solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int haveFree = 0, needHave = 0;
int el[6];
int main() {
int ii;
for (ii = 0; ii < 6; ii++) cin >> el[ii];
for (ii = 0; ii < 3; ii++) haveFree += max(0, ((el[ii] - el[ii + 3]) / 2));
for (ii = 0; ii < 3; ii++) needHave += max(0, (el[ii + 3] - el[ii]));
if (haveFree >= needHave)
cout << "Yes";
else
cout << "No";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long n) {
for (long long i = 2; i <= sqrt(n) + 1; i++) {
if (n % i == 0) return i;
}
return n;
}
int main() {
long long T;
cin >> T;
while (T--) {
long long n, k;
cin >> n >> k;
long long ans = n + f(n);
ans += (2 * (k - 1));
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double d, r1, r2, R1, R2;
bool ok(double rin, double rout, double r) {
if (d + r <= rin or (r + rout) <= d or d + rout <= r) return 1;
return 0;
}
int32_t main() {
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> r1 >> R1 >> x2 >> y2 >> r2 >> R2;
d = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
long long ans = 0;
if (ok(r1, R1, r2)) ans++;
if (ok(r2, R2, r1)) ans++;
if (ok(r1, R1, R2)) ans++;
if (ok(r2, R2, R1)) ans++;
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
int main() {
long x, y, z;
scanf("%ld %ld %ld\n", &x, &y, &z);
long p, q, r;
scanf("%ld %ld %ld\n", &p, &q, &r);
long a, b, c, d, e, f;
scanf("%ld %ld %ld %ld %ld %ld\n", &a, &b, &c, &d, &e, &f);
long total = a * (y < 0) + b * (y > q) + c * (z < 0) + d * (z > r) +
e * (x < 0) + f * (x > p);
printf("%ld\n", total);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int k[3], n, pos[200005];
int dp[200005][3];
int main() {
ios::sync_with_stdio(0);
for (int i = 0; i < 3; i++) cin >> k[i], n += k[i];
for (int t, p = 0; p < 3; p++)
for (int i = 1; i <= k[p]; i++) {
cin >> t, pos[t] = p;
}
for (int i = 1; i <= n; i++) {
dp[i][0] = dp[i - 1][0] + (pos[i] != 0);
dp[i][1] =
((dp[i - 1][0]) < (dp[i - 1][1]) ? (dp[i - 1][0]) : (dp[i - 1][1])) +
(pos[i] != 1);
dp[i][2] =
((dp[i - 1][0]) < (((dp[i - 1][1]) < (dp[i - 1][2]) ? (dp[i - 1][1])
: (dp[i - 1][2])))
? (dp[i - 1][0])
: (((dp[i - 1][1]) < (dp[i - 1][2]) ? (dp[i - 1][1])
: (dp[i - 1][2])))) +
(pos[i] != 2);
}
cout << ((dp[n][0]) < (((dp[n][1]) < (dp[n][2]) ? (dp[n][1]) : (dp[n][2])))
? (dp[n][0])
: (((dp[n][1]) < (dp[n][2]) ? (dp[n][1]) : (dp[n][2]))));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void dout() { cerr << '\n'; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << " " << H;
dout(T...);
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
struct poly {
int a[151];
poly() { memset(&a, 0, sizeof(a)); }
poly operator^(const poly& p) const {
poly res;
for (int i = 0; i < 151; i++) {
res.a[i] = a[i] ^ p.a[i];
}
return res;
}
poly operator<<(const int& x) const {
poly res;
for (int i = x; i < 151; i++) {
res.a[i] = a[i - x];
}
return res;
}
void output() {
int x = 0;
for (int i = 150; i >= 0; i--) {
if (a[i]) {
x = i;
break;
}
}
cout << x << '\n';
for (int i = 0; i <= x; i++) {
cout << a[i] << ' ';
}
cout << '\n';
}
};
poly p[151];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int n;
cin >> n;
p[0].a[0] = 1;
p[1].a[1] = 1;
for (int i = 2; i <= n; i++) {
p[i] = (p[i - 1] << 1) ^ p[i - 2];
}
p[n].output();
p[n - 1].output();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct PT {
double x, y;
PT() : x(0), y(0) {}
PT(double x, double y) : x(x), y(y) {}
PT(const PT& p) : x(p.x), y(p.y) {}
int operator<(const PT& rhs) const {
return make_pair(y, x) < make_pair(rhs.y, rhs.x);
}
int operator==(const PT& rhs) const {
return make_pair(y, x) == make_pair(rhs.y, rhs.x);
}
PT operator+(const PT& p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT& p) const { return PT(x - p.x, y - p.y); }
PT operator*(double c) const { return PT(x * c, y * c); }
PT operator/(double c) const { return PT(x / c, y / c); }
};
double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
double area(PT a, PT b, PT c) {
return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;
}
double area2(PT a, PT b, PT c) {
return cross(a, b) + cross(b, c) + cross(c, a);
}
double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
double dist(PT p, PT q) { return sqrt(dot(p - q, p - q)); }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
PT RotateCCW90(PT p) { return PT(-p.y, p.x); }
PT RotateCW90(PT p) { return PT(p.y, -p.x); }
PT RotateCCW(PT p, double t) {
return PT(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
int sign(double x) { return x < -1e-9 ? -1 : x > 1e-9; }
int sign(double x, double y) { return sign(x - y); }
ostream& operator<<(ostream& os, const PT& p) {
os << "(" << p.x << "," << p.y << ")";
return os;
}
bool between(const PT& a, const PT& b, const PT& c) {
return (fabs(area2(a, b, c)) < 1e-9 && (a.x - b.x) * (c.x - b.x) <= 0 &&
(a.y - b.y) * (c.y - b.y) <= 0);
}
void ConvexHull(vector<PT>& pts) {
sort(pts.begin(), pts.end());
pts.erase(unique(pts.begin(), pts.end()), pts.end());
vector<PT> up, dn;
for (int i = 0; i < pts.size(); i++) {
while (up.size() > 1 && area2(up[up.size() - 2], up.back(), pts[i]) >= 0)
up.pop_back();
while (dn.size() > 1 && area2(dn[dn.size() - 2], dn.back(), pts[i]) <= 0)
dn.pop_back();
up.push_back(pts[i]);
dn.push_back(pts[i]);
}
pts = dn;
for (int i = up.size() - 2; i >= 1; i--) pts.push_back(up[i]);
if (pts.size() <= 2) return;
dn.clear();
dn.push_back(pts[0]);
dn.push_back(pts[1]);
for (int i = 2; i < pts.size(); i++) {
if (between(dn[dn.size() - 2], dn[dn.size() - 1], pts[i])) dn.pop_back();
dn.push_back(pts[i]);
}
if (dn.size() >= 3 && between(dn.back(), dn[0], dn[1])) {
dn[0] = dn.back();
dn.pop_back();
}
pts = dn;
}
void pp(PT p) {
cout << (long long)floor(p.x + 0.5) << ' ' << (long long)floor(p.y + 0.5)
<< endl;
}
bool inside(PT p, PT a, PT b, PT c) {
return abs(area(p, a, b) + area(p, b, c) + area(p, c, a) - area(a, b, c)) <
1e-9;
}
int main() {
srand(time(NULL));
long long N, S;
cin >> N >> S;
vector<PT> pts(N);
for (int i = 0; i < N; i++) {
cin >> pts[i].x >> pts[i].y;
}
ConvexHull(pts);
N = pts.size();
for (int i = 0; i < N; i++) {
pts.push_back(pts[i]);
}
vector<int> ans;
double bst = 0;
for (int i = 0; i < N; i++) {
int pt = 2;
for (int base = 1; base <= N - 2; base++) {
int cur = i + base;
assert(i + base < pts.size());
while (pt < N - 1 && area(pts[i + pt + 1], pts[cur], pts[i]) >
area(pts[i + pt], pts[cur], pts[i])) {
pt++;
assert(i + pt < pts.size());
}
double h = area(pts[i + pt], pts[cur], pts[i]);
if (h > bst) {
ans = {i, cur, i + pt};
bst = h;
}
pt = max(pt, base + 1);
}
}
if (ans.empty()) {
cout << N << endl;
}
assert(!ans.empty());
PT p1 = pts[ans[0]] + pts[ans[1]] - pts[ans[2]];
PT p2 = pts[ans[1]] + pts[ans[2]] - pts[ans[0]];
PT p3 = pts[ans[0]] - pts[ans[1]] + pts[ans[2]];
pp(p1);
pp(p2);
pp(p3);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int dir[5][2] = {0, 1, 0, -1, 1, 0, -1, 0, 0, 0};
const int inf = 0x7fffffff;
const int mod = 1000000;
const int Max = 1000000;
int temp[10], ans[Max];
void check(char *s) {
int index = 0, dec, sum = 0, cnt = 0;
dec = atoi(s);
memset(temp, 0, sizeof(temp));
for (int i = 0; i < strlen(s); ++i) sum += s[i];
for (int i = max((dec - sum), 0); i <= dec; ++i) {
int temp = i, t = i;
while (temp) {
t += (temp % 10);
temp /= 10;
}
if (t == dec) {
ans[cnt++] = i;
}
}
printf("%d\n", cnt);
for (int i = 0; i < cnt; ++i) {
printf("%d%c", ans[i], i == cnt - 1 ? '\n' : ' ');
}
}
int main() {
char num[10];
scanf("%s", num);
check(num);
return 0;
}
| 2 |
#include <bits/stdc++.h>
char s[200000 + 5];
int n, u[200000 + 5];
bool solve() {
int i, sm = 0, ss = 0, sss = 0, x, y, a[10], an = 0, b[10], bn = 0;
for (i = 1; i <= n; ++i)
if (u[i])
sm += (s[i] - '0') * 10 + s[i + 1] - '0', ++i;
else
sm += s[i] - '0';
for (x = sm; sm; sm /= 10) ss += a[++an] = sm % 10;
for (y = ss; ss; ss /= 10) sss += b[++bn] = ss % 10;
if (sss < 10) {
for (i = 1; i <= n; ++i) {
if (i > 1) printf("+");
printf("%c", s[i]);
if (u[i]) printf("%c", s[++i]);
}
printf("\n");
for (i = an; i > 1; --i) printf("%d+", a[i]);
printf("%d\n", a[1]);
for (i = bn; i > 1; --i) printf("%d+", b[i]);
printf("%d\n", b[1]);
return false;
}
return true;
}
int main() {
scanf("%d%s", &n, s + 1);
for (int i = 1; solve();) {
for (; s[i] == '0'; ++i)
;
u[i] = 1;
i += 2;
}
}
| 8 |
#include <bits/stdc++.h>
int read() {
int ans = 0, c, f = 1;
while (!isdigit(c = getchar()))
if (c == '-') f *= -1;
do ans = ans * 10 + c - '0';
while (isdigit(c = getchar()));
return ans * f;
}
const int N = 500050;
const int mod = 1000000007;
int n, pre[N], nxt[N * 2], to[N * 2], cnt;
struct Edges {
int len, deg;
std::vector<int> left, right;
Edges() : len(1), deg(1) {
left.push_back(0);
right.push_back(0);
}
int insert() {
left.push_back(len);
right.push_back(len);
deg++;
return len++;
}
bool merge(int x, int y) {
if (right[x] != x || left[y] != y || deg == 0) return false;
if (left[x] == y && deg != 1) return false;
--deg;
left[y] = left[right[y]] = left[x];
right[x] = right[left[x]] = right[y];
return true;
}
} e[N];
int posu[N], posd[N], dep[N], fa[N];
void dfs(int x) {
for (int i = pre[x]; ~i; i = nxt[i])
if (to[i] != fa[x]) {
int y = to[i];
fa[y] = x;
dep[y] = dep[x] + 1;
posu[y] = e[x].insert();
posd[y] = e[y].insert();
dfs(y);
}
}
bool get(int x, int y) {
int u = 0, v = 0;
while (x != y)
if (dep[x] > dep[y]) {
if (!e[x].merge(u, posd[x])) return false;
u = posu[x];
x = fa[x];
} else {
if (!e[y].merge(posd[y], v)) return false;
v = posu[y];
y = fa[y];
}
return e[x].merge(u, v);
}
long long fac[N];
inline void addEdge(int x, int y) {
nxt[cnt] = pre[x];
to[pre[x] = cnt++] = y;
nxt[cnt] = pre[y];
to[pre[y] = cnt++] = x;
}
int main() {
int n = read();
memset(pre, -1, sizeof pre);
for (int i = 1; i < n; ++i) addEdge(read(), read());
dfs(1);
for (int i = 1; i <= n; ++i) {
int x = read();
if (!x) continue;
if (!get(i, x)) {
puts("0");
return 0;
}
}
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = fac[i - 1] * i % mod;
long long ans = 1;
for (int i = 1; i <= n; ++i)
if (e[i].deg) ans = ans * fac[e[i].deg - 1] % mod;
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
n *= 2;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
long long mn = 0;
for (int i = 0; i < n - 1; i++) {
if (arr[i] == arr[i + 1]) {
continue;
}
for (int j = i + 1; j < n; j++) {
if (arr[j] == arr[i]) {
mn += (j - i - 1);
for (int s = j; s > i + 1; s--) {
arr[s] = arr[s - 1];
}
arr[i + 1] = arr[i];
}
}
}
cout << mn << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, m, k;
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d%d%d", &n, &m, &k);
int c1 = n / m, c2 = (n + m - 1) / m;
int num = n - c1 * m;
if (!num) num = m;
int st = 1;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= num; j++) {
printf("%d ", c2);
for (int k = 0; k < c2; k++)
printf("%d ", st), st = (st - 1 + 1) % n + 1;
puts("");
}
int st1 = st;
for (int j = 1; j <= m - num; j++) {
printf("%d ", c1);
for (int k = 0; k < c1; k++)
printf("%d ", st1), st1 = (st1 - 1 + 1) % n + 1;
puts("");
}
}
puts("");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int ans = 0;
int n, l, dp[105][3105][5];
vector<pair<int, int> > boards;
long long int solve(int prevIndex, int currTotalLength, int isRotated);
int main() {
cin >> n >> l;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
boards.push_back(make_pair(a, b));
}
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
if (boards[i].first != boards[i].second) {
ans += solve(i, boards[i].first, 0);
ans += solve(i, boards[i].second, 1);
} else
ans += solve(i, boards[i].first, 0);
}
cout << ans % 1000000007 << endl;
return 0;
}
long long int solve(int currIndex, int currTotalLength, int isRotated) {
if (currTotalLength > l) return 0;
if (currTotalLength == l) return 1;
if (dp[currIndex][currTotalLength][isRotated] != -1) {
return dp[currIndex][currTotalLength][isRotated];
}
long long int counter = 0;
for (int i = 0; i < n; i++) {
if (i != currIndex) {
if (boards[i].first != boards[i].second) {
if (isRotated == 0) {
if (boards[i].first == boards[currIndex].second)
counter += solve(i, currTotalLength + boards[i].first, 0);
else if (boards[i].second == boards[currIndex].second)
counter += solve(i, currTotalLength + boards[i].second, 1);
} else {
if (boards[i].first == boards[currIndex].first)
counter += solve(i, currTotalLength + boards[i].first, 0);
else if (boards[i].second == boards[currIndex].first)
counter += solve(i, currTotalLength + boards[i].second, 1);
}
} else {
if (isRotated == 0) {
if (boards[i].first == boards[currIndex].second)
counter += solve(i, currTotalLength + boards[i].first, 0);
} else {
if (boards[i].first == boards[currIndex].first)
counter += solve(i, currTotalLength + boards[i].first, 0);
}
}
}
}
return dp[currIndex][currTotalLength][isRotated] = counter % 1000000007;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vpii = vector<pii>;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
using vll = vector<long long>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <class T>
istream &operator>>(istream &, vector<T> &);
template <class T>
ostream &operator<<(ostream &, const vector<T> &);
template <class T, class U>
istream &operator>>(istream &, pair<T, U> &);
template <class T, class U>
ostream &operator<<(ostream &, const pair<T, U> &);
template <class T>
struct Inf {
static constexpr T inf() {
return std::numeric_limits<T>::has_infinity()
? std::numeric_limits<T>::infinty()
: std::numeric_limits<T>::max();
}
};
template <>
struct Inf<int> {
static constexpr int inf() { return 0x3f3f3f3f; }
};
template <>
struct Inf<long long> {
static constexpr long long inf() { return 0x3f3f3f3f3f3f3f3fLL; }
};
constexpr int INF = Inf<int>::inf();
constexpr ll BINF = Inf<ll>::inf();
template <class T>
class Fenwick {
private:
std::vector<T> arr;
int sz;
T myQuery(int idx) {
T rt{};
for (; idx > 0; idx -= idx & -idx) rt += arr[idx];
return rt;
}
void myUpdate(int idx, T val) {
for (; idx <= sz; idx += idx & -idx) arr[idx] += val;
}
public:
Fenwick(int n) : arr(n + 1), sz(n) {}
T query(int x) { return myQuery(x + 1); }
T query(int l, int r) { return query(r) - query(l - 1); }
void update(int x, T v) { myUpdate(x + 1, v); }
};
int solve() {
int n;
cin >> n;
vvi g(n);
for (int i = 0; i + 1 < n; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
vector<vector<pii>> qry(n);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int r, d, x;
cin >> r >> d >> x;
r--;
qry[r].emplace_back(d, x);
}
vi dist(n);
vll ans(n);
Fenwick<ll> psum(n);
function<void(int, int)> dfs = [&](int u, int p) {
for (auto [d, x] : qry[u]) {
psum.update(min(dist[u] + d, n - 1), x);
}
ans[u] = psum.query(dist[u], n - 1);
for (int v : g[u])
if (v - p) {
dist[v] = dist[u] + 1;
dfs(v, u);
}
for (auto [d, x] : qry[u]) {
psum.update(min(dist[u] + d, n - 1), -x);
}
};
dfs(0, -1);
cout << ans;
return 0;
}
int main() {
ios::sync_with_stdio(0);
solve();
return 0;
}
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) is >> *it;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto it = v.begin(); it != v.end();)
os << *it, os << " \n"[++it == v.end()];
return os;
}
template <class T, class U>
istream &operator>>(istream &is, pair<T, U> &p) {
return is >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << p.first << ' ' << p.second;
}
| 5 |
#include <bits/stdc++.h>
int a[11], l[11][11];
int n, ans = 0;
void count(int now, int last) {
int i;
if (now > n)
ans++;
else
for (i = 1; i <= last + 1; i++)
count(now + 1, ((last) > (i) ? (last) : (i)));
}
void print() {
int i, j, s = 0;
for (i = 0; i < n; i++) l[i][0] = 0;
for (i = 1; i <= n; i++) l[a[i]][++l[a[i]][0]] = i;
for (i = 0; l[i][0]; i++) {
if (i) putchar(',');
putchar('{');
for (j = 1; j <= l[i][0]; j++) {
if (j > 1) putchar(',');
printf("%d", l[i][j]);
}
putchar('}');
}
putchar('\n');
}
void dfs(int now, int last) {
int i;
if (now > n)
print();
else if (!a[now]) {
dfs(now + 1, last);
for (i = last + 1; i; i--) {
a[now] = i;
dfs(now + 1, ((last) > (i) ? (last) : (i)));
}
} else {
for (i = 1; i <= last + 1; i++) {
a[now] = i;
dfs(now + 1, ((last) > (i) ? (last) : (i)));
}
a[now] = 0;
dfs(now + 1, last);
}
}
int main() {
scanf("%d", &n);
count(1, 0);
printf("%d\n", ans);
dfs(2, 0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[100010];
char s[100010];
void solve() {
int i, j, ans, val;
m = n;
while (m && s[m - 1] == '0') m--;
if (m == 0) {
printf("0\n");
return;
}
ans = 0;
val = 0;
for (i = 0; i < m; i++)
if (s[i] == '1') {
ans = max(ans + a[i], val);
val += a[i];
} else {
for (j = i; j < m && s[j] == '0'; j++) val += a[j];
i = j - 1;
}
printf("%d\n", ans);
}
void input() {
int i;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
scanf("%s", &s);
solve();
}
int main() {
input();
fclose(stdin);
fclose(stdout);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int maxn = 1e5 + 5;
const long long inf = 1e9 + 7;
int a[maxn], b[maxn];
int main() {
unsigned long long ans = (unsigned long long)3 << 62, sa = 0, sb = 0, cur = 0;
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
sa += (unsigned long long)a[i];
}
for (int i = 0; i < m; i++) {
scanf("%d", b + i);
sb += (unsigned long long)b[i];
}
sort(a, a + n);
sort(b, b + m);
for (int i = 0; i < n; i++) {
ans = min(ans, cur + (unsigned long long)(n - i) * sb);
cur += a[i];
}
cur = 0;
for (int i = 0; i < m; i++) {
ans = min(ans, cur + (unsigned long long)(m - i) * sa);
cur += b[i];
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 100;
long long mp[N], dp[N];
long long fp(long long b, long long exp) {
if (exp == 0) return 1;
if (exp == 1) return b;
long long half = fp(b, exp / 2);
if (exp % 2 == 1)
return (half * half) % 1000000007 * b % 1000000007;
else
return half * half % 1000000007;
}
int main() {
long long t, l, r;
cin >> t >> l >> r;
for (int i = (2); i <= (N - 1); i++) mp[i] = i;
for (int i = (2); i <= (sqrt(N) + 1); i++) {
if (mp[i] == i) {
int j = 2;
int cur = i * j;
while (cur < N) {
mp[cur] = min(mp[cur], (long long)i);
j++;
cur = i * j;
}
}
}
dp[0] = dp[1] = 0;
for (int i = (2); i <= (N - 1); i++) {
dp[i] = (i * (mp[i] - 1) / 2 + dp[i / mp[i]]) % 1000000007;
}
long long ans = 0;
long long curt = 1;
for (int i = (l); i <= (r); i++) {
ans = (ans + (curt * dp[i]) % 1000000007) % 1000000007;
curt = curt * t % 1000000007;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, ans[100005], x, num;
char ch;
stack<int> v;
int main() {
cin >> n;
num = 1;
for (int i = 1; i <= 2 * n; i++) {
cin >> ch;
if (ch == '+') {
v.push(num++);
} else {
cin >> x;
if (v.empty()) {
cout << "NO";
return 0;
} else if (x < ans[v.top() + 1]) {
cout << "NO";
return 0;
}
ans[v.top()] = x;
v.pop();
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
cout << ans[i];
if (i != n) cout << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long n, m, k, a, b, s[200], f[200];
unsigned long long ss;
int main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> s[i];
}
f[0] = 1;
f[1] = 1;
for (long long i = 2; i <= 102; i++) {
f[i] = f[i - 1] + f[i - 2];
f[i] = f[i] % 1000000000;
}
for (long long i = 1; i <= m; i++) {
cin >> k;
if (k == 1) {
cin >> a >> b;
s[a] = b;
} else {
cin >> a >> b;
ss = 0;
for (long long j = a; j <= b; j++) {
ss += (f[j - a] * s[j]);
}
cout << ss % 1000000000 << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9;
const int Mod = 1e9 + 7;
const long long OO = 1e18;
const int N = 1e5 + 5;
int test, n;
void file() {
if (fopen("trash.inp", "r"))
freopen("trash.inp", "r", stdin), freopen("trash.out", "w", stdout);
}
void in() {
cin >> n;
for (int i = 1; i <= n; i++) cout << i << " ";
cout << '\n';
}
void solve() {}
int main() {
file();
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> test;
while (test--) {
in();
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 107;
const long long mod = 1e9 + 7;
const int rx[8] = {1, -1, 0, 0, 1, 1, -1, -1};
const int ry[8] = {0, 0, 1, -1, 1, -1, 1, -1};
const long double pi = acos(-1.0);
const int B = (int)sqrt(N);
int d[16 / 2][2 * 4];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string lada1, lada2, korol, black;
cin >> lada1 >> lada2 >> korol >> black;
int l1x = lada1[0] - 'a', l1y = lada1[1] - '1';
int l2x = lada2[0] - 'a', l2y = lada2[1] - '1';
int kx = korol[0] - 'a', ky = korol[1] - '1';
int bx = black[0] - 'a', by = black[1] - '1';
d[kx][ky] = 2;
for (int i = 0; i < 4; ++i) {
int x = l1x + rx[i], y = l1y + ry[i];
while (x > -1 && y > -1 && x < 16 / 2 && y < 2 * 4 && d[x][y] != 2) {
d[x][y] = 1;
x += rx[i], y += ry[i];
}
}
for (int i = 0; i < 4; ++i) {
int x = l2x + rx[i], y = l2y + ry[i];
while (x > -1 && y > -1 && x < 16 / 2 && y < 2 * 4 && d[x][y] != 2) {
d[x][y] = 1;
x += rx[i], y += ry[i];
}
}
for (int i = max(0, kx - 1); i < min(8, kx + 2); ++i)
for (int j = max(0, ky - 1); j < min(8, ky + 2); ++j) d[i][j] = 1;
for (int i = max(0, bx - 1); i < min(8, bx + 2); ++i)
for (int j = max(0, by - 1); j < min(8, by + 2); ++j)
if (!d[i][j]) {
cout << "OTHER" << '\n';
return 0;
}
cout << "CHECKMATE" << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long maxval = 1e9;
int main() {
long long n, m;
cin >> n >> m;
map<long long, bool> used;
for (long long i = 0; i < n; ++i) {
long long x;
cin >> x;
used[x] = true;
}
long long sum = 0;
vector<long long> dist;
for (long long i = 1; i <= maxval; ++i) {
if (i + sum > m) break;
if (used[i]) continue;
sum += i;
dist.push_back(i);
}
cout << dist.size() << endl;
for (long long i = 0; i < dist.size(); ++i) {
cout << dist[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
char c = getchar();
long long ans = 0;
while (!isdigit(c)) c = getchar();
while (isdigit(c)) ans = ans * 10 + c - '0', c = getchar();
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
map<long long, vector<char> > ok;
string ans = "-1";
string s[n];
for (long long i = 0; i < n; i++) {
cin >> s[i];
for (long long j = 0; j < m; j++) {
ok[j].push_back(s[i][j]);
}
}
bool done = false;
for (long long i = 0; i < n and done == false; i++) {
string check = s[i];
for (long long j = 0; j < m; j++) {
vector<char> o = ok[j];
for (char ch : o) {
check = s[i];
check[j] = ch;
bool can = true;
for (long long k = 0; k < n and can; k++) {
long long c = 0;
for (long long l = 0; l < m and can; l++) {
if (s[k][l] != check[l]) {
c++;
}
if (c > 1) {
can = false;
}
}
}
if (can) {
cout << check << endl;
done = true;
break;
}
}
if (done) break;
}
}
if (done == false) cout << "-1" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void in(int &x) {
x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
int n, k, dis[200][200], D[200], best[200], dp[200][200], ans[200];
bool edge[200][200];
void dfs(int from, int f) {
for (int to = 1; to <= n; ++to)
if (edge[from][to] && to != f) {
dfs(to, from);
}
for (int i = 1; i <= n; ++i) {
dp[from][i] = D[dis[from][i]] + k;
for (int to = 1; to <= n; ++to)
if (edge[from][to] && to != f) {
dp[from][i] += min(dp[to][i] - k, dp[to][best[to]]);
}
if (!best[from] || dp[from][best[from]] > dp[from][i]) best[from] = i;
}
}
void get_ans(int from, int f) {
if (!f)
ans[from] = best[from];
else {
if (dp[from][ans[f]] - k > dp[from][best[from]])
ans[from] = best[from];
else
ans[from] = ans[f];
}
for (int to = 1; to <= n; ++to)
if (edge[from][to] && to != f) get_ans(to, from);
}
int main() {
in(n);
in(k);
for (int i = 1; i < n; ++i) in(D[i]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j) dis[i][j] = n;
for (int i = 1; i < n; ++i) {
int x, y;
in(x);
in(y);
edge[x][y] = edge[y][x] = dis[x][y] = dis[y][x] = 1;
}
for (int k = 1; k <= n; ++k)
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (dis[i][k] + dis[k][j] < dis[i][j])
dis[i][j] = dis[i][k] + dis[k][j];
dfs(1, 0);
printf("%d\n", dp[1][best[1]]);
get_ans(1, 0);
for (int i = 1; i <= n; ++i) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
long long mod = 1e9 + 7;
long long fmod(long long b, long long exp) {
long long res = 1;
while (exp) {
if (exp & 1ll) res = (res * b) % mod;
b = (b * b) % mod;
exp /= 2ll;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int m, i, j, k, x, q;
int t = 1;
long long n, b, g;
cin >> b >> g >> n;
long long mxb = min(n, b);
long long mxg = min(n, g);
long long mnb = max(0ll, min(b, n - mxg));
long long mng = max(0ll, min(g, n - mxb));
long long ind1 = min(mng, n - mxb);
long long ind2 = max(mxg, n - mnb);
cout << max(1ll, ind2 - ind1 + 1) << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int SIZE = 1e6 + 5;
const long long INF = 1LL << 58;
const double eps = 1e-10;
int p[10009];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int cm = 0;
for (int i = 0; i < (n); ++i) p[i] = i;
do {
int ans = 0;
for (int i = 0; i < (n); ++i) {
int cv = p[i];
ans += cv;
for (int j = (i + 1); j < (n); ++j) {
cv = min(cv, p[j]);
ans += cv;
}
}
cm = max(ans, cm);
} while (next_permutation(p, p + n));
for (int i = 0; i < (n); ++i) p[i] = i;
int cc = 0;
do {
int ans = 0;
for (int i = 0; i < (n); ++i) {
int cv = p[i];
ans += cv;
for (int j = (i + 1); j < (n); ++j) {
cv = min(cv, p[j]);
ans += cv;
}
}
if (ans == cm) {
cc++;
if (cc == m) {
for (int i = 0; i < (n); ++i) {
printf("%d ", p[i] + 1);
}
}
}
} while (next_permutation(p, p + n));
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > graph(100010);
int second[100010];
int degrees[100010] = {0};
long long mx = 0;
int n;
void dfs(int u = 1, int parent = 0, long long sum = 0) {
for (pair<int, int> p : graph[u]) {
if (p.first == parent) continue;
mx = max(mx, sum + p.second);
dfs(p.first, u, sum + p.second);
}
}
int main() {
int n;
cin >> n;
long long ans = 0;
for (int i = 0, u, first, second; i < n - 1; i++) {
scanf("%d %d %d", &u, &first, &second);
graph[u].push_back({first, second});
graph[first].push_back({u, second});
degrees[u]++;
degrees[first]++;
ans += second;
}
dfs();
cout << 2 * ans - mx << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long double n, p, a[100001], b[100001], sum;
bool Ver(long double time) {
long double x = 0;
for (int i = 1; i <= n; i++) {
x += max((long double)0, time * a[i] - b[i]);
}
return p * time >= x;
}
int main() {
cin >> n >> p;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i];
for (int i = 1; i <= n; i++) sum += a[i];
if (sum <= p) {
cout << "-1";
return 0;
}
long double li, ls, mid;
li = 0;
ls = 1000000000000000000;
for (int i = 1; i <= 300; i++) {
mid = (li + ls) / 2;
if (Ver(mid))
li = mid;
else
ls = mid;
}
cout << fixed << setprecision(10) << mid;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[501][501];
int a[501];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) dp[i][i] = 1;
for (int i = 1; i < n; i++)
if (a[i] == a[i + 1])
dp[i][i + 1] = 1;
else
dp[i][i + 1] = 2;
for (int k = 3; k <= n; k++)
for (int l = 1;; l++) {
int r = l + k - 1;
if (r > n) break;
dp[l][r] = 2000000000;
if (a[l] == a[r]) dp[l][r] = dp[l + 1][r - 1];
for (int mid = l; mid < r; mid++)
dp[l][r] = min(dp[l][r], dp[l][mid] + dp[mid + 1][r]);
}
printf("%d", dp[1][n]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int fro[105];
int lef[105];
int top[105][105];
int main() {
int N, M, H;
cin >> N >> M >> H;
int cnt = 0;
for (int i = 1; i <= M; i++) {
cin >> fro[i];
if (fro[i] != 0) cnt++;
}
for (int i = 1; i <= N; i++) {
cin >> lef[i];
}
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) cin >> top[i][j];
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (top[i][j] == 1) {
top[i][j] = lef[i];
}
}
}
while (cnt) {
int last = 0;
int index = 0;
for (int i = 1; i <= N; i++) {
if (lef[i] > last) {
index = i;
last = lef[i];
}
}
lef[index] = 0;
for (int i = 1; i <= M; i++) {
if (fro[i] != 0) {
for (int j = 1; j <= N; j++) {
if (top[j][i] > fro[i]) top[j][i] = fro[i];
}
fro[i] = 0;
cnt--;
}
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
cout << top[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<string, long long> p1, pair<string, long long> p2) {
if (p1.second > p2.second) return true;
return false;
}
int32_t main() {
srand(time(NULL));
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, bi;
string ai;
long long samples = 0;
vector<pair<string, long long> > v;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> ai >> bi;
v.push_back(make_pair(ai, bi));
samples += bi;
}
sort(v.begin(), v.end(), cmp);
set<string> free_first, free_second, rf, rs;
long long ind = -1;
for (long long i = 1; i <= samples; i++) {
string ss;
long long ii = i;
while (ii != 0) {
ss += (char)(ii % 10 + '0');
ii /= 10;
}
string ss1 = "";
for (long long j = ss.size() - 1; j >= 0; j--) {
ss1 += ss[j];
}
free_first.insert(ss1);
rf.insert(ss1);
}
for (long long i = samples + 1; i <= n; i++) {
string ss;
long long ii = i;
while (ii != 0) {
ss += (char)(ii % 10 + '0');
ii /= 10;
}
string ss1 = "";
for (long long j = ss.size() - 1; j >= 0; j--) {
ss1 += ss[j];
}
free_second.insert(ss1);
rs.insert(ss1);
}
for (long long i = 0; i < samples; i++) {
if (free_second.count(v[i].first)) {
ind = i;
}
}
for (long long i = 0; i < n; i++) {
string str = v[i].first;
if (free_first.count(str)) {
free_first.erase(str);
}
if (free_second.count(str)) {
free_second.erase(str);
}
}
vector<pair<string, string> > ans;
if (free_first.size() == 0 && free_second.size() == 0) {
if (ind == -1) {
cout << 0 << endl;
return 0;
}
free_second.insert(v[ind].first);
string pps = "";
for (long long j = 0; j < 6; j++) {
long long rn = rand() % 26;
pps += (char)('a' + rn);
}
ans.push_back(make_pair(v[ind].first, pps));
v[ind].first = pps;
}
if (free_second.size() > 0) {
vector<long long> nons;
for (long long i = samples; i < n; i++) {
if (rf.count(v[i].first)) {
nons.push_back(i);
}
}
for (long long i = 0; i < samples; i++) {
if (rf.count(v[i].first)) continue;
if (!rs.count(v[i].first)) continue;
if (free_first.size() != 0) {
string ff = *free_first.begin();
free_first.erase(ff);
if (rs.count(v[i].first)) {
free_second.insert(v[i].first);
}
ans.push_back(make_pair(v[i].first, ff));
v[i].first = ff;
continue;
}
long long index = nons.back();
nons.pop_back();
string newf = v[i].first;
string free = *free_second.begin();
free_second.erase(free);
string old = v[index].first;
ans.push_back(make_pair(v[index].first, free));
v[index].first = free;
ans.push_back(make_pair(newf, old));
v[i].first = old;
free_second.insert(newf);
}
for (long long i = 0; i < samples; i++) {
if (rf.count(v[i].first)) continue;
if (free_first.size() != 0) {
string ff = *free_first.begin();
free_first.erase(ff);
if (rs.count(v[i].first)) {
free_second.insert(v[i].first);
}
ans.push_back(make_pair(v[i].first, ff));
v[i].first = ff;
continue;
}
long long index = nons.back();
nons.pop_back();
string newf = v[i].first;
string free = *free_second.begin();
free_second.erase(free);
string old = v[index].first;
ans.push_back(make_pair(v[index].first, free));
v[index].first = free;
ans.push_back(make_pair(newf, old));
v[i].first = old;
}
for (long long i = samples; i < n; i++) {
if (!rs.count(v[i].first)) {
string free = *free_second.begin();
free_second.erase(free);
ans.push_back(make_pair(v[i].first, free));
v[i].first = free;
}
}
} else {
vector<long long> nons;
for (long long i = 0; i < samples; i++) {
if (rs.count(v[i].first)) {
nons.push_back(i);
}
}
for (long long i = samples; i < n; i++) {
if (rs.count(v[i].first)) continue;
if (!rf.count(v[i].first)) continue;
if (free_second.size() != 0) {
string ff = *free_second.begin();
free_second.erase(ff);
if (rf.count(v[i].first)) {
free_first.insert(v[i].first);
}
ans.push_back(make_pair(v[i].first, ff));
v[i].first = ff;
continue;
}
long long index = nons.back();
nons.pop_back();
string newf = v[i].first;
string free = *free_first.begin();
free_first.erase(free);
string old = v[index].first;
ans.push_back(make_pair(v[index].first, free));
v[index].first = free;
ans.push_back(make_pair(newf, old));
v[i].first = old;
free_first.insert(newf);
}
for (long long i = samples; i < n; i++) {
if (rs.count(v[i].first)) continue;
if (free_second.size() != 0) {
string ff = *free_second.begin();
free_second.erase(ff);
if (rs.count(v[i].first)) {
free_second.insert(v[i].first);
}
ans.push_back(make_pair(v[i].first, ff));
v[i].first = ff;
continue;
}
long long index = nons.back();
nons.pop_back();
string newf = v[i].first;
string free = *free_first.begin();
free_first.erase(free);
string old = v[index].first;
ans.push_back(make_pair(v[index].first, free));
v[index].first = free;
ans.push_back(make_pair(newf, old));
v[i].first = old;
}
for (long long i = 0; i < samples; i++) {
if (!rf.count(v[i].first)) {
string free = *free_first.begin();
free_first.erase(free);
ans.push_back(make_pair(v[i].first, free));
v[i].first = free;
}
}
}
cout << ans.size() << endl;
for (long long i = 0; i < ans.size(); i++) {
cout << "move " << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long Mpow(long long x, unsigned long long y, long long m) {
long long res = 1;
x = x % m;
while (y > 0) {
if (y & 1) res = (res * x) % m;
y = y >> 1;
x = (x * x) % m;
}
return res;
}
long long fc[500001], ifc[500001];
long long ncr(long long n, long long r) {
if (r > n) return 0;
long long rs = fc[n];
rs *= ifc[r];
rs %= 1000000007;
rs *= ifc[n - r];
rs %= 1000000007;
return rs;
}
int32_t main() {
long long i, j, lt, d, z, v, c, r, l, q, x, y, m, n, x1, y1, t1, k;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
fc[0] = 1;
ifc[0] = 1;
for (i = 1; i < 500001; i++) {
fc[i] = (fc[i - 1] * i) % 1000000007;
ifc[i] = Mpow(fc[i], 1000000007 - 2, 1000000007);
}
cin >> s;
n = s.length();
long long lfo[n + 2], rtc[n + 2];
lfo[0] = 0;
rtc[n + 1] = 0;
for (i = 1; i <= n; i++) {
lfo[i] = lfo[i - 1];
if (s[i - 1] == '(') lfo[i]++;
}
for (i = n; i >= 1; i--) {
rtc[i] = rtc[i + 1];
if (s[i - 1] == ')') rtc[i]++;
}
m = 0;
for (i = 1; i <= n; i++) {
if (s[i - 1] == ')') continue;
x = lfo[i] - 1;
y = rtc[i];
z = (y * fc[x + y]) % 1000000007;
k = (fc[x] * fc[y]) % 1000000007;
k = (k * (x + 1)) % 1000000007;
z = (z * Mpow(k, 1000000007 - 2, 1000000007)) % 1000000007;
z = (z + 1000000007) % 1000000007;
m += z;
m = (m + 1000000007) % 1000000007;
}
cout << m % 1000000007 << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
bool p[N][N][N];
char buf[N + 20];
bool check(int i, int j, int k) {
if (p[i][j][k] == false) return false;
if (p[i - 1][j][k] && p[i + 1][j][k] || p[i][j - 1][k] && p[i][j + 1][k] ||
p[i][j][k - 1] && p[i][j][k + 1])
return true;
if (!p[i - 1][j][k] && !p[i][j - 1][k] && !p[i][j][k - 1] ||
!p[i + 1][j][k] && !p[i][j + 1][k] && !p[i][j][k + 1])
return false;
bool ii = p[i - 1][j][k], ji = p[i][j - 1][k], ki = p[i][j][k - 1];
bool io = p[i + 1][j][k], jo = p[i][j + 1][k], ko = p[i][j][k + 1];
if (ii + ji + ki == 1 && io + jo + ko == 1) {
if (ii) {
if (jo) {
if (p[i - 1][j + 1][k])
return false;
else
return true;
}
if (ko) {
if (p[i - 1][j][k + 1])
return false;
else
return true;
}
cerr << "never" << endl;
}
if (ji) {
if (io) {
if (p[i + 1][j - 1][k])
return false;
else
return true;
}
if (ko) {
if (p[i][j - 1][k + 1])
return false;
else
return true;
}
cerr << "never" << endl;
}
if (ki) {
if (io) {
if (p[i + 1][j][k - 1])
return false;
else
return true;
}
if (jo) {
if (p[i][j + 1][k - 1])
return false;
else
return true;
}
cerr << "never" << endl;
}
cerr << "never 1" << endl;
} else if (ii + ji + ki == 2 && io + jo + ko == 1) {
if (io) {
if (p[i + 1][j - 1][k] && p[i + 1][j][k - 1])
return false;
else
return true;
} else if (jo) {
if (p[i - 1][j + 1][k] && p[i][j + 1][k - 1])
return false;
else
return true;
} else if (ko) {
if (p[i - 1][j][k + 1] && p[i][j - 1][k + 1])
return false;
else
return true;
}
cerr << "never 2" << endl;
} else if (ii + ji + ki == 1 && io + jo + ko == 2) {
if (ii) {
if (p[i - 1][j][k + 1] && p[i - 1][j + 1][k])
return false;
else
return true;
} else if (ji) {
if (p[i + 1][j - 1][k] && p[i][j - 1][k + 1])
return false;
else
return true;
} else if (ki) {
if (p[i + 1][j][k - 1] && p[i][j + 1][k - 1])
return false;
else
return true;
}
cerr << "never 3" << endl;
}
cerr << "never 4" << endl;
return false;
}
int main() {
int n, m, kk;
scanf("%d %d %d\n", &n, &m, &kk);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
gets(buf + 1);
for (int k = 1; k <= kk; k++) {
p[i][j][k] = (buf[k] == '1');
}
}
if (i < n) gets(buf);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int k = 1; k <= kk; k++) {
ans += check(i, j, k);
}
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int parent[1001], parent1[1001], sz[1001], sz1[1001];
int find_set(int p) {
if (parent[p] != p) parent[p] = find_set(parent[p]);
return parent[p];
}
void union_set(int a, int b) {
a = find_set(a);
b = find_set(b);
if (sz[a] > sz[b]) swap(a, b);
if (a == b) return;
sz[b] += sz[a];
sz[a] = 0;
parent[a] = b;
}
int find_set1(int p) {
if (parent1[p] != p) parent1[p] = find_set1(parent1[p]);
return parent1[p];
}
void union_set1(int a, int b) {
a = find_set1(a);
b = find_set1(b);
if (sz1[a] > sz1[b]) swap(a, b);
if (a == b) return;
sz1[b] += sz1[a];
sz1[a] = 0;
parent1[a] = b;
}
int main() {
int n, m, m1;
cin >> n >> m >> m1;
for (int i = 1; i <= n; i++) {
sz[i] = sz1[i] = 1;
parent[i] = parent1[i] = i;
}
while (m--) {
int a, b;
cin >> a >> b;
union_set(a, b);
}
while (m1--) {
int a, b;
cin >> a >> b;
union_set1(a, b);
}
vector<pair<int, int> > ans;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (find_set(i) != find_set(j) && find_set1(i) != find_set1(j)) {
ans.push_back(make_pair(i, j));
union_set(i, j);
union_set1(i, j);
break;
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const nmax = 100;
string v[1 + nmax], v2[1 + nmax];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, q;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> v[i - 1];
for (int i = 1; i <= m; i++) cin >> v2[i - 1];
cin >> q;
for (int i = 1; i <= q; i++) {
int x;
cin >> x;
x--;
cout << v[x % n] << v2[x % m] << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int is_big[100010], big[360];
long long delta[360], res[360];
int same[360][100010];
int sz[100010], cnt[100010];
long long arr[100010];
vector<int> num[100010];
int main() {
int n, m, q, tot = 0;
memset(is_big, -1, sizeof(is_big));
scanf("%d%d%d", &n, &m, &q);
int limit = ceil(sqrt(n));
for (int i = 0; i < n; i++) scanf("%lld", arr + i);
for (int i = 0; i < m; i++) {
scanf("%d", sz + i);
for (int j = 0; j < sz[i]; j++) {
int x;
scanf("%d", &x);
num[i].push_back(--x);
}
if (sz[i] > limit) {
is_big[i] = tot;
big[tot] = i;
tot++;
}
}
for (int i = 0; i < tot; i++) {
for (int j = 0; j < sz[big[i]]; j++) {
res[i] += arr[num[big[i]][j]];
cnt[num[big[i]][j]]++;
}
for (int j = 0; j < m; j++) {
for (int k = 0; k < sz[j]; k++) same[i][j] += cnt[num[j][k]];
}
for (int j = 0; j < sz[big[i]]; j++) cnt[num[big[i]][j]]--;
}
for (int i = 0; i < tot; i++) cnt[big[i]] = i;
while (q--) {
char tp;
scanf("\n%c", &tp);
if (tp == '?') {
int x;
scanf("%d", &x);
x--;
if (is_big[x] == -1) {
long long ans = 0;
for (int i = 0; i < sz[x]; i++) ans += arr[num[x][i]];
for (int i = 0; i < tot; i++) ans += (long long)same[i][x] * delta[i];
printf("%lld\n", ans);
} else {
long long ans = res[cnt[x]];
for (int i = 0; i < tot; i++) ans += (long long)same[i][x] * delta[i];
printf("%lld\n", ans);
}
} else {
int x, y;
scanf("%d%d", &x, &y);
x--;
if (is_big[x] == -1) {
for (int i = 0; i < sz[x]; i++) arr[num[x][i]] += y;
for (int i = 0; i < tot; i++) res[i] += (long long)same[i][x] * y;
} else
delta[cnt[x]] += y;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int N = 200005;
std::bitset<N> an, f[27];
int q, opt, l, r, pos;
char st[N], s[N], c;
int main() {
scanf("%s", st + 1);
int n = strlen(st + 1);
for (int i = 1; i <= n; i++) f[st[i] - 'a'][i] = 1;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d %c", &pos, &c);
f[st[pos] - 'a'][pos] = 0;
f[c - 'a'][pos] = 1;
st[pos] = c;
} else {
scanf("%d%d%s", &l, &r, s + 1);
an.set();
int len = strlen(s + 1);
for (int j = 1; j <= len; j++) an &= f[s[j] - 'a'] >> (j - 1);
int anl = (an >> l).count(), anr = (an >> (r - len + 2)).count();
if (anl < anr) anl = anr;
printf("%d\n", anl - anr);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long num = 0, flag = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
while (c >= '0' && c <= '9') num = num * 10 + c - 48, c = getchar();
return num * flag;
}
int n, k;
int cnt[2400005], ans[2400005], fac[2400005], inv[2400005];
int A[2400005], B[2400005], L, rev[2400005];
inline int ksm(int num, int k) {
int ret = 1;
for (; k; k >>= 1, num = 1ll * num * num % 998244353)
if (k & 1) ret = 1ll * ret * num % 998244353;
return ret;
}
inline int upd(int x) { return x < 998244353 ? x : x - 998244353; }
inline void NTT(int *a, int len, int op) {
for (int i = 0; i < len; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int i = 1; i < len; i <<= 1)
for (int j = 0,
wn = ksm(op == 1 ? 3 : 332748118, (998244353 - 1) / (i << 1));
j < len; j += (i << 1))
for (int k = 0, w = 1; k < i; k++, w = 1ll * wn * w % 998244353) {
int x = a[j + k], y = 1ll * a[i + j + k] * w % 998244353;
a[j + k] = upd(x + y), a[i + j + k] = upd(x - y + 998244353);
}
if (!~op)
for (int i = 0, Inv = ksm(len, 998244353 - 2); i < len; i++)
a[i] = 1ll * a[i] * Inv % 998244353;
}
inline int C(int p, int q) {
return 1ll * fac[p] * inv[q] % 998244353 * inv[p - q] % 998244353;
}
int main() {
n = getint(), k = getint();
fac[0] = inv[0] = inv[1] = 1;
for (int i = 2; i <= n; i++)
inv[i] = 1ll * (998244353 - 998244353 / i) * inv[998244353 % i] % 998244353;
for (int i = 1; i <= n; i++)
fac[i] = 1ll * i * fac[i - 1] % 998244353,
inv[i] = 1ll * inv[i - 1] * inv[i] % 998244353;
for (int i = 1; i <= n; i++) cnt[getint()]++;
while (k--) {
int t = getint(), a = 0, b = 0;
for (int i = 1; i < t; i++)
if (cnt[i] >= 2)
a += 2;
else if (cnt[i] == 1)
b++;
memset(A, 0, sizeof A);
memset(B, 0, sizeof B);
for (int i = 0; i <= a; i++) A[i] = C(a, i);
for (int i = 0; i <= b; i++) B[i] = 1ll * C(b, i) * ksm(2, i) % 998244353;
a += b;
L = 0;
for (n = 1; n <= a; n <<= 1) ++L;
for (int i = 0; i < n; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (L - 1));
NTT(A, n, 1), NTT(B, n, 1);
for (int i = 0; i < n; i++) A[i] = 1ll * A[i] * B[i] % 998244353;
NTT(A, n, -1);
for (int i = 0; i <= a; i++) (ans[(t + 1 + i) << 1] += A[i]) %= 998244353;
}
int q = getint();
while (q--) printf("%d\n", (ans[getint()] + 998244353) % 998244353);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p;
string a[101000];
cin >> n >> p;
long long num = 0, ans = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = n; i >= 1; i--) {
num *= 2;
if (a[i] == "halfplus") num += 1;
ans += num * p;
}
cout << ans / 2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const char S[8][10] = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
int main() {
long long n;
while (cin >> n) {
char s[10];
cin >> s;
long long v[10];
memset(v, 0, sizeof(v));
for (long long i = 0; i < 8; i++)
if (strlen(S[i]) != n) v[i] = 1;
for (long long i = 0; i < n; i++)
if (s[i] != '.')
for (long long j = 0; j < 8; j++)
if (strlen(S[j]) != n || S[j][i] != s[i]) v[j] = 1;
for (long long i = 0; i < 8; i++)
if (!v[i]) cout << S[i] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool prime(int n) {
if (n <= 1) {
return false;
}
if (n <= 3) {
return true;
}
if (n % 2 == 0 || n % 3 == 0) {
return false;
}
for (int i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
int main() {
int n;
cin >> n;
if (n <= 5) {
cout << 0 << endl;
} else {
int ans = 0;
for (int i = 6; i <= n; i++) {
int num = 0;
for (int j = 2; j <= i / 2; j++) {
if (prime(j) && i % j == 0) {
num++;
}
}
if (num == 2) {
ans++;
}
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using std::min;
using std::vector;
const int fin = 0, maxn = 52;
const int INF = 1 << 28;
const int dx[4] = {0, -1, 0, 1}, dy[4] = {1, 0, -1, 0};
int n, m;
char s[maxn][maxn];
bool c[maxn][maxn], v[maxn][maxn];
vector<int> V[maxn * 2];
int sol(int sx, int sy) {
int i, j, k, u, ux, uy, tx, ty, last = -1;
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) v[i][j] = 0;
for (i = 0; i <= n + m; ++i) V[i].clear();
V[0].push_back(sx * m + sy), v[sx][sy] = 1;
for (i = 0; i <= n + m; ++i)
for (j = 0; j < V[i].size(); ++j) {
u = V[i][j], ux = u / m, uy = u % m;
if (c[ux][uy]) last = i;
for (k = 0; k < 4; ++k) {
tx = ux + dx[k], ty = uy + dy[k];
if (tx < 0 || tx >= n || ty < 0 || ty >= m) continue;
if (!v[tx][ty])
v[tx][ty] = 1, V[i + (c[ux][uy] ^ c[tx][ty])].push_back(tx * m + ty);
}
}
return last + 1;
}
int main() {
if (fin) {
freopen("t.in", "r", stdin);
freopen("t.out", "w", stdout);
}
int i, j, ans = INF;
scanf("%d%d\n", &n, &m);
for (i = 0; i < n; ++i) gets(s[i]);
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) c[i][j] = s[i][j] == 'B';
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) ans = min(ans, sol(i, j));
printf("%d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct trie {
trie *next[2];
} * root, a[5000000];
int x = 0;
long long num[100009];
trie *mal() {
trie *p = a + x++;
p->next[0] = p->next[1] = 0;
return p;
}
void insert(long long x) {
int i, t;
trie *p = root;
for (i = 40; i >= 0; i--) {
t = 0;
if ((1ll << i) & x) t = 1;
if (p->next[t])
p = p->next[t];
else
p = p->next[t] = mal();
}
}
long long find(long long x) {
long long ans = 0;
trie *p = root;
for (int i = 40; i >= 0; i--) {
int t = 1;
if ((1ll << i) & x) t = 0;
if (p->next[t]) {
p = p->next[t];
ans |= 1ll << i;
} else
p = p->next[1 - t];
}
return ans;
}
int main() {
int i, j, k, n, m;
scanf("%d", &n);
root = mal();
for (i = 1; i <= n; i++) cin >> num[i];
long long ans = 0, s = 0, t = 0;
for (i = 1; i <= n; i++) s ^= num[i];
insert(0);
ans = s;
for (i = 1; i <= n; i++) {
t ^= num[i];
insert(t);
s ^= num[i];
ans = max(ans, find(s));
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int mas[1010][1010];
int row[1010], col[1010];
int n, m, k;
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &mas[i][j]);
}
}
for (int i = 0; i < n; ++i) {
row[i] = i;
}
for (int i = 0; i < m; ++i) {
col[i] = i;
}
scanf("%d", &n);
for (int i = 0; i < k; ++i) {
char c;
int a, b;
scanf("%c %d %d\n", &c, &a, &b);
a--;
b--;
if (c == 'c') {
col[a] ^= col[b];
col[b] ^= col[a];
col[a] ^= col[b];
}
if (c == 'r') {
row[a] ^= row[b];
row[b] ^= row[a];
row[a] ^= row[b];
}
if (c == 'g') {
printf("%d\n", mas[row[a]][col[b]]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
const int mod = (int)1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1.0);
int n, m, k;
string s;
int a[200010], b[200010];
int main() {
cin >> s;
int len1 = s.length();
for (int i = 1; i <= len1; i++) a[i] = s[i - 1] - '0';
cin >> s;
int len2 = s.length();
for (int i = 1; i <= len2; i++) b[i] = s[i - 1] - '0' + b[i - 1];
int div = len2 - len1;
long long ans = 0;
for (int i = 1; i <= len1; i++) {
if (a[i] == 0)
ans += b[i + div] - b[i - 1];
else
ans += div + 1 - (b[i + div] - b[i - 1]);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[1000009];
long long deg[1000009], vis[1000009] = {0ll}, vis2[1000009];
void dfs(int u) {
vis[u] = 1;
for (auto& v : g[u]) {
if (vis[v]) continue;
dfs(v);
}
}
int main() {
cin.sync_with_stdio(0), cin.tie(0);
long long n, m, loop = 0;
cin >> n >> m;
long long a, b;
for (auto i = 0; i < m; i++) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
vis2[a] = vis2[b] = 1;
if (a == b)
loop++;
else
deg[a]++, deg[b]++;
}
dfs(a);
for (int i = 1; i <= n; i++) {
if (!vis[i] && vis2[i]) {
cout << "0" << '\n';
return 0;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) ans += deg[i] * (deg[i] - 1ll) / 2ll;
cout << ans + loop * (loop - 1ll) / 2ll + loop * (m - loop) << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void useFiles(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
vector<vector<int>> g;
vector<int> used;
vector<vector<int>> ans;
int solve(int v, int p = -1) {
vector<int> arr;
used[v] = 1;
for (auto x : g[v])
if (x != p && used[x] == 1) arr.push_back(x);
for (auto x : g[v]) {
if (!used[x]) {
int d = solve(x, v);
if (d == -1)
arr.push_back(x);
else
ans.push_back({v, x, d});
}
}
used[v] = 2;
for (int i = 0; i < (arr.size() >> 1); ++i)
ans.push_back({arr[i << 1], v, arr[(i << 1) + 1]});
if (arr.size() % 2 != 0) return arr.back();
return -1;
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n);
used.resize(n, 0);
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < n; ++i)
if (!used[i]) solve(i);
cout << ans.size() << endl;
for (auto &v : ans) {
for (auto &x : v) cout << x + 1 << " ";
cout << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, q, l, r;
string s;
int main() {
cin >> n >> q >> s;
for (int i = 1; i <= q; i++) {
cin >> l >> r;
--l;
--r;
int was[20], cp, dp = 1;
string t = s;
memset(was, 0, sizeof(was));
cp = l;
while (cp >= l && cp <= r) {
if (t[cp] == '>' || t[cp] == '<') {
int pr = cp;
if (t[cp] == '>')
dp = 1;
else
dp = -1;
cp += dp;
while (cp >= l && cp <= r && t[cp] == 1) cp += dp;
if (cp < l || cp > r) break;
if (t[cp] == '>' || t[cp] == '<') t[pr] = 1;
continue;
};
was[t[cp] - '0']++;
t[cp]--;
if (t[cp] < '0') t[cp] = 1;
cp += dp;
while (cp >= l && cp <= r && t[cp] == 1) cp += dp;
};
for (int j = 0; j < 10; j++) printf("%d ", was[j]);
printf("\n");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int b;
int a[1000], n;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
while (1 == 1) {
sort(a, a + n);
for (int i = 1; i < n; ++i)
if (a[i] != a[i - 1]) a[i] = a[i] - a[i - 1];
int met = 0;
for (int i = 1; i < n; ++i)
if (a[0] != a[i]) met = 1;
if (met == 0) break;
};
int sum = 0;
for (int i = 0; i < n; ++i) sum += a[i];
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a;
long double aa;
int i = 4;
int k;
while (i > 0) {
k = i - 1;
if (n % k == 0) break;
i = i * 2;
}
cout << n / k << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace PROG {
namespace io {
const int MaxBuff = 1 << 15;
const int Output = 1 << 23;
char B[MaxBuff], *S = B, *T = B;
char Out[Output], *iter = Out;
__inline__ __attribute__((always_inline)) void flush() {
fwrite(Out, 1, iter - Out, stdout);
iter = Out;
}
} // namespace io
template <class Type>
__inline__ __attribute__((always_inline)) Type read() {
using namespace io;
register char ch;
register Type ans = 0;
register bool neg = 0;
while (ch = ((S == T) && (T = (S = B) + fread(B, 1, MaxBuff, stdin), S == T)
? 0
: *S++),
(ch < '0' || ch > '9') && ch != '-')
;
ch == '-' ? neg = 1 : ans = ch - '0';
while (ch = ((S == T) && (T = (S = B) + fread(B, 1, MaxBuff, stdin), S == T)
? 0
: *S++),
'0' <= ch && ch <= '9')
ans = ans * 10 + ch - '0';
if (ch == '.') {
double t = 1;
while (ch = ((S == T) && (T = (S = B) + fread(B, 1, MaxBuff, stdin), S == T)
? 0
: *S++),
'0' <= ch && ch <= '9')
ans = ans * 10 + ch - '0', t *= 10;
ans /= t;
}
return neg ? -ans : ans;
}
template <>
__inline__ __attribute__((always_inline)) string read<string>() {
using namespace io;
static char str[100000];
int top = 0;
char ch;
string ans;
bool neg = 0;
while (ch = ((S == T) && (T = (S = B) + fread(B, 1, MaxBuff, stdin), S == T)
? 0
: *S++),
isspace(ch))
;
str[top++] = ch;
while (ch = ((S == T) && (T = (S = B) + fread(B, 1, MaxBuff, stdin), S == T)
? 0
: *S++),
!isspace(ch))
str[top++] = ch;
str[top] = 0;
return string(str);
}
template <class Type>
__inline__ __attribute__((always_inline)) void Print(Type x, char ch = '\n') {
using namespace io;
if (!x)
*iter++ = '0';
else {
if (x < 0) *iter++ = '-', x = -x;
static int s[100];
register int t = 0;
while (x) s[++t] = x % 10, x /= 10;
while (t) *iter++ = '0' + s[t--];
}
if (ch) *iter++ = ch;
}
__inline__ __attribute__((always_inline)) void puts(const char* s,
char ch = '\n') {
using namespace io;
while (*s) *iter++ = *s++;
if (ch) *iter++ = ch;
}
} // namespace PROG
namespace PROG {
const int N = 400500;
const int INF = 1000000007;
const int MOD = INF;
int n;
int num = 0;
int ans = 1;
set<int> sset;
int main() {
n = read<int>();
int minn = 0, maxn = INF;
while (n--) {
string ss;
ss = read<string>();
int x = read<int>();
if (ss[1] == 'D') {
sset.insert(x);
if (x > minn && x < maxn) num++;
} else {
if (x < minn || x > maxn) {
ans = 0;
puts("0");
io::flush();
return 0;
} else if (x == minn || x == maxn)
ans *= 1;
else
ans = (long long)ans * 2 % MOD;
set<int>::iterator it = sset.find(x), tmp;
if (it == sset.begin())
minn = 0;
else {
tmp = it;
tmp--;
minn = *tmp;
}
if (it == (--sset.end()))
maxn = INF;
else {
tmp = it;
tmp++;
maxn = *tmp;
}
sset.erase(it);
num = 0;
}
}
Print<int>((int)((long long)ans * (num + 1) % MOD));
io::flush();
return 0;
}
} // namespace PROG
int main(void) {
PROG::main();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int weight, ind;
bool included;
};
bool cmpW(const Edge& a, const Edge& b) {
return a.weight < b.weight or a.weight == b.weight && a.included > b.included;
}
Edge edges[100005];
pair<int, int> ans[100005];
int lastCycle[100005], currCycle, lstNode;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) lastCycle[i] = i + 1;
for (int i = 0; i < m; ++i)
cin >> edges[i].weight >> edges[i].included, edges[i].ind = i;
sort(edges, edges + m, cmpW);
for (int i = 0; i < m; ++i)
if (edges[i].included)
ans[edges[i].ind] = {lstNode, lstNode + 1}, currCycle = 0, ++lstNode;
else {
if (currCycle + 1 >= lstNode) {
cout << -1;
return 0;
}
ans[edges[i].ind] = {currCycle, ++lastCycle[currCycle]};
currCycle += (lastCycle[currCycle] == lstNode);
}
for (int i = 0; i < m; ++i)
cout << ++ans[i].first << ' ' << ++ans[i].second << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gen(long long n, long long k) {
return (1ll << n) - 1ll - (1ll << k);
}
int main() {
long long a, b;
cin >> a >> b;
int ans = 0;
for (int i = 2; i < 62; ++i) {
for (int j = 0; j + 1 < i; ++j) {
long long val = gen(i, j);
if (a <= val && val <= b) ++ans;
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, comp;
int mat[4][4] = {{0, 1, 1, 1}, {0, 0, 2, 0}, {0, 2, 0, 0}, {1, 1, 1, 0}};
long long dp[1010][2010][4];
int solve(int pos, int K, int prev) {
if (pos == n) return K == 0;
if (dp[pos][K][prev] != -1) return dp[pos][K][prev];
int ans = 0;
for (int i = 0; i < 4; ++i)
ans = (ans + solve(pos + 1, K - mat[prev][i], i)) % 998244353LL;
return (dp[pos][K][prev] = ans);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> comp;
memset(dp, -1, sizeof(dp));
long long ans = 0;
for (int i = 0; i < 4; ++i)
ans = (ans + solve(1, comp - 1 - (i == 1 || i == 2), i)) % 998244353LL;
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
int x[21] = {};
long long res = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t;
x[t + 10]++;
}
for (int i = 0; i < 10; i++) {
res += x[i] * 1ull * x[20 - i];
}
res += x[10] * 1ull * (x[10] - 1) / 2;
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long b, long long p) {
if (p == 0) return 1;
return b * power(b, p - 1);
}
long long fact(long long n) {
if (n == 1) return 1;
return n * fact(n - 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, c0(0), c1(0), cnt(0), c(0);
cin >> n;
long long arr[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] == 0)
c0++;
else
c1++;
}
for (long long i = 0; i < n; i++) {
if (arr[i] == 1)
cnt += (c0);
else
c0--;
}
for (int i = n - 1; i >= 0; i--) {
if (arr[i] == 0)
c += c1;
else
c1--;
}
cout << min(cnt, c) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 1;
vector<int> g[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> x(m), y(m);
for (int i = 0; i < m; ++i) {
cin >> x[i] >> y[i];
g[x[i]].push_back(y[i]);
g[y[i]].push_back(x[i]);
}
vector<int> t(n + 1);
vector<pair<int, int> > p;
for (int i = 1; i <= n; ++i) {
cin >> t[i];
p.push_back({t[i], i});
}
for (int i = 0; i < m; ++i) {
if (t[x[i]] == t[y[i]]) {
cout << "-1";
return 0;
}
}
sort(p.begin(), p.end());
for (auto i : p) {
int u = i.second;
vector<int> cnt(i.first);
for (int j : g[u]) {
if (t[j] < i.first) cnt[t[j]]++;
}
for (int j = 1; j < i.first; ++j) {
if (!cnt[j]) {
cout << "-1";
return 0;
}
}
}
for (auto i : p) {
cout << i.second << ' ';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, i, j;
cin >> n;
j = 1;
for (i = 0; i < n; i += 1) {
for (j = 0; j < n; j += 1) {
long long ans;
if (j % 2 == 0)
ans = i + n * j;
else
ans = (n - i - 1) + n * j;
cout << ans + 1 << " ";
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j)
if (i == j)
cout << k << ' ';
else
cout << "0 ";
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const int N = 510;
long long int powxy(long long int x, long long int y) {
if (y == 0) return 1;
if (y % 2 == 1) return (x * powxy(x, y - 1)) % MOD;
long long int t = powxy(x, y / 2) % MOD;
return (t * t) % MOD;
}
long long int solve(long long int h, long long int a, long long int x,
long long int y, long long int mod) {
for (int i = 1; i <= mod; i++) {
h = (h * x + y) % mod;
if (h == a) return i;
}
return -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int m, h1, a1, x1, y1, h2, a2, x2, y2;
cin >> m >> h1 >> a1 >> x1 >> y1 >> h2 >> a2 >> x2 >> y2;
long long int k1 = solve(h1, a1, x1, y1, m);
long long int t1 = solve(a1, a1, x1, y1, m);
long long int k2 = solve(h2, a2, x2, y2, m);
long long int t2 = solve(a2, a2, x2, y2, m);
if (k1 == -1 || k2 == -1) return cout << -1, 0;
for (int i = 1; i <= 2 * m; i++) {
if (k1 == k2) return cout << k1, 0;
if (k1 < k2) {
if (t1 == -1) return cout << -1, 0;
k1 += t1;
} else {
if (t2 == -1) return cout << -1, 0;
k2 += t2;
}
}
cout << -1;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int n[100], k[100];
for (int i = 0; i < t; i++) cin >> n[i] >> k[i];
for (int i = 0; i < t; i++) {
for (int j = 0; j < n[i]; j++) {
char a = 'a' + j % k[i];
cout << a;
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int b[4001], c[4001], a[2000][2000], mmax[2], t;
int main(int argc, char **argv) {
for (int i = 0; i < 4001; i++) b[i] = c[i] = 0;
int n, mx[2], my[2], tch;
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
scanf("%I64d", &a[i][j]);
b[i - j + 2000] += a[i][j];
c[i + j] += a[i][j];
}
mmax[0] = mmax[1] = -1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
t = b[i - j + 2000] + c[i + j] - a[i][j];
tch = (i + j) % 2;
if (mmax[tch] < t) {
mmax[tch] = t;
mx[tch] = i + 1;
my[tch] = j + 1;
}
}
printf("%I64d\n%d %d %d %d", mmax[1] + mmax[0], mx[0], my[0], mx[1], my[1]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long count_bc(long long x) { return (x + 2) * (x + 1) / 2; }
long long l;
long long ways(long long a, long long b, long long c) {
long long ret = 0;
for (int da = 0; da <= l; ++da) {
if (b + c > a + da) continue;
ret += count_bc(min(l - da, a + da - b - c));
}
return ret;
}
int main() {
long long a, b, c;
cin >> a >> b >> c >> l;
long long ways_tot = (l + 1) * (l + 2) * (l + 3) / 6;
ways_tot -= ways(a, b, c);
ways_tot -= ways(b, c, a);
ways_tot -= ways(c, b, a);
cout << ways_tot << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[100000], b[100000];
long long i, o, j, k, l, n, m, second, p;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
k += a[i];
}
for (i = 0; i < n; i++) {
cin >> b[i];
}
sort(b, b + n);
m = b[n - 1] + b[n - 2];
if (m >= k)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int maxn = 2e5 + 5;
int tt;
int n, a[maxn];
bool vis[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> tt;
while (tt--) {
cin >> n;
int ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
vis[a[i]] = 1;
}
sort(a + 1, a + n + 1);
vector<int> v;
v.push_back(a[n]);
ans = a[n];
for (int i = n - 1; i >= 1; i--) {
if (v.size() == 3) break;
bool tr = 1;
for (auto j : v)
if (j % a[i] == 0) tr = 0;
if (tr) v.push_back(a[i]), ans += a[i];
}
if (a[n] % 30 == 0 and vis[a[n] / 5] and vis[a[n] / 3] and vis[a[n] / 2]) {
ans = max(ans, a[n] / 5 + a[n] / 3 + a[n] / 2);
}
for (int i = 1; i <= n; i++) vis[a[i]] = 0;
cout << ans << '\n';
}
}
| 6 |
#include <bits/stdc++.h>
int main(int argc, const char* argv[]) {
long long int n;
(scanf("%lld", &n));
;
long long int asallar[] = {
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47,
53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197,
199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379,
383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571,
577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761,
769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977,
983, 991, 997, 1001};
long long int x = 0;
long long int prints[5000];
long long int memC = 0;
while (asallar[x] <= n) {
long long int t = 1;
long long int w = asallar[x];
while (t * w <= n) {
prints[memC] = t * w;
memC++;
t *= w;
}
x++;
}
printf("%lld", memC);
puts("");
for (long long int i = 0; i < (memC); i++) {
printf("%lld ", prints[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int mod = 1e9 + 7;
string arr[501];
int cache[501][501][252];
int dp(int i1, int i2, int moves) {
int j1 = moves - i1;
int j2 = m - 1 - (moves - ((n - 1) - i2));
if (j1 > j2 || i1 > i2 || arr[i1][j1] != arr[i2][j2] || i1 >= n || i2 >= n ||
j2 >= m || j1 >= m || j1 < 0 || j2 < 0)
return 0;
int &ans = cache[i1][i2][moves];
if (ans != -1) return ans;
if (i1 == i2) {
if (j2 - j1 <= 1) return 1;
return dp(i1, i2, moves + 1);
}
if (j1 == j2) {
if (i2 - i1 <= 1) return 1;
return dp(i1 + 1, i2 - 1, moves + 1);
}
ans = dp(i1 + 1, i2, moves + 1);
if (ans >= mod) ans %= mod;
ans += dp(i1, i2 - 1, moves + 1);
if (ans >= mod) ans %= mod;
ans += dp(i1, i2, moves + 1);
if (ans >= mod) ans %= mod;
ans += dp(i1 + 1, i2 - 1, moves + 1);
if (ans >= mod) ans %= mod;
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> arr[i];
memset(cache, -1, sizeof(cache));
cout << dp(0, n - 1, 0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename D>
std::ostream& operator<<(std::ostream& os, const std::pair<T, D>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
vector<long long> s;
long long add(long long l, long long r) { return s[r + 1] - s[l]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long q;
cin >> q;
vector<long long> av(n);
for (int i = (0); i < (n); i++) cin >> av[i];
s.resize(n + 1);
s[0] = 0;
for (int i = (0); i < (n); i++) s[i + 1] = av[i] + s[i];
vector<long long> kv(q);
for (int i = (0); i < (q); i++) cin >> kv[i];
long long cur_i = 0;
long long cur_health = av[0];
for (auto& k : kv) {
if (k >= cur_health) {
long long l = cur_i;
long long r = n;
while (r - l > 1) {
long long m = (l + r) / 2;
long long killer_arrows = cur_health + add(cur_i + 1, m);
if (k >= killer_arrows) {
l = m;
} else {
r = m;
}
}
if (l == n - 1) {
cur_i = 0;
cur_health = av[0];
} else {
long long killer_arrows = cur_health + add(cur_i + 1, l);
cur_i = l + 1;
cur_health = av[cur_i] - (k - killer_arrows);
}
} else {
cur_health -= k;
}
cout << n - cur_i << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
template <typename T>
struct hash_map_t {
vector<T> v, val, nxt;
vector<int> head;
int mod, tot, lastv;
T lastans;
bool have_ans;
hash_map_t(int md = 0) {
head.clear();
v.clear();
val.clear();
nxt.clear();
tot = 0;
mod = md;
nxt.resize(1);
v.resize(1);
val.resize(1);
head.resize(mod);
have_ans = 0;
}
void clear() { *this = hash_map_t(mod); }
bool count(int x) {
int u = x % mod;
for (register int i = head[u]; i; i = nxt[i]) {
if (v[i] == x) {
have_ans = 1;
lastv = x;
lastans = val[i];
return 1;
}
}
return 0;
}
void ins(int x, int y) {
int u = x % mod;
nxt.push_back(head[u]);
head[u] = ++tot;
v.push_back(x);
val.push_back(y);
}
int qry(int x) {
if (have_ans && lastv == x) return lastans;
count(x);
return lastans;
}
};
const int N = 5678, INF = 0x7f7f7f7f, MAXTIME = 100;
struct edge_t {
int u, v, next, cap, flow, cost;
};
vector<edge_t> G;
queue<int> q;
int head[N], dis[N], fr[N], maxflow[N], used[N], x[N], y[N];
int n, m, k, c, d, tot = 1, s, t, ans1, ans2;
inline void addedge(int u, int v, int cap, int cost) {
G.resize(tot + 3);
G[++tot] = (edge_t){u, v, head[u], cap, 0, cost}, head[u] = tot;
G[++tot] = (edge_t){v, u, head[v], 0, 0, -cost}, head[v] = tot;
}
bool spfa() {
memset(dis, 0x7f, sizeof(dis));
memset(used, 0, sizeof(used));
dis[s] = 0;
used[s] = 1;
maxflow[s] = INF;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
used[u] = 0;
for (register int i = head[u]; i; i = G[i].next) {
int v = G[i].v;
if (G[i].cap > G[i].flow && dis[v] > dis[u] + G[i].cost) {
dis[v] = dis[u] + G[i].cost;
fr[v] = i;
maxflow[v] = min(maxflow[u], G[i].cap - G[i].flow);
if (!used[v]) {
used[v] = 1;
q.push(v);
}
}
}
}
return dis[t] != INF;
}
void solve() {
int tmp = t;
while (tmp != s) {
int i = fr[tmp];
G[i].flow += maxflow[t];
G[i ^ 1].flow -= maxflow[t];
tmp = G[i].u;
}
ans1 += maxflow[t];
ans2 += maxflow[t] * dis[t];
}
void mcmf() {
while (spfa()) solve();
}
inline int calc(int x, int y) { return x * n + y; }
int main() {
G.resize(2);
read(n);
read(m);
read(k);
read(c);
read(d);
s = 0;
t = (MAXTIME + 1) * n + 1;
for (register int i = 1; i <= k; i++) {
int a;
read(a);
addedge(s, calc(0, a), 1, 0);
}
for (register int i = 1; i <= m; i++) read(x[i]), read(y[i]);
for (register int i = 0; i <= MAXTIME; i++)
addedge(calc(i, 1), t, INF, i * c);
for (register int i = 0; i < MAXTIME; i++) {
for (register int j = 1; j <= n; j++) {
addedge(calc(i, j), calc(i + 1, j), INF, 0);
}
}
for (register int i = 1; i <= m; i++) {
for (register int j = 0; j < MAXTIME; j++) {
for (register int cnt = 1; cnt <= n; cnt++) {
addedge(calc(j, x[i]), calc(j + 1, y[i]), 1, d * (cnt * 2 - 1));
addedge(calc(j, y[i]), calc(j + 1, x[i]), 1, d * (cnt * 2 - 1));
}
}
}
mcmf();
print(ans2, '\n');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false);
int n;
cin >> n;
int mem[15];
set<int> s;
s.insert(0);
for (int i = 0; i < 15; i++) {
set<int> tmp;
for (auto it : s) {
tmp.insert(it + 1);
tmp.insert(it + 5);
tmp.insert(it + 10);
tmp.insert(it + 50);
}
s = tmp;
mem[i] = s.size();
}
if (n <= 15) {
cout << mem[n - 1] << endl;
} else {
n = n - 15;
cout << (long long)mem[14] + (long long)n * (49LL) << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int cmp(int a, int b) { return a > b; }
int a[57], b[57];
int main() {
int t, n, x, i;
scanf("%d", &t);
while (t--) {
int flag = 0;
scanf("%d%d", &n, &x);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) scanf("%d", &b[i]);
sort(b, b + n, cmp);
for (i = n - 1; i >= 0; i--) {
if (a[i] + b[i] > x) {
puts("No");
flag = 1;
break;
}
}
if (flag == 0) puts("Yes");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int ans[1000005], s[1000005], sta[1000005];
int main() {
int n;
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", ans + i), s[i] = 1;
int k, x, top = 0;
scanf("%d", &k);
while (k--) {
scanf("%d", &x);
s[x - 1] = -1;
}
if (n & 1)
puts("NO");
else {
sta[top++] = ans[n - 1];
s[n - 1] = -1;
for (int i = n - 2; i >= 0; i--)
if (s[i] == -1 || sta[top - 1] != ans[i])
sta[top++] = ans[i], s[i] = -1;
else
top--;
puts(top ? "NO" : "YES");
if (!top) {
for (int i = 0; i < n; i++) printf("%d ", ans[i] * s[i]);
puts("");
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1e+9 + 7;
const ll INF = LLONG_MAX;
const int N = (int)2e+5 + 8;
ld x;
vector<pair<ll, ll>> res;
void MAIN(int tc) {
cin >> x;
for (ld a = 1; a <= 1e7; a++) {
ld num = (6 * x) + (a * a * a) - (a);
ld den = (3 * a * a) + (3 * a);
ld b = num / den;
if (fmod(num, den) == 0 && a <= b) {
res.push_back({a, b});
res.push_back({b, a});
}
}
sort((res).begin(), (res).end(), [&](pair<ll, ll> p1, pair<ll, ll> p2) {
return p1.first == p2.first ? p1.first < p2.first : p1.second > p2.second;
});
res.resize(unique(res.begin(), res.end()) - res.begin());
;
cout << res.size() << "\n";
;
for (auto [a, b] : res) {
cout << a << " " << b << "\n";
;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << fixed;
cout << setprecision(10);
int test_cases = 1;
for (int i = 1; i <= test_cases; i++) {
MAIN(i);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int INF = 1e18;
class Node {
public:
pair<long long int, long long int> nums;
};
vector<vector<Node>> tree;
vector<vector<long long int>> values;
void build(int index, int l, int r, int i, vector<vector<Node>> &tree) {
if (l > r) {
return;
}
if (l == r) {
tree[i][index].nums = {values[i][l], INF};
return;
}
int mid = l + (r - l) / 2;
build(index * 2, l, mid, i, tree);
build(index * 2 + 1, mid + 1, r, i, tree);
auto ans1 = tree[i][index * 2].nums;
auto ans2 = tree[i][index * 2 + 1].nums;
pair<long long int, long long int> ans = {INF, INF};
if (ans1.first < ans2.first) {
ans.first = ans1.first;
if (ans1.second < ans2.first) {
ans.second = ans1.second;
} else {
ans.second = ans2.first;
}
} else {
ans.first = ans2.first;
if (ans1.first < ans2.second) {
ans.second = ans1.first;
} else {
ans.second = ans2.second;
}
}
tree[i][index].nums = ans;
return;
}
void update(int index, int x, int l, int r, int i, vector<vector<Node>> &tree) {
if (x < l || x > r) {
return;
}
if (x == l && x == r) {
tree[i][index].nums = {values[i][x], INF};
return;
}
int mid = l + (r - l) / 2;
update(index * 2, x, l, mid, i, tree);
update(index * 2 + 1, x, mid + 1, r, i, tree);
auto ans1 = tree[i][index * 2].nums;
auto ans2 = tree[i][index * 2 + 1].nums;
pair<long long int, long long int> ans = {INF, INF};
if (ans1.first < ans2.first) {
ans.first = ans1.first;
if (ans1.second < ans2.first) {
ans.second = ans1.second;
} else {
ans.second = ans2.first;
}
} else {
ans.first = ans2.first;
if (ans1.first < ans2.second) {
ans.second = ans1.first;
} else {
ans.second = ans2.second;
}
}
tree[i][index].nums = ans;
return;
}
pair<long long int, long long int> query(int index, int L, int R, int l, int r,
int i, vector<vector<Node>> &tree) {
if (L > r || R < l) {
return {INF, INF};
}
if (L <= l && R >= r) {
return tree[i][index].nums;
}
int mid = l + (r - l) / 2;
auto ans1 = query(index * 2, L, R, l, mid, i, tree);
auto ans2 = query(index * 2 + 1, L, R, mid + 1, r, i, tree);
pair<long long int, long long int> ans = {INF, INF};
int temp = 0;
if (ans1.first < ans2.first) {
ans.first = ans1.first;
if (ans1.second < ans2.first) {
ans.second = ans1.second;
} else {
ans.second = ans2.first;
}
} else {
ans.first = ans2.first;
if (ans1.first < ans2.second) {
ans.second = ans1.first;
} else {
ans.second = ans2.second;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int x = (int)(ceil(log2(n)));
int max_size = (1 << (x + 1)) - 1;
b = a;
tree = vector<vector<Node>>(9, vector<Node>(max_size + 1));
for (int i = 0; i < 9; i++) {
for (int j = 0; j <= max_size; j++) {
tree[i][j].nums = make_pair(INF, INF);
}
}
values = vector<vector<long long int>>(9);
for (int i = 0; i < 9; i++) {
for (int j = 0; j < n; j++) {
if (a[j] % 10) {
values[i].push_back(b[j]);
} else {
values[i].push_back(INF);
}
a[j] /= 10;
}
}
for (int i = 0; i < 9; i++) {
build(1, 0, n - 1, i, tree);
}
for (int i = 0; i < m; i++) {
int type;
cin >> type;
if (type == 1) {
long long int ind, x;
cin >> ind >> x;
long long int y = x;
for (int j = 0; j < 9; j++) {
if (x % 10) {
values[j][ind - 1] = y;
} else {
values[j][ind - 1] = INF;
}
x /= 10;
}
for (int j = 0; j < 9; j++) update(1, ind - 1, 0, n - 1, j, tree);
} else {
int l, r;
cin >> l >> r;
l--;
r--;
long long int fans = 2e18 + 1;
for (int i = 0; i < 9; i++) {
auto ans = query(1, l, r, 0, n - 1, i, tree);
long long int temp = ans.first + ans.second;
fans = min(fans, temp);
}
if (fans >= 1e18) {
cout << -1 << '\n';
} else {
cout << fans << '\n';
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char change(char a, char b) {
if ('R' != a && 'R' != b) return 'R';
if ('G' != a && 'G' != b) return 'G';
if ('B' != a && 'B' != b) return 'B';
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
int ans = 0;
for (int i = 1; i < n; i++)
if (s[i] == s[i - 1]) {
ans++;
s[i] = i == n - 1 ? change(s[i], s[i]) : change(s[i - 1], s[i + 1]);
}
cout << ans << endl;
cout << s;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char a[200][200];
int main() {
int n;
int flag = 1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == '#') {
if (a[i + 1][j] == '#' && a[i + 2][j] == '#' &&
a[i + 1][j - 1] == '#' && a[i + 1][j + 1] == '#') {
a[i][j] = '.';
a[i + 1][j] = '.';
a[i + 2][j] = '.';
a[i + 1][j - 1] = '.';
a[i + 1][j + 1] = '.';
} else {
flag = 0;
break;
}
}
}
if (flag == 0) {
break;
}
}
if (flag == 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> ids_ends[200000 + 10];
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int l, r;
cin >> l >> r;
ids_ends[l].push_back({r, i});
}
vector<int> ans;
set<pair<int, int>> ids_ends_q;
for (int pos = 1; pos <= 200000; pos++) {
for (pair<int, int> id_end : ids_ends[pos]) {
ids_ends_q.insert(id_end);
}
while (ids_ends_q.size() > k) {
pair<int, int> end_id = *ids_ends_q.rbegin();
ids_ends_q.erase(end_id);
ans.push_back(end_id.second);
}
while (!ids_ends_q.empty() && ids_ends_q.begin()->first <= pos) {
ids_ends_q.erase(ids_ends_q.begin());
}
}
cout << ans.size() << endl;
for (int x : ans) printf("%d ", x);
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
int a_, b_, ans = 0;
for (int i = 1; i < n; i++) {
a_ = a / i;
b_ = b / (n - i);
ans = max(ans, min(a_, b_));
}
if (a + b == n) {
cout << 1 << endl;
} else
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
const int N = 12;
const int divisors[] = {1, 2, 3, 4, 6, 12};
const int L = 6;
int t(0);
scanf("%d\n", &t);
while (t--) {
std::string cards("");
getline(std::cin, cards);
std::vector<int> goodDivs;
for (int k = 0; k < L; k++) {
int numCols = divisors[k];
bool state[numCols];
for (int u = 0; u < numCols; u++) {
state[u] = 1;
}
for (int m = 0; m < N; m++) {
if (cards[m] == 'O') {
state[m % numCols] = 0;
}
}
for (int u = 0; u < numCols; u++) {
if (state[u] == 1) {
goodDivs.push_back(numCols);
break;
}
}
}
printf("%lu ", goodDivs.size());
for (int k = goodDivs.size() - 1; k >= 0; k--) {
printf("%dx%d ", N / goodDivs[k], goodDivs[k]);
}
puts("");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void morir() {
cout << -1 << endl;
exit(0);
}
int n, k;
int v[1000000];
int visto[1000000];
stack<int> s;
int nsol;
int sol[1000000];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= k; i++) {
cin >> v[i];
sol[i] = v[i];
}
visto[n + 1] = 1;
int iv = 1;
int next = 1;
while (next <= n) {
if (int(s.size()) and s.top() == next) {
s.pop();
next++;
} else if (visto[next]) {
morir();
} else if (iv <= k) {
nsol++;
sol[nsol] = v[iv];
visto[v[iv]] = 1;
s.push(v[iv]);
iv++;
} else {
int i = next;
while (not visto[i + 1]) i++;
for (; i >= next; i--) {
nsol++;
sol[nsol] = i;
s.push(i);
visto[i] = 1;
}
}
}
for (int i = 1; i <= n; i++) {
if (i > 1) cout << " ";
cout << sol[i];
}
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string itoa(long long a) {
string ret;
for (long long i = a; i > 0; i = i / 10) ret += ((i % 10) + 48);
reverse(ret.begin(), ret.end());
return ret;
}
int toi(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long toi64(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double tod(string s) {
double r = 0;
istringstream sin(s);
sin >> r;
return r;
}
vector<string> token(string a, string b) {
const char *q = a.c_str();
while (count(b.begin(), b.end(), *q)) q++;
vector<string> oot;
while (*q) {
const char *e = q;
while (*e && !count(b.begin(), b.end(), *e)) e++;
oot.push_back(string(q, e));
q = e;
while (count(b.begin(), b.end(), *q)) q++;
}
return oot;
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / gcd(a, b));
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T power(T x, T p) {
if (!p) return 1;
return x * power(x, p - 1);
}
const int mx = 0;
int main() {
string num;
while (cin >> num) {
int cnt = 0;
while (num != "1") {
if (num[(int)num.size() - 1] == '1') {
int i;
for (i = (int)num.size() - 1; i >= 0; i--)
if (num[i] == '0')
break;
else
num[i] = '0';
if (i == -1)
num = "1" + num;
else
num[i] = '1';
} else
num.erase(num.end() - 1);
cnt++;
}
cout << cnt << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct vec {
long long a[30];
};
struct mat {
long long a[30][30];
};
long long n, k;
int val(long long um) {
if (um < k) return um;
return (um + val(um / k)) % k;
}
mat M[30], MI[30];
mat E[200][40], EI[200][40];
vec cur;
mat mult(mat m1, mat m2) {
mat m3;
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) {
m3.a[i][j] = 0;
for (int l = 0; l < k; l++) {
m3.a[i][j] += (m1.a[i][l] * m2.a[l][j]) % 1000000007LL;
}
m3.a[i][j] %= 1000000007LL;
}
}
return m3;
}
vec mult(mat m, vec v) {
vec v2;
for (int i = 0; i < k; i++) {
v2.a[i] = 0;
for (int j = 0; j < k; j++) {
v2.a[i] += (v.a[j] * m.a[i][j]) % 1000000007LL;
}
v2.a[i] %= 1000000007LL;
}
return v2;
}
void pre_comp() {
for (int i = 0; i < k; i++) {
E[0][i] = M[i];
EI[0][i] = MI[i];
}
int LOG = 0;
long long t = n;
while (t > 0) {
LOG++;
t /= k;
}
for (int j = 1; j <= LOG; j++) {
E[j][0] = E[j - 1][0];
EI[j][0] = EI[j - 1][0];
for (int l = 1; l < k; l++) {
E[j][0] = mult(E[j - 1][l], E[j][0]);
EI[j][0] = mult(EI[j][0], EI[j - 1][l]);
}
for (int i = 1; i < k; i++) {
E[j][i] = mult(E[j - 1][i - 1], mult(E[j][i - 1], EI[j - 1][i - 1]));
EI[j][i] = mult(E[j - 1][i - 1], mult(EI[j][i - 1], EI[j - 1][i - 1]));
}
}
}
vec solve(long long n, vec v, int at) {
if (n == 0) return v;
int w = val(n / k);
v = solve(n / k, v, at + 1);
for (int i = 0; i < n % k; i++) {
v = mult(E[at][(w + i) % k], v);
}
return v;
}
int main() {
scanf("%lld %lld", &n, &k);
for (int i = 0; i < k; i++) {
cur.a[i] = 1;
for (int j = 0; j < k; j++) {
for (int l = 0; l < k; l++) {
if (j == l) {
M[i].a[j][l] = 1;
MI[i].a[j][l] = 1;
} else if (j == i) {
M[i].a[j][l] = 1;
MI[i].a[j][l] = -1;
} else {
M[i].a[j][l] = 0;
MI[i].a[j][l] = 0;
}
}
}
}
pre_comp();
cur = solve(n, cur, 0);
long long tot = 0;
for (int i = 0; i < k; i++) {
tot += cur.a[i];
}
tot--;
tot %= 1000000007LL;
if (tot < 0) tot += 1000000007LL;
while (tot % (k - 1) != 0) {
tot += 1000000007LL;
}
printf("%lld\n", tot / (k - 1));
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long powi(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
void solve() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int k = -1, in = -1;
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 0) {
k = 1;
in = i + 1;
}
}
if (k != -1) {
cout << k << endl << in;
return;
} else {
if (n == 1) {
cout << k;
return;
} else {
cout << 2 << endl;
cout << 1 << " " << 2;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, src, dst, s, t, ans, node, vol[200001], dist[200001],
present[200001];
list<int> adj[200001];
bool BFS(int q) {
for (int i = 1; i <= n; i++) {
dist[i] = INT_MAX - 1;
present[i] = 0;
}
queue<int> Q;
Q.push(s);
present[s] = 1;
dist[s] = 0;
while (!Q.empty()) {
int tmp = Q.front();
Q.pop();
present[tmp] = 0;
if (vol[tmp]) dist[tmp] = 0;
if (tmp == t) return true;
int new_dist = dist[tmp] + 1;
if (new_dist > q) continue;
for (auto it : adj[tmp]) {
if (new_dist < dist[it]) {
dist[it] = new_dist;
if (!present[it]) {
Q.push(it);
present[it] = 1;
}
}
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) {
cin >> node;
vol[node] = 1;
}
for (int i = 0; i < m; i++) {
cin >> src >> dst;
adj[src].push_back(dst);
adj[dst].push_back(src);
}
cin >> s >> t;
int lft = 1, rt = n, mid;
while (lft <= rt) {
mid = (rt - lft) / 2 + lft;
if (BFS(mid))
ans = mid, rt = mid - 1;
else
lft = mid + 1;
}
if (!ans)
cout << -1;
else
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5, M = 2e4 + 5, inf = 0x3f3f3f3f, mod = 1e9 + 7;
int main() {
string a;
cin >> a;
int n = a.size(), ans = 0;
string y;
for (int i = n - 1; ~i; i--) {
if (a[i] != '0') {
if (i > 1 || (i == 1 && a[0] >= a[1])) ans++;
} else {
int len = 0;
while (a[i] == '0') i--, len++;
len++;
if (i > len)
ans++;
else if (i == len) {
int ok = 1;
for (int j = 0; j < i; j++)
if (a[j] < a[j + i]) {
ok = 0;
break;
}
if (ok)
ans++;
else
break;
} else
break;
}
}
ans++;
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int k;
long long a[100005];
long long fpow(long long a, long long b) {
long long r = 1;
for (; b; b /= 2, a = (a * a) % 1000000007)
if (b & 1) r = (r * a) % 1000000007;
return r;
}
void mmul(int a[2][2], int b[2][2]) {
static int c[2][2];
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
const long long m = 1000000007 * 1LL * 1000000007;
long long s = 0;
for (int k = 0; k < 2; k++) {
s += a[i][k] * 1LL * b[k][j];
if (s >= m) s -= m;
}
c[i][j] = s % 1000000007;
}
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) a[i][j] = c[i][j];
}
int r[2][2];
void mpow(int a[2][2], long long b) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) r[i][j] = i == j;
for (; b; b /= 2, mmul(a, a))
if (b & 1) mmul(r, a);
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) a[i][j] = r[i][j];
}
int t[2][2];
int main() {
int k;
scanf("%d", &k);
bool one = true;
for (int i = 1; i <= k; i++) {
scanf("%lld", a + i);
one &= a[i] == 1;
}
if (one) {
printf("0/1\n");
return 0;
}
t[0][0] = 0;
t[0][1] = 1;
t[1][0] = 2;
t[1][1] = 1;
for (int i = 1; i <= k; i++) mpow(t, a[i]);
long long inv2 = fpow(2, 1000000007 - 2);
long long p = (t[0][0] * inv2) % 1000000007;
long long q = fpow(2, a[1]);
for (int i = 2; i <= k; i++) q = fpow(q, a[i]);
q = (q * inv2) % 1000000007;
printf("%lld/%lld\n", p, q);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long spf[2];
long long fac[2];
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 2; i++) spf[i] = i;
for (long long i = 4; i < 2; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 2; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 2; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
map<long long, long long> getfactor(long long a) {
map<long long, long long> m;
while (a > 1) {
m[spf[a]]++;
a /= spf[a];
}
return m;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long inverse(long long a, long long p) { return power(a, p - 2, p); }
long long ncr(long long n, long long r, long long p) {
if (r == 0) return 1;
return (fac[n] * inverse(fac[r], p) % p * inverse(fac[n - r], p) % p) % p;
}
long long seg[400001];
long long k;
void build(long long a[], long long v, long long l, long long r) {
if (l == r) {
seg[v] = a[l];
return;
}
long long mid = (l + r) / 2;
build(a, v * 2, l, mid);
build(a, v * 2 + 1, mid + 1, r);
seg[v] = gcd(k, seg[v * 2] * seg[v * 2 + 1]);
}
long long query(long long v, long long l, long long r, long long posl,
long long posr) {
if (l >= posl && r <= posr)
return seg[v];
else if (l > posr || r < posl)
return 1;
long long mid = (l + r) / 2;
return gcd(k, (query(v * 2, l, mid, posl, posr) *
query(v * 2 + 1, mid + 1, r, posl, posr)));
}
void solve() {
long long n;
cin >> n >> k;
long long a[n + 1];
for (long long i = 1; i <= n; i++) cin >> a[i];
build(a, 1, 1, n);
long long r = 1;
long long ans = 0;
for (long long i = 1; i <= n; i++) {
if (r < i)
while (r < i) r++;
while (query(1, 1, n, i, r) % k > 0 && r <= n) r++;
if (r <= n) ans += (n - r) + 1;
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
for (int i = a; i > 0; i--) {
if (a % i == 0) {
a = i;
cout << a << " ";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
A cvt(B x) {
stringstream ss;
ss << x;
A y;
ss >> y;
return y;
}
vector<long long> lucky;
void build(int len = 0, long long x = 0) {
if (x != 0) lucky.push_back(x);
if (len < 18) {
build(len + 1, x * 10 + 4);
build(len + 1, x * 10 + 7);
}
}
long long L[600000], R[600000];
long long n, k;
vector<pair<long long, int> > p;
int main() {
build();
sort(lucky.begin(), lucky.end());
cin >> n >> k;
long long ms = -1;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
if (ms == -1 || y - x < ms) {
ms = y - x;
}
p.push_back(make_pair(x, 1));
p.push_back(make_pair(y, -1));
}
sort(p.begin(), p.end());
int j, c, cc;
long long f;
j = 0;
c = 0;
cc = 0;
f = 0;
int ls = lucky.size();
for (int i = 0; i < ls; i++) {
for (; j < p.size() && p[j].first <= lucky[i]; j++) {
if (p[j].second == -1) {
f = min(1000000000000000001LL, f + lucky[i] - p[j].first);
c++;
}
}
if (cc > 0) {
long long b = 1000000000000000001LL / cc + 1;
long long dl = lucky[i] - lucky[i - 1];
if (dl > b)
f = 1000000000000000001LL;
else
f = min(1000000000000000001LL, f + cc * dl);
}
L[i] = f;
cc = c;
}
j = p.size() - 1;
c = 0;
cc = 0;
f = 0;
for (int i = ls - 1; i >= 0; i--) {
for (; j >= 0 && p[j].first >= lucky[i]; j--) {
if (p[j].second == 1) {
f = min(1000000000000000001LL, f + p[j].first - lucky[i]);
c++;
}
}
if (cc > 0) {
long long b = 1000000000000000001LL / cc + 1;
long long dl = lucky[i + 1] - lucky[i];
if (dl > b)
f = 1000000000000000001LL;
else
f = min(1000000000000000001LL, f + cc * dl);
}
R[i] = f;
cc = c;
}
j = 0;
int best = 0;
for (int i = 0; i < ls; i++) {
while (lucky[i] - lucky[j] > ms) j++;
while (j < i && R[j] + L[i] > k) j++;
if (R[j] + L[i] <= k) {
int a = i - j + 1;
if (a > best) {
best = a;
}
}
}
printf("%d\n", best);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
const long long maxn = 4e5 + 5, N = 1e6 + 20, SQ = 450, base = 800287,
mod = 1e9 + 7, INF = 1e18 + 5, lg = 20;
const long double eps = 1e-4;
struct node {
long long mx, lazy;
};
stack<long long> st;
node seg[4 * maxn];
long long n, a[maxn], L[maxn], R[maxn];
void build(long long v = 1, long long s = 0, long long e = 2 * n) {
if (e - s == 1) {
long long x = (s < n ? 0 : -INF);
seg[v].mx = x;
seg[v].lazy = 0;
return;
}
build(2 * v, s, (s + e) / 2);
build(2 * v + 1, (s + e) / 2, e);
seg[v].lazy = 0;
seg[v].mx = max(seg[2 * v].mx, seg[2 * v + 1].mx);
}
void find_L() {
for (long long i = 0; i < 2 * n; ++i) {
while ((long long)st.size() && a[st.top()] > a[i]) {
st.pop();
}
L[i] = ((long long)st.size() ? st.top() : -1);
st.push(i);
}
while ((long long)st.size()) {
st.pop();
}
}
void find_R() {
for (long long i = 2 * n - 1; i >= 0; --i) {
while ((long long)st.size() && a[st.top()] > a[i]) {
st.pop();
}
R[i] = ((long long)st.size() ? st.top() : 2 * n);
st.push(i);
}
while ((long long)st.size()) {
st.pop();
}
}
inline void shift(long long v) {
seg[2 * v].mx += seg[v].lazy;
seg[2 * v + 1].mx += seg[v].lazy;
seg[2 * v].lazy += seg[v].lazy;
seg[2 * v + 1].lazy += seg[v].lazy;
seg[v].lazy = 0;
}
void add(long long l, long long r, long long x, long long v = 1,
long long s = 0, long long e = 2 * n) {
if (l >= e || s >= r) {
return;
}
if (l <= s && e <= r) {
seg[v].mx += x;
seg[v].lazy += x;
return;
}
shift(v);
add(l, r, x, 2 * v, s, (s + e) / 2);
add(l, r, x, 2 * v + 1, (s + e) / 2, e);
seg[v].mx = max(seg[2 * v].mx, seg[2 * v + 1].mx);
}
void modify(long long p, long long x, long long v = 1, long long s = 0,
long long e = 2 * n) {
if (e - s == 1) {
seg[v].mx = x;
return;
}
shift(v);
if (p < (s + e) / 2) {
modify(p, x, 2 * v, s, (s + e) / 2);
} else {
modify(p, x, 2 * v + 1, (s + e) / 2, e);
}
seg[v].mx = max(seg[2 * v].mx, seg[2 * v + 1].mx);
}
long long get(long long p, long long v = 1, long long s = 0,
long long e = 2 * n) {
if (e - s == 1) {
return seg[v].mx;
}
shift(v);
long long res;
if (p < (s + e) / 2) {
res = get(p, 2 * v, s, (s + e) / 2);
} else {
res = get(p, 2 * v + 1, (s + e) / 2, e);
}
seg[v].mx = max(seg[2 * v].mx, seg[2 * v + 1].mx);
return res;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
a[i + n] = a[i];
}
build();
find_L();
find_R();
for (long long i = 0; i < n; ++i) {
add(L[i] + 1, i, 1);
add(i + 1, R[i], 1);
}
long long res = INF, id = -1;
for (long long i = 0; i < n; ++i) {
if (seg[1].mx < res) {
res = seg[1].mx;
id = i;
}
long long val = (L[i + n] <= i ? 0 : get(L[i + n]) + 1);
add(i + 1, R[i], -1);
add(L[i + n] + 1, i + n, 1);
modify(i, -INF), modify(i + n, val);
}
cout << res + 1 << ' ' << id << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 2e3 + 5, mod = 998244353, inf = mod;
long long n;
long long arr[maxn][maxn];
long long dp[maxn][maxn];
long long pw[maxn], fac[maxn];
struct bit {
vector<long long> sum = vector<long long>(maxn, 0);
void add(long long i, long long v) {
for (; i < maxn; i += i & -i) {
sum[i] += v;
assert(sum[i] >= 0);
}
}
long long get(long long i) {
long long r = 0;
for (; i; i -= i & -i) {
r += sum[i];
}
return r;
}
void reset() {
fill(begin(sum), end(sum), 0);
for (long long i = (long long)1; i <= (long long)n; i++) add(i, 1);
}
} avoid, can;
bool first[maxn], us[maxn];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
fac[0] = 1;
for (long long i = (long long)1; i <= (long long)n; i++) {
fac[i] = fac[i - 1] * i % mod;
}
for (long long i = (long long)1; i <= (long long)n; i++) {
for (long long j = (long long)1; j <= (long long)n; j++) {
cin >> arr[i][j];
}
}
dp[0][0] = 1;
for (long long i = (long long)1; i <= (long long)n; i++) {
dp[i][0] = dp[i - 1][0] * i % mod;
for (long long av = (long long)1; av <= (long long)i; av++) {
dp[i][av] = (dp[i - 1][av - 1] * (i - av) % mod +
(av > 1 ? (av - 1) * dp[i - 1][av - 2] % mod : 0)) %
mod;
}
}
pw[0] = 1;
for (long long i = (long long)1; i <= (long long)n; i++) {
pw[i] = pw[i - 1] * dp[n][n] % mod;
}
long long ans = 0;
can.reset();
for (long long i = (long long)1; i <= (long long)n; i++) {
can.add(arr[1][i], -1);
ans += can.get(arr[1][i] - 1) * fac[n - i] % mod * pw[n - 1] % mod;
ans %= mod;
}
for (long long i = (long long)2; i <= (long long)n; i++) {
avoid.reset();
can.reset();
fill(begin(first), end(first), 0);
fill(begin(us), end(us), 0);
long long av = n;
for (long long j = (long long)1; j <= (long long)n; j++) {
if (us[arr[i - 1][j]]) {
long long notf = avoid.get(arr[i][j] - 1), tot = can.get(arr[i][j] - 1);
ans += notf * dp[n - j][avoid.get(n) - 1] % mod * pw[n - i] % mod;
ans += (tot - notf) * dp[n - j][avoid.get(n)] % mod * pw[n - i] % mod;
ans %= mod;
} else {
long long notf = avoid.get(arr[i][j] - 1) - (arr[i - 1][j] < arr[i][j]);
long long tot = can.get(arr[i][j] - 1) - (arr[i - 1][j] < arr[i][j]);
ans += notf * dp[n - j][avoid.get(n) - 2] % mod * pw[n - i] % mod;
ans +=
(tot - notf) * dp[n - j][avoid.get(n) - 1] % mod * pw[n - i] % mod;
ans %= mod;
}
first[arr[i - 1][j]] = 1;
us[arr[i][j]] = 1;
if (!first[arr[i][j]]) avoid.add(arr[i][j], -1);
if (!us[arr[i - 1][j]]) avoid.add(arr[i - 1][j], -1);
can.add(arr[i][j], -1);
}
}
cout << ans;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
bool flag1 = false;
bool flag2 = false;
bool flag3 = false;
bool flag4 = false;
bool flag5 = false;
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'h') {
flag1 = true;
}
if (flag1 == true && s[i] == 'e') {
flag2 = true;
}
if (flag2 == true && s[i] == 'i') {
flag3 = true;
}
if (flag3 == true && s[i] == 'd') {
flag4 = true;
}
if (flag4 == true && s[i] == 'i') {
flag5 = true;
}
}
if (flag5 == true) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[21][21];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
}
}
bool joketest = true;
for (int i = 1; i <= n; ++i) {
int cnttest = 0;
for (int j = 1; j <= m; ++j) {
if (a[i][j] != j) {
++cnttest;
}
}
if (cnttest > 2) {
joketest = false;
break;
}
}
if (joketest) {
cout << "YES" << endl;
return 0;
}
for (int col1 = 1; col1 < m; ++col1) {
for (int col2 = col1 + 1; col2 <= m; ++col2) {
for (int i = 1; i <= n; ++i) {
swap(a[i][col1], a[i][col2]);
}
bool joke = true;
for (int i = 1; i <= n; ++i) {
int cnt = 0;
for (int j = 1; j <= m; ++j) {
if (a[i][j] != j) {
++cnt;
}
}
if (cnt > 2) {
joke = false;
break;
}
}
if (joke) {
cout << "YES" << endl;
return 0;
}
for (int i = 1; i <= n; ++i) {
swap(a[i][col1], a[i][col2]);
}
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 1e6 + 17;
int n;
int dp[N], pre[N], f[N];
char s[N];
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; ++i) pre[i] = pre[i - 1] + (s[i] == '0');
int dd = 0, t = 0;
for (int i = 1; i <= n; ++i) {
dp[i] = dp[i - 1] + (s[i] == '1');
f[i] = i - 1;
if (dp[i] > dd + pre[i] + 2) {
dp[i] = dd + pre[i] + 2;
f[i] = t;
}
if (s[i] == '0') {
if (dp[i] - pre[i] < dd) {
dd = dp[i] - pre[i];
t = i;
}
}
}
cout << dp[n] << endl;
int cur = n;
vector<pair<int, int> > v;
while (cur) {
if (f[cur] == cur - 1) {
if (s[cur] == '1') {
v.push_back(pair<int, int>(n - cur, 1));
}
cur = f[cur];
} else {
int l = f[cur];
v.push_back(pair<int, int>(n - l, 1));
v.push_back(pair<int, int>(n - cur, -1));
for (int i = l + 1; i <= cur; ++i)
if (s[i] == '0') v.push_back(pair<int, int>(n - i, -1));
cur = f[cur];
}
}
for (pair<int, int> p : v)
if (p.second == 1)
printf("+2^%d\n", p.first);
else
printf("-2^%d\n", p.first);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int const M = 3e5 + 10, mod = 1e9 + 7, inf = 1e9 + 10;
int a[M], n, q[M], p[M], d[M];
bool vis[M];
bool mark[M];
vector<int> hlp;
vector<int> ans, adj[M];
int mn = inf, now = 0;
void dfs(int v) {
now++;
mark[v] = 1;
hlp.push_back(v);
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u]) dfs(u);
}
}
int pw(int x, int y) {
if (y == 0) return 1;
int tmp = pw(x, y / 2);
if (y % 2 == 0) return (tmp * tmp) % mod;
return (((tmp * tmp) % mod) * x) % mod;
}
int sa(int x, int y) {
if (x % y == 0) return x / y;
return x / y + 1;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
if (a > b) swap(a, b);
if (a == 1 && b == n) {
cout << 1 << endl;
cout << 1 << " " << n;
return 0;
}
adj[a].push_back(b);
adj[b].push_back(a);
}
int head = 0, tail = 0;
q[head++] = 1;
d[1] = 1;
int cnt = 0;
while (head > tail) {
cnt++;
int v = q[tail++];
if (v == n) {
mn = min(mn, d[v] - 1);
int tmp = v;
ans.push_back(tmp);
while (p[tmp] != 0) {
ans.push_back(p[tmp]);
tmp = p[tmp];
}
reverse(ans.begin(), ans.end());
}
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (!d[u]) q[head++] = u, d[u] = d[v] + 1, p[u] = v;
}
}
if (adj[1].size() != cnt - 1 && mn > 4) {
ans.clear();
mn = 4;
mark[1] = 1;
for (int j = 0; j < adj[1].size(); j++) {
int u = adj[1][j];
mark[u] = 1;
}
bool flag = 0;
for (int j = 0; j < adj[1].size(); j++) {
if (flag) break;
int u = adj[1][j];
for (int k = 0; k < adj[u].size(); k++) {
int uu = adj[u][k];
if (!mark[uu] && ans.size() == 0) {
ans.push_back(1);
ans.push_back(u);
ans.push_back(uu);
ans.push_back(1);
ans.push_back(n);
flag = 1;
break;
}
}
}
} else if (mn > 5 && adj[1].size() == cnt - 1) {
int good = 0;
mark[1] = 1;
bool flag = 0;
for (int i = 0; i < adj[1].size(); i++) {
now = 0;
if (flag) break;
hlp.clear();
int u = adj[1][i];
if (!mark[u])
dfs(u);
else
continue;
for (int j = 0; j < hlp.size(); j++) {
int uu = hlp[j];
if (adj[uu].size() != now) good = uu;
}
if (good == 0) continue;
for (int k = 0; k < adj[good].size(); k++) vis[adj[good][k]] = 1;
vis[good] = 1;
for (int k = 0; k < adj[good].size(); k++) {
int vv = adj[good][k];
if (vv == 1) continue;
for (int l = 0; l < adj[vv].size(); l++) {
int nn = adj[vv][l];
if (!vis[nn] && nn != 1) {
flag = 1;
mn = 5;
ans.push_back(1);
ans.push_back(good);
ans.push_back(vv);
ans.push_back(nn);
ans.push_back(good);
ans.push_back(n);
break;
}
}
if (flag) break;
}
}
}
if (mn == inf) return cout << -1, 0;
cout << mn << endl;
for (int j = 0; j < ans.size(); j++) cout << ans[j] << " ";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
const long long maxn = 3e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 10;
bool valid[30], ss[33];
int32_t main() {
long long n = in();
memset(valid, true, sizeof valid);
bool found = false;
long long letter = -1;
long long ans = 0;
for (long long i = 0; i < n; i++) {
char ch;
cin >> ch;
if (ch == '?') {
char aa;
cin >> aa;
if ((aa - 'a') != letter && found) ans++;
valid[aa - 'a'] = false;
} else {
string s;
cin >> s;
if (ch == '.') {
for (auto x : s) {
valid[x - 'a'] = false;
}
} else {
memset(ss, 0, sizeof ss);
for (auto u : s) {
ss[u - 'a'] = true;
}
for (long long j = 0; j < 26; j++)
if (!ss[j]) valid[j] = false;
}
if (ch == '!' && found) ans++;
}
long long cnt = 0;
for (long long j = 0; j < 26; j++) {
if (valid[j]) {
cnt++, letter = j;
}
}
if (cnt == 1) {
found = true;
}
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
const int Inf = 0x3f3f3f3f;
const int MN = 100005, MS = 1 << 18 | 7;
inline void chmin(int &x, int y) { x = x < y ? x : y; }
int N, M, Q;
char str[2][MN];
int Coef;
struct SegmentTree {
int mycoef;
struct dat {
int f[2][2][2];
int c[2][2];
dat() {}
dat(int v0, int v1) {
f[0][0][0] = v0 + v1, f[0][1][1] = !v0 + !v1;
f[1][0][0] = v0 + !v1, f[1][1][1] = !v0 + v1;
f[0][0][1] = f[0][1][0] = f[1][0][1] = f[1][1][0] = Inf;
c[0][v0] = 1, c[0][!v0] = 0;
c[1][v1] = 1, c[1][!v1] = 0;
}
friend dat operator+(dat a, dat b) {
dat c;
for (int k = 0; k < 2; ++k)
for (int x = 0; x < 2; ++x)
for (int y = 0; y < 2; ++y) {
c.f[k][x][y] = Inf;
for (int z = 0; z < 2; ++z)
for (int w = 0; w < 2; ++w)
chmin(c.f[k][x][y],
a.f[k][x][z] + b.f[k][w][y] + (z != w) * Coef);
}
for (int k = 0; k < 2; ++k)
for (int x = 0; x < 2; ++x) c.c[k][x] = a.c[k][x] + b.c[k][x];
return c;
}
} tr[MS];
int tag[MS];
inline void P(int i, int rev) {
tag[i] ^= rev;
if (rev & 1) {
std::swap(tr[i].c[0][0], tr[i].c[0][1]);
std::swap(tr[i].c[1][0], tr[i].c[1][1]);
for (int k = 0; k < 2; ++k)
for (int y = 0; y < 2; ++y)
std::swap(tr[i].f[k][0][y], tr[i].f[k][1][!y]);
rev ^= 3;
}
if (rev & 2) {
std::swap(tr[i].c[1][0], tr[i].c[1][1]);
for (int x = 0; x < 2; ++x)
for (int y = 0; y < 2; ++y)
std::swap(tr[i].f[0][x][y], tr[i].f[1][x][y]);
}
}
inline void Pushdown(int i) {
if (tag[i]) P((i << 1), tag[i]), P(((i << 1) | 1), tag[i]), tag[i] = 0;
}
void Build(int i, int l, int r) {
if (l == r) return tr[i] = dat(str[0][l] == 'R', str[1][l] == 'R'), void();
Build((i << 1), l, ((l + r) >> 1)),
Build(((i << 1) | 1), ((l + r) >> 1) + 1, r);
Coef = mycoef, tr[i] = tr[(i << 1)] + tr[((i << 1) | 1)];
}
void Mdf(int i, int l, int r, int a, int b, int x) {
if (r < a || b < l) return;
if (a <= l && r <= b) return P(i, x), void();
Pushdown(i), Mdf((i << 1), l, ((l + r) >> 1), a, b, x),
Mdf(((i << 1) | 1), ((l + r) >> 1) + 1, r, a, b, x);
Coef = mycoef, tr[i] = tr[(i << 1)] + tr[((i << 1) | 1)];
}
} A, B;
inline int Ans() {
int ret = Inf;
for (int x = 0; x < 2; ++x)
for (int y = 0; y < 2; ++y)
chmin(ret, A.tr[1].f[0][x][y] + B.tr[1].c[0][!x] + B.tr[1].c[1][!y]);
for (int x = 0; x < 2; ++x)
for (int y = 0; y < 2; ++y)
chmin(ret, B.tr[1].f[0][x][y] + A.tr[1].c[0][!x] + A.tr[1].c[1][!y]);
return ret;
}
int main() {
scanf("%d%d%d", &N, &M, &Q);
scanf("%s%s", str[0] + 1, str[1] + 1), A.mycoef = M, A.Build(1, 1, N);
scanf("%s%s", str[0] + 1, str[1] + 1), B.mycoef = N, B.Build(1, 1, M);
printf("%d\n", Ans());
while (Q--) {
char s[3];
int l, r;
scanf("%s%d%d", s, &l, &r);
if (*s == 'L') A.Mdf(1, 1, N, l, r, 1);
if (*s == 'R') A.Mdf(1, 1, N, l, r, 2);
if (*s == 'U') B.Mdf(1, 1, M, l, r, 1);
if (*s == 'D') B.Mdf(1, 1, M, l, r, 2);
printf("%d\n", Ans());
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int f[10005];
int c[130];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int x = a[n - 1];
for (int i = 1; i <= x; i++) {
if (x % i == 0) {
f[i] = 1;
}
}
for (int i = 0; i < n; i++) {
if (f[a[i]]) {
f[a[i]] = 0;
c[i] = 1;
}
}
int y = 0;
for (int i = 0; i < n; i++) {
if (!c[i]) {
y = max(y, a[i]);
}
}
cout << x << " " << y << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1;
for (long long tt = 1; tt <= T; tt++) {
int n, mn = 1e9;
cin >> n;
n *= 2;
vector<int> ls(n);
for (int &x : ls) cin >> x;
sort(ls.begin(), ls.end());
for (int u = 0; u < n; u++) {
for (int v = 0; v < n; v++) {
if (v != u) {
map<int, int> vis;
vis[u] = vis[v] = 1;
int w = 0, x = 0, sm = 0;
while (x < n) {
while (vis[w]) w++;
while (vis[x] || x == w) x++;
if (x < n) sm += ls[x] - ls[w], vis[w] = vis[x] = 1;
w++, x++;
}
mn = min(mn, sm);
}
}
}
cout << mn;
cout << '\n';
}
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.