solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
int a[N];
int b[N];
int posa[N];
int posb[N];
int main() {
int n;
scanf("%d", &n);
vector<int> temp, temp1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
for (int i = 0; i < n; i++) {
if (a[i] != 0) {
temp.push_back(a[i]);
}
if (b[i] != 0) {
temp1.push_back(b[i]);
}
}
for (int i = 0; i < temp.size(); i++) {
posa[temp[i]] = i;
posb[temp1[i]] = i;
}
int diff = 0;
for (int i = 1; i < n; i++) {
if (posb[i] >= posa[i]) {
diff = posb[i] - posa[i];
break;
}
}
bool ok = true;
for (int i = 0; i < temp.size(); i++) {
if (temp1[((i + diff) % (n - 1))] != temp[i]) {
ok = false;
break;
}
}
if ((ok))
cout << "YES";
else
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gi() {
char cc = getchar();
int cn = 0, flus = 1;
while (cc < '0' || cc > '9') {
if (cc == '-') flus = -flus;
cc = getchar();
}
while (cc >= '0' && cc <= '9') cn = cn * 10 + cc - '0', cc = getchar();
return cn * flus;
}
const int N = 1e5 + 5;
int n, a[N];
signed main() {
int T = gi();
while (T--) {
n = gi();
int type = 0;
for (register int i = 1; i <= n; ++i) {
a[i] = gi();
if (a[i] % 2 == 0) type = i;
}
if (type) {
printf("1\n");
printf("%d\n", type);
} else {
if (n == 1)
puts("-1");
else {
puts("2");
printf("1 2\n");
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000002;
inline void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
x *= f;
}
int n, k, res;
long long dp[502][502], ans[502];
int main() {
read(n), read(k);
dp[0][0] = 1;
for (register int i = 1; i <= n; ++i)
for (register int j = 1; j <= i; ++j)
for (register int k = 1; k <= j; ++k)
(dp[i][j] += dp[i - k][min(j, i - k)]) %= 998244353;
for (register int i = 1; i <= n; ++i)
ans[i] = (dp[n][i] - dp[n][i - 1] + 998244353) % 998244353;
for (register int i = 1; i <= n; ++i)
for (register int j = 1; j <= n; ++j) {
if (i * j >= k)
break;
else
(res += ans[i] * ans[j] % 998244353) %= 998244353;
}
printf("%d\n", res * 2 % 998244353);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << "(" << p.first << "," << p.second << ")";
}
const double pi = acos(-1);
const int inf = (1 << 30);
const long long INF = (1LL << 62) - 1;
const int mod = (int)1e9 + 7;
const long long MOD = (long long)1e9 + 7;
const double EPS = 1e-9;
const int dx8[] = {-1, 0, +1, -1, +1, -1, 0, +1};
const int dy8[] = {+1, +1, +1, 0, 0, -1, -1, -1};
const int dx4[] = {0, -1, +1, 0};
const int dy4[] = {+1, 0, 0, -1};
const int dx2[] = {+1, 0};
const int dy2[] = {0, +1};
const int dxkn[] = {1, -1, 1, -1, 2, -2, -2, 2};
const int dykn[] = {2, 2, -2, -2, 1, 1, -1, -1};
struct point {
double x;
double y;
point(double p, double q) {
x = p;
y = q;
}
void print() { printf("Point = (%0.2lf, %0.2lf)\n", x, y); }
};
struct line {
double a;
double b;
double c;
line(point p, point q) {
if (p.x == q.x && p.y == q.y) {
a = 0;
b = 0;
c = 0;
} else if (p.x == q.x) {
this->a = 1;
this->b = 0;
this->c = -p.x;
} else if (p.y == q.y) {
this->a = 0;
this->b = 1;
this->c = -p.y;
} else {
this->a = (p.y - q.y);
this->b = (q.x - p.x);
this->c = (p.y * (p.x - q.x) - p.x * (p.y - q.y));
}
}
void print() {
printf("Line = %0.2lfx + %0.2lfy + %0.2lf = 0\n", this->a, this->b,
this->c);
}
};
vector<point> p;
int main() {
int i, n;
double x, y, d, ans;
cin >> n;
p.push_back({0, 0});
for (i = 1; i <= n; i++) {
cin >> x >> y;
p.push_back({x, y});
}
p.push_back({p[1].x, p[1].y});
p[0].x = p[n].x;
p[0].y = p[n].y;
for (i = 1, ans = 100000000000000000.0; i <= n; i++) {
line l = line(p[i - 1], p[i + 1]);
d = l.a * p[i].x + l.b * p[i].y + l.c;
d /= (2.0 * sqrt(l.a * l.a + l.b * l.b));
d = abs(d);
ans = min(d, ans);
}
cout << setprecision(10) << ans << "\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
const long long MOD = 1000000007;
using namespace std;
long long jcn_1 = 1, inv_jcn_1, n, f[100], s, ans = 0;
long long pow(long long a, long long b) {
long long ans = 1;
a %= MOD;
while (b) {
if (b & 1) ans = (ans * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return ans;
}
long long C(long long k) {
long long ans = 1;
for (long long i = s - k + 1; i <= n + s - k - 1; i++)
ans = (ans * (i % MOD)) % MOD;
return ans * inv_jcn_1 % MOD;
}
void dfs(long long pos, long long opt, long long x) {
if (pos == n) {
if (x > s) return;
ans = ((ans + opt * C(x)) % MOD + MOD) % MOD;
return;
}
dfs(pos + 1, opt, x);
dfs(pos + 1, -opt, x + f[pos + 1] + 1);
}
signed main() {
scanf("%I64d %I64d", &n, &s);
for (long long i = 1; i < n; i++) jcn_1 *= i;
inv_jcn_1 = pow(jcn_1, MOD - 2);
for (long long i = 1; i <= n; i++) scanf("%I64d", &f[i]);
dfs(0, 1, 0);
printf("%I64d\n", ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
long long arr[2001];
cin >> n >> a >> b;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n, greater<int>());
cout << arr[a - 1] - arr[n - b] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200;
const int MAXLG = 16;
typedef double Mat[MAXN][MAXN];
typedef double Vec[MAXN];
struct P {
int x, y;
};
int n;
P p[MAXN];
Mat pone;
Mat pmany[MAXLG + 1];
Vec pok;
void mmlt(const Mat &A, const Mat &B, Mat &C) {
Mat tmp;
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j) {
double cur = 0;
for (int k = (0); k < (n); ++k) cur += A[i][k] * B[k][j];
tmp[i][j] = cur;
}
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j) C[i][j] = tmp[i][j];
}
void vmlt(const Mat &A, const Vec &b, Vec &c) {
Vec tmp;
for (int i = (0); i < (n); ++i) {
double cur = 0;
for (int j = (0); j < (n); ++j) cur += A[i][j] * b[j];
tmp[i] = cur;
}
for (int i = (0); i < (n); ++i) c[i] = tmp[i];
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d%d", &p[i].x, &p[i].y);
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j) pone[i][j] = 0;
for (int i = (0); i < (n); ++i) {
map<pair<int, int>, vector<int> > cur;
for (int j = (0); j < (n); ++j)
if (j != i) {
int dx = p[j].x - p[i].x, dy = p[j].y - p[i].y;
if (dy < 0 || dy == 0 && dx < 0) dy = -dy, dx = -dx;
int g = gcd(abs(dx), dy);
dx /= g, dy /= g;
cur[make_pair(dx, dy)].push_back(j);
}
for (auto it = cur.begin(); it != cur.end(); ++it) {
vector<int> now = it->second;
double peach = 1.0 / ((int)(cur).size()) / (((int)(now).size()) + 1);
pone[i][i] += peach;
for (int j = (0); j < (((int)(now).size())); ++j)
pone[i][now[j]] += peach;
}
}
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (n); ++j) pmany[0][i][j] = pone[i][j];
for (int k = (0); k < (MAXLG); ++k) mmlt(pmany[k], pmany[k], pmany[k + 1]);
set<vector<int> > opt;
for (int i = (0); i < (n); ++i) {
map<pair<int, int>, vector<int> > cur;
for (int j = (0); j < (n); ++j)
if (j != i) {
int dx = p[j].x - p[i].x, dy = p[j].y - p[i].y;
if (dy < 0 || dy == 0 && dx < 0) dy = -dy, dx = -dx;
int g = gcd(abs(dx), dy);
dx /= g, dy /= g;
cur[make_pair(dx, dy)].push_back(j);
}
for (auto it = cur.begin(); it != cur.end(); ++it) {
vector<int> now = it->second;
now.push_back(i);
sort(now.begin(), now.end());
opt.insert(now);
}
}
int nq;
scanf("%d", &nq);
for (int qi = (0); qi < (nq); ++qi) {
int dst, steps;
scanf("%d%d", &dst, &steps);
--dst, --steps;
for (int i = (0); i < (n); ++i) pok[i] = i == dst ? 1.0 : 0.0;
for (int k = (0); k <= (MAXLG); ++k)
if (steps & (1 << k)) vmlt(pmany[k], pok, pok);
double ans = 0;
for (auto it = opt.begin(); it != opt.end(); ++it) {
vector<int> now = *it;
double sum = 0;
for (int j = (0); j < (((int)(now).size())); ++j) sum += pok[now[j]];
ans = max(ans, sum / ((int)(now).size()));
}
printf("%.15lf\n", ans);
}
}
int main() {
run();
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110;
char a[MAXN][MAXN];
char check(char a) {
if (a == '<') {
return '>';
}
if (a == '>') {
return '<';
}
return a;
}
int main() {
int n, x;
cin >> n >> x;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
a[i][j] = '.';
}
}
for (int i = 0; i < n / 2; i++) {
int k = 2 * i, k2 = 2 * i + 1;
for (int j = 0; j < n / 2; j++) {
a[k][j] = '>';
}
for (int j = n / 2 + 1; j < n - 1; j += 2) {
a[k][j] = '>';
}
a[k][n - 1] = 'v';
for (int j = 0; j < n / 2 - 1; j++) {
a[k2][(n - 1) - j] = '<';
}
for (int j = n / 2; j < n - 1; j += 2) {
a[k2][(n - 1) - j] = '<';
}
a[k2][0] = '^';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i / 2) % 2 == 0) {
cout << a[i][j];
} else {
cout << check(a[i][(n - 1) - j]);
}
}
cout << endl;
}
cout << 1 << ' ' << 1 << endl;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<vector<int>> v;
stack<vector<int>> second;
for (long long i = 0; i < n; i++) {
vector<int> v1(5, 0);
for (int j = 0; j < 5; j++) {
cin >> v1[j];
}
v.push_back(v1);
second.push(v1);
}
if (n <= 1) {
cout << n << endl;
continue;
}
while (second.size() != 1) {
vector<int> v1 = second.top();
second.pop();
vector<int> v2 = second.top();
second.pop();
int cv1 = 0, cv2 = 0;
for (int i = 0; i < 5; i++) {
if (v1[i] > v2[i]) {
cv2++;
} else if (v1[i] < v2[i]) {
cv1++;
}
}
if (cv1 > cv2) {
second.push(v1);
} else {
second.push(v2);
}
}
bool chck = true;
vector<int> rem = second.top();
for (int i = 0; i < n; i++) {
int c = 0;
for (int j = 0; j < 5; j++) {
if (rem[j] <= v[i][j]) {
c++;
}
}
if (c < 3) {
chck = false;
break;
}
}
if (chck) {
cout << (find(v.begin(), v.end(), rem) - v.begin()) + 1 << endl;
} else {
cout << -1 << endl;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, K, s[25], t[25];
int x[1000005], y[1000005], ans = -1, L = 0, R = 0;
int build(int *bs, int *per) {
int S = 0;
for (int i = 0; i < K; i++) S |= bs[per[i]] << i;
return S;
}
int per[25];
int mn[1100000], mx[1100000];
int main() {
scanf("%d%d%d", &n, &m, &K);
int coe = K;
memset(mn, 0x3f, sizeof(mn));
memset(mx, -0x3f, sizeof(mx));
for (int i = 0, x; i < K; i++) scanf("%1d", s + i), coe -= s[i];
for (int i = 0, x; i < K; i++) scanf("%1d", t + i), coe -= t[i];
for (int i = 1; i <= n; i++) scanf("%d%d", x + i, y + i), x[i]--, y[i]--;
for (int i = 0; i < K; i++) per[i] = i;
for (int i = n; i; i--) {
int T = build(t, per);
mx[T] = max(mx[T], i + 1);
for (int j = 0; j < K; j++)
if (per[j] == x[i])
per[j] = y[i];
else if (per[j] == y[i])
per[j] = x[i];
int S = build(s, per);
mn[S] = i;
}
for (int i = 1; i < (1 << K); i <<= 1)
for (int j = 0; j < (1 << K); j++)
if (i & j) mn[i ^ j] = min(mn[i ^ j], mn[j]);
for (int i = 1; i < (1 << K); i <<= 1)
for (int j = 0; j < (1 << K); j++)
if (i & j) mx[i ^ j] = max(mx[i ^ j], mx[j]);
for (int i = 0; i < (1 << K); i++)
if (mx[i] - mn[i] >= m) {
int res = (__builtin_popcount(i) << 1) + coe;
if (res > ans) ans = res, L = mn[i], R = mx[i] - 1;
}
printf("%d\n%d %d\n", ans, L, R);
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 100100;
const int MAXM = 2100100;
long long int ned;
long long int first[MAXN], dist[MAXN], work[MAXN];
long long int nxt[MAXM], to[MAXM], cap[MAXM];
void init() {
memset(first, -1, sizeof first);
ned = 0;
}
void add(int u, int v, long long int f) {
to[ned] = v, cap[ned] = f;
nxt[ned] = first[u];
first[u] = ned++;
to[ned] = u, cap[ned] = 0;
nxt[ned] = first[v];
first[v] = ned++;
}
long long int dfs(int u, long long int f, int s, int t) {
if (u == t) return f;
long long int df, v;
for (long long int &e = work[u]; e != -1; e = nxt[e]) {
v = to[e];
if (dist[v] == dist[u] + 1 && cap[e] > 0) {
df = dfs(v, min(f, cap[e]), s, t);
if (df > 0) {
cap[e] -= df;
cap[e ^ 1] += df;
return df;
}
}
}
return 0;
}
bool bfs(int s, int t) {
int u, v;
memset(&dist, -1, sizeof(dist));
dist[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
u = q.front();
q.pop();
for (int e = first[u]; e != -1; e = nxt[e]) {
v = to[e];
if (dist[v] < 0 && cap[e] > 0) {
dist[v] = dist[u] + 1;
q.push(v);
}
}
}
return dist[t] >= 0;
}
long long int dinic(int s, int t) {
long long int result = 0, f;
while (bfs(s, t)) {
memcpy(work, first, sizeof work);
while (true) {
f = dfs(s, 1e18, s, t);
result += f;
if (!f) break;
}
}
return result;
}
int vtx[3030];
int are[3030];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
init();
for (int i = 1; i <= n; i++) {
cin >> vtx[i];
add(m + i, m + n + 1, vtx[i]);
}
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
cin >> are[i];
add(0, i, are[i]);
add(i, m + u, INF);
add(i, m + v, INF);
}
long long int ans = 0;
for (int i = 1; i <= m; i++) ans += are[i];
cout << ans - dinic(0, n + m + 1) << endl;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int rev[600500];
struct cd {
double r, i;
cd(double _r = 0.0, double _i = 0.0) {
r = _r;
i = _i;
}
cd operator-(const cd &b) const { return cd(r - b.r, i - b.i); }
cd operator+(const cd &b) const { return cd(r + b.r, i + b.i); }
cd operator*(const cd &b) const {
return cd(r * b.r - i * b.i, r * b.i + i * b.r);
}
} a[600500], b[600500];
void change(cd y[], int len) {
for (int i = 1; i < len; ++i) {
rev[i] = (rev[i >> 1] >> 1) + (i & 1) * (len >> 1);
if (i < rev[i]) swap(y[i], y[rev[i]]);
}
}
void fft(cd y[], int len, int on) {
change(y, len);
for (int h = 2; h <= len; h <<= 1) {
cd wn(cos(on * 2 * pi / h), sin(on * 2 * pi / h));
for (int j = 0; j < len; j += h) {
cd w(1, 0);
for (int k = j; k < j + h / 2; ++k) {
cd u = y[k];
cd t = w * y[k + h / 2];
y[k] = u + t;
y[k + h / 2] = u - t;
w = w * wn;
}
}
}
if (on == -1)
for (int i = 0; i < len; ++i) y[i].r /= len;
}
char s[600500], t[600500], st[600500];
int ls, lt;
int num[35][600500];
int id;
int lx[600500], rx[600500];
int main() {
int n = (1 << 19);
scanf("%s%s", s, t);
ls = strlen(s);
lt = strlen(t);
for (int i = 0; i < lt; ++i) st[i] = t[i];
reverse(t, t + lt);
for (int i = 0; i < lt; ++i) b[i] = cd((t[i] == '1' ? 1 : -1), 0);
fft(b, n, 1);
for (int i = 0; i + 6000 < ls; i += 6000) {
int en = i + 5999;
lx[id] = i;
rx[id] = en;
for (int j = 0; j < n; ++j) a[j] = cd(0, 0);
for (int j = i; j <= en; ++j) a[j] = cd((s[j] == '1' ? 1 : -1), 0);
fft(a, n, 1);
for (int j = 0; j < n; ++j) a[j] = a[j] * b[j];
fft(a, n, -1);
for (int j = 0; j < n; ++j) num[id][j] = (int)floor(a[j].r + 0.5);
id++;
}
lx[id] = rx[id - 1] + 1;
rx[id] = ls - 1;
id++;
int q;
scanf("%d", &q);
while (q--) {
int p1, p2, len;
scanf("%d%d%d", &p1, &p2, &len);
int L = p1 / 6000, R = (p1 + len - 1) / 6000;
int ans = 0;
for (int i = L + 1; i < R; ++i)
ans += (6000 - num[i][lt - 1 + p1 - p2]) / 2;
if (L != R) {
for (int i = p1; i <= rx[L]; ++i) ans += (s[i] != st[p2 + i - p1]);
for (int i = lx[R]; i <= p1 + len - 1; ++i)
ans += (s[i] != st[p2 + i - p1]);
} else
for (int i = 0; i < len; ++i) ans += (s[p1 + i] != st[p2 + i]);
printf("%d\n", ans);
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int Read() {
char c;
while (c = getchar(), (c != '-') && (c < '0' || c > '9'))
;
bool neg = (c == '-');
int ret = (neg ? 0 : c - 48);
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + c - 48;
return neg ? -ret : ret;
}
const int MAXN = 200005;
struct node {
int mi, ma, fi, fa;
} ret, t1[1 << 19], t2[1 << 19];
vector<int> stage[MAXN << 1];
set<int> s1[MAXN], s2[MAXN];
int top, ti, stk[MAXN], cur[MAXN], bg1[MAXN], en1[MAXN], bg2[MAXN], en2[MAXN],
seq1[MAXN], seq2[MAXN];
int N, cnt, st1[MAXN], st2[MAXN], nxt[MAXN * 4], lnk[MAXN * 4], a[MAXN],
b[MAXN];
void init() {
scanf("%d", &N);
for (int i = 2; i <= N; i++) {
int x = Read();
a[i] = x;
lnk[++cnt] = i, nxt[cnt] = st1[x], st1[x] = cnt;
lnk[++cnt] = x, nxt[cnt] = st1[i], st1[i] = cnt;
}
for (int i = 2; i <= N; i++) {
int x = Read();
b[i] = x;
lnk[++cnt] = i, nxt[cnt] = st2[x], st2[x] = cnt;
lnk[++cnt] = x, nxt[cnt] = st2[i], st2[i] = cnt;
}
}
void Traverse(int *bg, int *en, int *seq) {
top = ti = stk[1] = bg[1] = seq[1] = 1;
while (top) {
int x = stk[top];
bool find = 0;
for (int i = cur[x], y = lnk[i]; i; i = nxt[i], y = lnk[i])
if (!bg[y]) {
bg[y] = ++ti, seq[ti] = stk[++top] = y;
find = 1, cur[x] = nxt[i];
break;
}
if (!find) en[x] = ti, --top;
}
}
void Update(node &t, node tp) {
if (tp.mi < t.mi) t.mi = tp.mi, t.fi = tp.fi;
if (tp.ma > t.ma) t.ma = tp.ma, t.fa = tp.fa;
}
void iniTree(node *t, set<int> *s, int *seq, int id, int l, int r) {
if (l == r) {
int x = seq[l];
t[id].fi = t[id].fa = x;
if (s[x].size()) {
t[id].mi = *s[x].begin();
set<int>::iterator tmp = s[x].end();
tmp--;
t[id].ma = *tmp;
} else
t[id].mi = N + 1, t[id].ma = 0;
return;
}
int mid = (l + r) >> 1;
iniTree(t, s, seq, id + id, l, mid),
iniTree(t, s, seq, id + id + 1, mid + 1, r);
t[id] = t[id + id], Update(t[id], t[id + id + 1]);
}
void Remove(node *t, set<int> *s, int *seq, int id, int l, int r, int z,
int v) {
if (l == r) {
int x = seq[l];
s[x].erase(v);
if (s[x].size()) {
t[id].mi = *s[x].begin();
set<int>::iterator tmp = s[x].end();
tmp--;
t[id].ma = *tmp;
} else
t[id].mi = N + 1, t[id].ma = 0;
return;
}
int mid = (l + r) >> 1;
if (z <= mid)
Remove(t, s, seq, id + id, l, mid, z, v);
else
Remove(t, s, seq, id + id + 1, mid + 1, r, z, v);
t[id] = t[id + id], Update(t[id], t[id + id + 1]);
}
void Query(node *t, int id, int l, int r, int gl, int gr) {
if (gl <= l && r <= gr) {
Update(ret, t[id]);
return;
}
int mid = (l + r) >> 1;
if (gl <= mid) Query(t, id + id, l, mid, gl, gr);
if (gr > mid) Query(t, id + id + 1, mid + 1, r, gl, gr);
}
void Search(int cb, int *bg, int *en, int *bd, int *seq, node *t, set<int> *s,
int x, int y) {
if (bg[x] < bg[y]) swap(x, y);
for (;;) {
ret.mi = N + 1, ret.ma = 0;
Query(t, 1, 1, N, bg[x], en[x]);
bool cont = 0;
if (ret.mi < bg[x]) {
int dx = seq[ret.mi], dy = ret.fi;
if (bd[dy] == dx) swap(dx, dy);
stage[cb + 1].push_back(dx - 1), cont = 1;
Remove(t, s, seq, 1, 1, N, bg[dx], bg[dy]);
Remove(t, s, seq, 1, 1, N, bg[dy], bg[dx]);
}
if (ret.ma > en[x]) {
int dx = seq[ret.ma], dy = ret.fa;
if (bd[dy] == dx) swap(dx, dy);
stage[cb + 1].push_back(dx - 1), cont = 1;
Remove(t, s, seq, 1, 1, N, bg[dx], bg[dy]);
Remove(t, s, seq, 1, 1, N, bg[dy], bg[dx]);
}
if (!cont) return;
}
}
void work() {
memcpy(cur, st1, sizeof(cur)), Traverse(bg1, en1, seq1);
memcpy(cur, st2, sizeof(cur)), Traverse(bg2, en2, seq2);
for (int i = 2; i <= N; i++) {
int x = i, y = a[i];
s2[x].insert(bg2[y]);
s2[y].insert(bg2[x]);
}
for (int i = 2; i <= N; i++) {
int x = i, y = b[i];
s1[x].insert(bg1[y]);
s1[y].insert(bg1[x]);
}
iniTree(t1, s1, seq1, 1, 1, N);
iniTree(t2, s2, seq2, 1, 1, N);
int fir = Read();
stage[1].push_back(fir);
int tx = fir + 1, ty = a[fir + 1];
Remove(t2, s2, seq2, 1, 1, N, bg2[tx], bg2[ty]);
Remove(t2, s2, seq2, 1, 1, N, bg2[ty], bg2[tx]);
for (int cb = 1; cb <= N + N; cb++) {
if (!stage[cb].size()) return;
sort(stage[cb].begin(), stage[cb].end());
puts(cb & 1 ? "Blue" : "Red");
for (int i = 0; i <= stage[cb].size() - 1; i++) {
printf("%d%c", stage[cb][i], i + 1 < stage[cb].size() ? ' ' : '\n');
if (cb & 1)
Search(cb, bg1, en1, b, seq1, t1, s1, stage[cb][i] + 1,
a[stage[cb][i] + 1]);
else
Search(cb, bg2, en2, a, seq2, t2, s2, stage[cb][i] + 1,
b[stage[cb][i] + 1]);
}
}
}
int main() {
init();
work();
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N];
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int e = 0, ans = 0;
for (int i = 0; i < n; i++) {
int diff = a[i + 1] - a[i];
if (a[i] < a[i + 1]) {
if (e > diff) {
e -= diff;
} else if (e == diff) {
e = 0;
} else {
ans += (diff - e);
e = 0;
}
} else {
e += (a[i] - a[i + 1]);
}
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int ans[t];
for (int z = 0; z < t; z++) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int count = 0, mn = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
if (a[i] > mn) count++;
mn = min(mn, a[i]);
}
ans[z] = count;
}
for (int i = 0; i < t; i++) cout << ans[i] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
string s;
cin >> s;
int n = (int)s.length();
const int NMX = 1 << 20;
vector<int> dp(NMX, 0);
for (int i = 0; i < n; i++) {
int cur = 0;
for (int j = i; j < min(n, i + 20); j++) {
int c = int(s[j] - 'a');
if (cur & (1 << c)) break;
cur |= 1 << c;
dp[cur] = __builtin_popcount(cur);
}
}
for (int i = 0; i < NMX; i++) {
for (int j = 0; j < 20; j++) {
if (i & (1 << j)) dp[i] = max(dp[i], dp[i ^ (1 << j)]);
}
}
int ans = 0;
for (int i = 0; i < NMX; i++) {
int comp = ~i & (NMX - 1);
ans = max(ans, dp[i] + dp[comp]);
}
cout << ans;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<string> dict;
vector<bool> u;
string start, ans;
char letter = '#';
void z_fun(string &s1, string &s2) {
vector<int> z;
string s = s1 + '#' + s2;
int len = s.length();
z.resize(len);
z[0] = 0;
int l = 0, r = 0;
for (int i = 1; i < len; i++)
if (i > r) {
int j;
for (j = 0; i + j < len && toupper(s[i + j]) == toupper(s[j]); j++)
;
z[i] = j;
if (z[i] == s1.length()) {
for (int k = i; k < s1.length() + i; k++) {
u[k - s1.length() - 1] = true;
}
}
l = i;
r = i + j - 1;
} else if (z[i - l] < r - i + 1) {
z[i] = z[i - l];
if (z[i] == s1.length()) {
for (int k = i; k < s1.length() + i; k++) {
u[k - s1.length() - 1] = true;
}
}
} else {
int j;
for (j = 1; r + j < len && toupper(s[r + j]) == toupper(s[r - i + j]);
j++)
;
z[i] = r - i + j;
if (z[i] == s1.length()) {
for (int k = i; k < s1.length() + i; k++) {
u[k - s1.length() - 1] = true;
}
}
l = i;
r = r + j - 1;
}
}
char toSameReg(char ex, char l) {
if (ex >= 'A' && ex <= 'Z') {
return toupper(l);
} else {
return tolower(l);
}
}
int main() {
cin >> n;
dict.resize(n);
for (int i = 0; i < n; i++) {
cin >> dict[i];
}
cin >> start;
cin >> letter;
u.assign(start.length(), false);
ans = start;
for (int i = 0; i < n; i++) {
z_fun(dict[i], start);
}
for (int i = 0; i < u.size(); i++) {
if (u[i]) {
if (toupper(start[i]) != toupper(letter)) {
ans[i] = toSameReg(ans[i], letter);
continue;
}
if (toupper(letter) == 'A') {
ans[i] = toSameReg(ans[i], 'B');
} else {
ans[i] = toSameReg(ans[i], 'A');
}
}
}
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e+5;
const long long mod = 1e9 + 7;
int a[maxn], n, m;
struct Mat {
long long v[2][2];
Mat() { memset(v, 0, sizeof(v)); }
friend Mat operator*(Mat g, Mat b) {
Mat c;
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++)
c.v[i][j] = (c.v[i][j] + g.v[i][k] * b.v[k][j]) % mod;
return c;
}
friend Mat operator+(Mat g, Mat b) {
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 1; j++) g.v[i][j] = (g.v[i][j] + b.v[i][j]) % mod;
return g;
}
friend Mat operator^(Mat g, int b) {
Mat ans;
ans.v[0][0] = ans.v[1][1] = 1LL;
for (; b; b = b >> 1, g = g * g)
if (b & 1) ans = ans * g;
return ans;
}
} T, F, M[maxn], laz[maxn];
inline void build(int rt, int l, int r) {
laz[rt] = F;
M[rt].v[0][1] = 1LL;
if (l == r) {
M[rt] = M[rt] * (T ^ a[l]);
return;
}
build(rt << 1, l, ((l + r) >> 1)), build(rt << 1 | 1, ((l + r) >> 1) + 1, r);
M[rt] = M[rt << 1] + M[rt << 1 | 1];
}
inline void pushdown(int rt, int l, int r) {
if (l == r) return;
laz[rt << 1] = laz[rt << 1] * laz[rt],
laz[rt << 1 | 1] = laz[rt << 1 | 1] * laz[rt];
M[rt << 1] = M[rt << 1] * laz[rt];
M[rt << 1 | 1] = M[rt << 1 | 1] * laz[rt];
laz[rt] = F;
}
inline void add(int rt, int l, int r, int xl, int xr, Mat x) {
pushdown(rt, l, r);
if (l == xl && r == xr) {
M[rt] = M[rt] * x;
laz[rt] = laz[rt] * x;
return;
}
if (xr <= ((l + r) >> 1))
add(rt << 1, l, ((l + r) >> 1), xl, xr, x);
else if (xl > ((l + r) >> 1))
add(rt << 1 | 1, ((l + r) >> 1) + 1, r, xl, xr, x);
else
add(rt << 1, l, ((l + r) >> 1), xl, ((l + r) >> 1), x),
add(rt << 1 | 1, ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1, xr, x);
M[rt] = M[rt << 1] + M[rt << 1 | 1];
}
inline long long query(int rt, int l, int r, int xl, int xr) {
pushdown(rt, l, r);
if (l == xl && r == xr) return M[rt].v[0][0];
if (xr <= ((l + r) >> 1))
return query(rt << 1, l, ((l + r) >> 1), xl, xr);
else if (xl > ((l + r) >> 1))
return query(rt << 1 | 1, ((l + r) >> 1) + 1, r, xl, xr);
else
return (query(rt << 1, l, ((l + r) >> 1), xl, ((l + r) >> 1)) +
query(rt << 1 | 1, ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1, xr)) %
mod;
}
int main() {
scanf("%d%d", &n, &m);
T.v[0][1] = T.v[1][0] = T.v[1][1] = 1LL;
F.v[0][0] = F.v[1][1] = 1LL;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
while (m--) {
int opt, l, r, x;
scanf("%d%d%d", &opt, &l, &r);
if (opt == 1)
scanf("%d", &x), add(1, 1, n, l, r, (T ^ x));
else
printf("%I64d\n", query(1, 1, n, l, r));
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
#define ios ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define ll long long
#define inf INT_MAX
#define llinf LLONG_MAX
#define mod 1000000007
#define mxn 1000000001
ll q,x,y,br;
int main()
{
ios;
cin >> q;
while ( q-- )
{
cin >> y >> x;
br = 0;
for ( ll k = 1; k <= mxn; k++ )
{
if ( min( x-(k+1)+1, (y-k)/k-(k+1)+1 ) <= 0 ) /// x-(k+1)+1 <==> x-k, (y-k)/k-(k+1)+1 <==> y/k-(k+1)
{
break;
}
br += min( x-(k+1)+1, (y-k)/k-(k+1)+1 ); /// x-(k+1)+1 <==> x-k, (y-k)/k-(k+1)+1 <==> y/k-(k+1)
}
cout << br << "\n";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, pos = 0;
cin >> n;
char ch[n];
cin >> ch;
long long int aa[n];
for (i = 0; i < n; i++) scanf("%I64d", &aa[i]);
map<int, int> mp;
mp[0] = 1;
while (1) {
if (ch[pos] == '>')
pos += aa[pos];
else
pos -= aa[pos];
mp[pos]++;
if (pos < 0 || pos >= n) {
cout << "FINITE";
return 0;
}
if (mp[pos] == 2) {
cout << "INFINITE";
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return (1);
long long int sol = power(a, b / 2, m);
sol = (sol * sol) % m;
if (b % 2 == 1) sol = (sol * a) % m;
return sol;
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else {
return gcd(b, a % b);
}
}
long long int a[100005], p[100005];
void solve() {
string s;
cin >> s;
int n = s.length();
long long int sol = 0;
long long int sum = 0;
int t = n - 2;
for (int i = 0; i < n - 1; i++) {
sum = sum + s[i] - '0';
sol = (sol + (sum * a[t]) % 1000000007) % 1000000007;
t--;
}
long long int exp = 0;
for (int i = n - 1; i >= 1; i--) {
long long int x = (long long int)(s[i] - '0');
long long int t = (long long int)i;
long long int cnt = t * (t + 1) / 2;
cnt = cnt % 1000000007;
x = (x * p[exp]) % 1000000007;
sol = sol + (cnt * x) % 1000000007;
sol = sol % 1000000007;
exp++;
}
cout << sol;
}
int main() {
int t = 1;
long long int temp = 1;
a[0] = 1;
for (int i = 1; i <= 100002; i++) {
temp = (temp * 10) % 1000000007;
long long int tt = (long long int)i;
tt++;
long long int x;
x = temp * tt;
x = x % 1000000007;
a[i] = x;
}
p[0] = 1;
for (int i = 1; i <= 100000; i++) {
p[i] = (p[i - 1] * 10) % 1000000007;
}
while (t--) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int i, n, m, ans, b[200005], x, y;
map<int, int> mp;
map<int, int>::iterator it;
vector<int> v[200005];
void dfs(int x) {
b[x] = 1;
mp[x] = 1;
for (int i = 0; i < v[x].size(); i++)
if (!b[v[x][i]]) dfs(v[x][i]);
}
int main() {
ios::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (i = 1; i <= n; i++) {
if (b[i]) continue;
dfs(i);
it = mp.find(i);
for (it; it != --mp.end(); it++)
if (!b[(*it).first + 1]) {
ans++;
dfs((*it).first + 1);
}
it = mp.end()--;
i = (*it).first;
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int MAXN = 1e6 + 10;
const long long MOD = 1e9 + 7;
const long long MOD2 = 998244353;
const long long INF = 8e18;
const int LOG = 22;
long long pw(long long a, long long b, long long mod) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % mod, b / 2, mod)) % mod
: pw(a * a % mod, b / 2, mod)));
}
vector<pair<int, int> > G[MAXN];
vector<int> adj[MAXN];
int H[MAXN], U[MAXN], king[MAXN], cnt[MAXN], ptr = 1;
bool is_cut[MAXN], mark[MAXN], vis[MAXN];
int H2[MAXN], par[LOG][MAXN], cost[LOG][MAXN];
void pre(int v, int lastid = 0) {
U[v] = H[v];
mark[v] = 1;
for (auto y : G[v]) {
int u = y.first, id = y.second;
if (id == lastid) continue;
if (!mark[u]) {
H[u] = H[v] + 1;
pre(u, id);
if (U[u] > H[v]) {
is_cut[id] = 1;
}
U[v] = min(U[v], U[u]);
} else {
U[v] = min(U[v], H[u]);
}
}
}
void DFS(int v) {
vis[v] = 1;
cnt[king[v]]++;
for (auto y : G[v]) {
int u = y.first, id = y.second;
if (vis[u]) continue;
if (is_cut[id]) {
king[u] = ++ptr;
} else {
king[u] = king[v];
}
DFS(u);
}
}
void dfs(int v, int P) {
H2[v] = H2[P] + 1;
par[0][v] = P;
cost[0][v] = (cnt[v] > 1);
for (int T = 1; T < LOG; T++) {
par[T][v] = par[T - 1][par[T - 1][v]];
cost[T][v] = cost[T - 1][v] + cost[T - 1][par[T - 1][v]];
}
for (auto u : adj[v]) {
if (u == P) continue;
dfs(u, v);
}
}
int LCA(int v, int u) {
v = king[v], u = king[u];
if (H2[v] > H2[u]) {
swap(u, v);
}
int del = H2[u] - H2[v], res = 0;
for (int T = LOG - 1; ~T; T--) {
if (del & (1 << T)) {
res += cost[T][u];
u = par[T][u];
}
}
if (v == u) {
return res + (cnt[v] > 1);
}
for (int T = LOG - 1; ~T; T--) {
if (par[T][u] != par[T][v]) {
res += cost[T][v] + cost[T][u];
v = par[T][v], u = par[T][u];
}
}
res += cost[0][v] + cost[0][u];
v = par[0][v];
res += cost[0][v];
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(make_pair(b, i));
G[b].push_back(make_pair(a, i));
}
pre(1);
king[1] = 1;
DFS(1);
for (int v = 1; v <= n; v++) {
for (auto y : G[v]) {
int u = y.first;
if (king[v] != king[u]) {
adj[king[v]].push_back(king[u]);
}
}
}
dfs(1, 0);
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
int cu = LCA(a, b);
cout << pw(2, cu, MOD) << "\n";
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m;
cin >> n >> m;
vector<long long> arr(m);
for (long long i = 0; i < m; i++) cin >> arr[i];
sort(arr.begin(), arr.end());
long long ans = LLONG_MAX;
for (long long i = 0; i <= m - n; i++) {
ans = min(ans, arr[i + n - 1] - arr[i]);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int SQRT_N = 32000;
const long long LINF = (long long)4e18;
int n;
long long k;
long long seq[N];
long long max_d;
long long events[SQRT_N * N];
int esz;
long long sum_x;
void process(int l, int r) {
sum_x -= r - l;
long long left_d = events[l];
long long right_d = r == esz ? LINF : events[r];
long long max_poss_d = min(right_d - 1, k / sum_x);
if (left_d <= max_poss_d) max_d = max(max_d, max_poss_d);
}
void solve() {
scanf("%d%lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &seq[i]);
k += seq[i];
}
for (long long d = 1; d <= SQRT_N; d++) {
long long sum = 0;
for (int i = 0; i < n; i++) sum += (seq[i] + d - 1) / d;
if (sum * d <= k) max_d = max(max_d, d);
}
for (int i = 0; i < n; i++) {
int old_esz = esz;
for (long long x = SQRT_N; x >= 1; x--)
events[esz++] = (seq[i] + x - 1) / x;
inplace_merge(events, events + old_esz, events + esz);
}
sum_x = (long long)(SQRT_N + 1) * n;
int j = 0;
for (int i = 1; i <= esz; i++)
if (i == esz || events[j] != events[i]) {
process(j, i);
j = i;
}
printf("%lld\n", max_d);
}
int main() {
solve();
(void)0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * w;
}
int n, Q, b;
int a[N];
vector<int> adj[N];
void init() {
b = sqrt(n);
for (int i = 1; i <= n; i++) {
a[i] = i;
adj[i / b].push_back(i);
}
}
long long work(int l, int r) {
if (l == r) return 0;
int idx, idy, x, y, k;
x = a[l];
y = a[r];
idx = l / b;
k = find(adj[idx].begin(), adj[idx].end(), x) - adj[idx].begin();
adj[idx][k] = y;
sort(adj[idx].begin(), adj[idx].end());
idy = r / b;
k = find(adj[idy].begin(), adj[idy].end(), y) - adj[idy].begin();
adj[idy][k] = x;
sort(adj[idy].begin(), adj[idy].end());
int ans = 0, f;
if (x > y)
f = -1, swap(x, y);
else
f = 1;
if (idx == idy) {
for (int i = l + 1; i <= r - 1; i++)
if (x < a[i] && a[i] < y) ans++;
} else {
for (int i = l + 1; i < (idx + 1) * b; i++)
if (x < a[i] && a[i] < y) ans++;
for (int id = idx + 1; id < idy; id++)
ans += upper_bound(adj[id].begin(), adj[id].end(), y) -
lower_bound(adj[id].begin(), adj[id].end(), x);
for (int i = idy * b; i < r; i++)
if (x < a[i] && a[i] < y) ans++;
}
swap(a[l], a[r]);
return f * (2 * ans + 1);
}
long long ans = 0;
int main() {
n = read();
Q = read();
init();
int l, r;
while (Q--) {
l = read();
r = read();
if (l > r) swap(l, r);
ans += work(l, r);
printf("%lld\n", ans);
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, c, i, j;
cin >> n >> m >> c;
long long int a[n], b[m];
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < m; i++) cin >> b[i];
for (i = 0; i < n - m + 1; i++) {
for (j = 0; j < m; j++) {
a[i + j] = a[i + j] + b[j];
a[i + j] = a[i + j] % c;
}
}
for (i = 0; i < n; i++) cout << a[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
char s[N][N];
int ans, l[N], n, r;
int main() {
while (gets(s[n])) {
l[n] = strlen(s[n]);
if (l[n] > ans) ans = l[n];
n++;
}
for (int i = 0; i < ans + 2; i++) printf("*");
puts("");
for (int i = 0; i < n; i++) {
printf("*");
int c = (ans - l[i]) / 2;
if ((ans - l[i]) & 1) c += r, r ^= 1;
for (int j = 0; j < c; j++) printf(" ");
printf("%s", s[i]);
for (int j = 0; j < ans - l[i] - c; j++) printf(" ");
puts("*");
}
for (int i = 0; i < ans + 2; i++) printf("*");
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const static long long inf = (long long)1e18;
const static int mod = 1000000007;
int n, u, r;
int a[31], b[31], k[31], p[31];
inline long long calc(int* aa) {
long long ans = 0;
for (int i = 0; i < (int)(n); i++) {
ans += (long long)(aa[i]) * k[i];
}
return ans;
}
long long go(int pos, bool dup, int* now) {
if (pos == u) {
return calc(now);
}
long long ret = -inf;
if ((u - pos) % 2 == 0) {
ret = calc(now);
}
int next[31] = {};
for (int i = 0; i < (int)(n); i++) {
next[i] = now[p[i]] + r;
}
for (int i = 0; i < (int)(n); i++) {
now[i] = now[i] ^ b[i];
}
if ((u - pos) % 2 == 1) {
ret = calc(now);
}
ret = max(ret, go(pos + 1, true, next));
if (dup) {
ret = max(ret, go(pos + 1, false, now));
}
return ret;
}
int main() {
while (cin >> n >> u >> r) {
int now[31] = {};
for (int i = 0; i < (int)(n); i++) {
cin >> a[i];
now[i] = a[i];
}
for (int i = 0; i < (int)(n); i++) {
cin >> b[i];
}
for (int i = 0; i < (int)(n); i++) {
cin >> k[i];
}
for (int i = 0; i < (int)(n); i++) {
cin >> p[i];
--p[i];
}
cout << go(0, true, now) << endl;
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int ans;
long long n, k, d1, d2, a, b, c;
void gettin(long long x, long long y) {
if (n % 3) return;
long long aa, bb, cc;
if ((k - x - y) < 0) return;
if ((k - x - y) % 3) return;
aa = (k - x - y) / 3;
bb = aa + x;
cc = aa + y;
if (aa > n / 3) return;
if (aa < 0) return;
if (bb > n / 3) return;
if (cc > n / 3) return;
if (bb < 0) return;
if (cc < 0) return;
ans = 1;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
ans = 0;
scanf("%I64d%I64d%I64d%I64d", &n, &k, &d1, &d2);
gettin(d1, d1 + d2);
gettin(d1, d1 - d2);
gettin(-d1, -d1 + d2);
gettin(-d1, -d1 - d2);
if (ans)
puts("yes");
else
puts("no");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100], ans;
int find(int x) {
while (x > 0) {
if (a[x % 10]) return true;
x /= 10;
}
return false;
}
int main() {
scanf("%d", &n);
memset(a, 0, sizeof(a));
int tp = n;
while (tp > 0) {
a[tp % 10] = true;
tp /= 10;
}
ans = 0;
for (int i = 1; i * i <= n; i++)
if (n % i == 0) {
int tp = i;
if (find(tp)) ans++;
if (i != n / i && find(n / i)) ans++;
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char m[1001][1001];
int di[1001][1001], dx[5] = {0, 0, 0, 1, -1}, dy[5] = {0, 1, -1, 0, 0}, n, b, d,
x, y, ans;
int main() {
cin >> n >> b;
memset(di, -1, sizeof(di));
queue<pair<int, int> > q;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= b; ++j) {
cin >> m[i][j];
if (m[i][j] == 'E') {
q.push(make_pair(i, j));
di[i][j] = 0;
}
}
}
while (!q.empty()) {
pair<int, int> f = q.front();
q.pop();
for (int i = 1; i <= 4; ++i) {
x = f.first + dx[i];
y = f.second + dy[i];
if (di[x][y] == -1 && x > 0 && x <= n && y > 0 && y <= b &&
m[x][y] != 'T') {
di[x][y] = di[f.first][f.second] + 1;
if (m[x][y] == 'S') d = di[x][y];
q.push(make_pair(x, y));
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= b; ++j) {
if (di[i][j] != -1 && di[i][j] <= d && m[i][j] >= '0' && m[i][j] <= '9')
ans += m[i][j] - '0';
}
}
cout << ans << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
struct Pair {
int a, b;
};
struct dsu {
vector<int> par;
dsu(int n = 0) {
par.resize(n);
for (int i = 0; i < n; ++i) par[i] = i;
}
int get(int x) { return (x == par[x] ? x : par[x] = get(par[x])); }
void unite(int x, int y) {
x = get(x), y = get(y);
par[y] = x;
}
};
int n, m, q, Bucket_sz;
int q_ans[1 + N];
vector<Pair> E[1 + N];
Pair query[1 + N];
map<pair<int, int>, vector<int>> pos_q;
void read() {
scanf("%d%d", &n, &m);
Bucket_sz = sqrt(m);
for (int i = 1; i <= m; ++i) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
E[c].push_back(Pair{a, b});
}
scanf("%d", &q);
for (int i = 1; i <= q; ++i) {
scanf("%d%d", &query[i].a, &query[i].b);
if (query[i].a > query[i].b) swap(query[i].a, query[i].b);
pos_q[make_pair(query[i].a, query[i].b)].push_back(i);
}
}
void solve_big() {
dsu forest(n + 1);
for (int i = 1; i <= m; ++i) {
if ((int)E[i].size() >= Bucket_sz) {
forest = dsu(n + 1);
for (auto edges : E[i]) forest.unite(edges.a, edges.b);
for (int j = 1; j <= q; ++j)
if (forest.get(query[j].a) == forest.get(query[j].b)) q_ans[j]++;
}
}
}
void solve_small() {
dsu forest(n + 1);
for (int c = 1; c <= m; ++c) {
if ((int)E[c].size() < Bucket_sz && !E[c].empty()) {
for (auto edges : E[c]) forest.unite(edges.a, edges.b);
vector<int> nodes;
for (auto edges : E[c])
nodes.push_back(edges.a), nodes.push_back(edges.b);
sort(nodes.begin(), nodes.end());
nodes.resize(unique(nodes.begin(), nodes.end()) - nodes.begin());
for (int i = 0; i < (int)nodes.size(); ++i)
for (int j = i + 1; j < (int)nodes.size(); ++j)
if (forest.get(nodes[i]) == forest.get(nodes[j]))
if (pos_q.find(make_pair(nodes[i], nodes[j])) != end(pos_q))
for (auto pozitii : pos_q[make_pair(nodes[i], nodes[j])])
q_ans[pozitii]++;
for (auto nod : nodes) forest.par[nod] = nod;
}
}
}
void solve() {
solve_big();
solve_small();
for (int i = 1; i <= q; ++i) printf("%d\n", q_ans[i]);
}
int main() {
read();
solve();
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAX_COUNT = 2e3 + 1;
const int MOD = 1e9 + 7;
int n;
int d;
vector<int> g[MAX_COUNT];
int val[MAX_COUNT];
long long ans;
long long dfs(int u, int p, int root) {
if (val[u] < val[root]) return 0;
if (val[u] > val[root] + d) return 0;
if (val[u] == val[root] && u < root) return 0;
long long res = 1;
for (int v : g[u]) {
if (v == p) continue;
res = (res * (dfs(v, u, root) + 1)) % MOD;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin >> d >> n;
for (int i = 1; i < (n + 1); ++i) {
cin >> val[i];
}
for (int i = 0; i < (n - 1); ++i) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 1; i < (n + 1); ++i) {
ans = (ans + dfs(i, -1, i)) % MOD;
;
}
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const int mod = 1e9 + 7;
int n, sz[N], son[N], top[N], id[N], ty[N], f[N], o[N], val[N], tot;
vector<int> g[N];
void dfs_1(int u, int fa) {
sz[u]++;
f[u] = fa;
pair<int, int> mx = make_pair(0, 0);
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
if (v != fa) {
dfs_1(v, u);
sz[u] += sz[v];
mx = max(mx, make_pair(sz[v], v));
}
}
son[u] = mx.second;
}
void dfs_2(int u, int fa) {
id[u] = ++tot;
if (son[u]) {
top[son[u]] = top[u];
dfs_2(son[u], u);
}
for (int i = 0; i < (int)g[u].size(); i++) {
int v = g[u][i];
if (v != son[u] && v != fa) {
top[v] = v;
dfs_2(v, u);
}
}
}
struct node {
int sum, mul;
bool lazy;
} t[N << 2];
void push_down(int u) {
if (t[u].lazy) {
t[u << 1].sum =
(t[u << 1].sum + 1LL * t[u].sum * t[u << 1 | 1].mul % mod) % mod;
t[u << 1 | 1].sum = (t[u << 1 | 1].sum + t[u].sum) % mod;
t[u << 1].lazy = t[u << 1 | 1].lazy = 1;
t[u].sum = 0;
t[u].lazy = 0;
}
}
int update_sum(int u, int l, int r, int L, int R, int v) {
if (l == L && r == R) {
t[u].sum = (t[u].sum + v) % mod;
t[u].lazy = 1;
return t[u].mul;
}
push_down(u);
int mid = (l + r) / 2;
if (R <= mid)
return update_sum(u << 1, l, mid, L, R, v);
else if (L > mid)
return update_sum(u << 1 | 1, mid + 1, r, L, R, v);
else {
int res = update_sum(u << 1 | 1, mid + 1, r, mid + 1, R, v);
res = 1LL * res * update_sum(u << 1, l, mid, L, mid, 1LL * v * res % mod) %
mod;
return res;
}
}
void update_mul(int u, int l, int r, int x) {
if (l == r) {
t[u].mul++;
return;
}
push_down(u);
int mid = (l + r) / 2;
if (x <= mid)
update_mul(u << 1, l, mid, x);
else
update_mul(u << 1 | 1, mid + 1, r, x);
t[u].mul = 1LL * t[u << 1].mul * t[u << 1 | 1].mul % mod;
}
pair<int, int> query(int u, int l, int r, int x) {
if (l == r) return make_pair(t[u].mul, t[u].sum);
push_down(u);
int mid = (l + r) / 2;
if (x <= mid)
return query(u << 1, l, mid, x);
else
return query(u << 1 | 1, mid + 1, r, x);
}
int main() {
int V, q;
scanf("%d%d", &V, &q);
int cnt = 1;
for (int i = 1; i <= q; i++) {
scanf("%d", &ty[i]);
if (ty[i] == 1) {
scanf("%d%d", &o[i], &val[i]);
cnt++;
g[o[i]].push_back(cnt);
g[cnt].push_back(o[i]);
} else
scanf("%d", &o[i]);
}
top[1] = 1;
dfs_1(1, 0);
dfs_2(1, 0);
update_sum(1, 1, tot, id[1], id[1], V);
update_mul(1, 1, tot, id[1]);
cnt = 1;
for (int i = 1; i <= q; i++) {
if (ty[i] == 1) {
cnt++;
update_sum(1, 1, tot, id[cnt], id[cnt], val[i]);
update_mul(1, 1, tot, id[cnt]);
pair<int, int> res = query(1, 1, tot, id[o[i]]);
int ad = (res.second + 1LL * (res.first + 1) * val[i] % mod) % mod;
update_sum(1, 1, tot, id[o[i]], id[o[i]], val[i]);
update_mul(1, 1, tot, id[o[i]]);
int x = f[o[i]];
while (x) {
int y = top[x];
int res = update_sum(1, 1, tot, id[y], id[x], ad);
ad = 1LL * res * ad % mod;
x = f[y];
}
} else {
pair<int, int> res = query(1, 1, tot, id[o[i]]);
printf("%d\n", 1LL * res.first * res.second % mod);
}
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int i, n, ans;
int f[10];
char ch;
int main() {
memset(f, 0, sizeof(f));
cin >> n;
for (i = 1; i <= n; i++) {
cin >> ch;
f[ch - 48]++;
}
ans = min(n / 11, f[8]);
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
class BinaryIndexedTree {
int N;
vector<int> tree;
public:
BinaryIndexedTree(int _N) : N(_N), tree(_N + 1) {}
int query(int idx) {
int res = 0;
for (int i = idx; i > 0; i -= (i & -i)) {
res += tree[i];
if (res >= MOD) res -= MOD;
}
return res;
}
int query(int L, int R) {
int res = L <= R ? query(R) - query(L - 1) : 0;
if (res < 0) res += MOD;
return res;
}
void update(int idx, int val = 1) {
for (int i = idx; i <= N; i += (i & -i)) {
tree[i] += val;
if (tree[i] >= MOD) tree[i] -= MOD;
}
}
};
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
vector<int> A(N);
for (int i = 0, _n = (N); i < _n; ++i) cin >> A[i];
map<int, int> POS;
for (int i = 0, _n = (N); i < _n; ++i) POS[A[i]] = i + 1;
vector<int> S(A);
sort(S.begin(), S.end());
BinaryIndexedTree left(N), right(N);
int res = 0;
for (int x : S) {
int i = POS[x];
left.update(i, i);
long long mult =
(left.query(i) * 1LL * (N - i + 1) + right.query(i + 1, N) * 1LL * i) %
MOD;
res = (res + x * mult) % MOD;
right.update(i, N - i + 1);
}
cout << res << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int chkmax(T &a, T b) {
if (b > a) {
a = b;
return 1;
}
return 0;
}
template <class T>
int chkmin(T &a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <class iterator>
void output(iterator begin, iterator end, ostream &out = cerr) {
while (begin != end) {
out << (*begin) << " ";
begin++;
}
out << endl;
}
template <class T>
void output(T x, ostream &out = cerr) {
output(x.begin(), x.end(), out);
}
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
vector<int> get_zero(int *a, int n) {
int lst = 0;
vector<int> res;
for (int i = 0; i <= n; ++i) {
if (i == n || a[i] == 1) {
if (lst) {
res.push_back(lst);
lst = 0;
}
}
if (i < n && a[i] == 0) {
lst++;
}
}
return res;
}
const long long MOD = 998244353;
const int mx = 3610;
int H, W, chips, used1[mx], used2[mx];
vector<int> v1, v2;
void read_and_parse() {
cin >> H >> W >> chips;
for (int i = 0; i < chips; ++i) {
int x1, Y1, x2, y2;
cin >> x1 >> Y1 >> x2 >> y2;
x1--;
Y1--;
x2--;
y2--;
used1[x1] = 1;
used1[x2] = 1;
used2[Y1] = 1;
used2[y2] = 1;
}
v1 = get_zero(used1, H);
v2 = get_zero(used2, W);
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
}
long long C[mx][mx];
void calc_C() {
for (int i = 0; i < mx; ++i) {
for (int j = 0; j < mx; ++j) {
if (j == 0) {
C[i][j] = 1;
continue;
}
if (i == 0) {
C[i][j] = 0;
continue;
}
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
}
}
long long get_C(int n, int k) {
if (n < k) {
return 0;
}
return C[n][k];
}
long long dp[mx][mx];
void calc_dp() {
for (int i = 0; i < mx; ++i) {
for (int j = 0; j < mx; ++j) {
if (j == 0) {
dp[i][j] = 1;
continue;
}
if (i == 0) {
dp[i][j] = 0;
continue;
}
dp[i][j] = dp[i - 1][j];
if (i >= 2) {
dp[i][j] = (dp[i][j] + dp[i - 2][j - 1]) % MOD;
}
}
}
}
vector<long long> get_dp(vector<int> &a, int l, int r, int sum) {
if (l > r) {
return {1};
}
if (l == r) {
return vector<long long>(dp[a[l]], dp[a[l]] + a[l] / 2 + 1);
}
int lsum = 0;
for (int i = l; i < r; ++i) {
lsum += a[i];
if (2 * lsum >= sum || i == r - 1) {
vector<long long> res_l = get_dp(a, l, i, lsum);
vector<long long> res_r = get_dp(a, i + 1, r, sum - lsum);
vector<long long> res((int)res_l.size() + (int)res_r.size() - 1);
for (int x = 0; x < res_l.size(); ++x) {
for (int y = 0; y < res_r.size(); ++y) {
res[x + y] = (res[x + y] + res_l[x] * res_r[y]) % MOD;
}
}
return res;
}
}
assert(0);
}
long long fact[mx];
signed main() {
fast_io();
fact[0] = 1;
for (int i = 1; i < mx; ++i) {
fact[i] = (fact[i - 1] * (long long)i) % MOD;
}
read_and_parse();
calc_C();
calc_dp();
int n = 0, m = 0;
for (auto x : v1) {
n += x;
}
for (auto x : v2) {
m += x;
}
vector<long long> dp1 = get_dp(v1, 0, (int)v1.size() - 1, n);
vector<long long> dp2 = get_dp(v2, 0, (int)v2.size() - 1, m);
long long ans = 0;
for (int k1 = 0; k1 < dp1.size(); ++k1) {
for (int k2 = 0; k2 < dp2.size(); ++k2) {
long long cnt1 = (dp1[k1] * get_C(n - 2 * k1, k2)) % MOD;
long long cnt2 = (dp2[k2] * get_C(m - 2 * k2, k1)) % MOD;
long long F = (fact[k1] * fact[k2]) % MOD;
ans = (ans + cnt1 * cnt2 % MOD * F % MOD) % MOD;
}
}
cout << ans << endl;
}
| 18 |
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define mkp make_pair
#define si set < int >
#define vi vector < int >
#define pii pair < int, int >
#define mii map < int, int >
#define p_q priority_queue
#define INF ((1 << 30) - 1)
#define FI(n) FastIO::read(n)
#define FO(n) FastIO::write(n)
#define ull unsigned long long
#define mst(a, b) memset(a,b,sizeof(a))
#define foR(i, k, j) for(int i = (k); i >= (j); i--)
#define For(i, k, j) for(int i = (k); i <= (j); i++)
#define Foe(i, u) for(int i = lst[u], v = e[i].v; i; i = e[i].nxt, v = e[i].v)
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define Fin(s) freopen(s, "r", stdin)
#define Fout(s) freopen(s, "w", stdout)
#define file(s) Fin(s".in"), Fout(s".out")
//#define int long long
const int P = 1e9 + 7; //
using namespace std;
template <typename T> inline void ckmax(T &a, T b) {(a < b) && (a = b);}
template <typename T> inline void ckmin(T &a, T b) {(a > b) && (a = b);}
inline int mul(int a, int b) {return 1ll * a * b % P;}
inline int add(int a, int b) {return a + b >= P ? a + b - P : a + b;}
inline int sub(int a, int b) {return a - b >= 0 ? a - b : a - b + P;}
inline void mulmod(int &a, int b) {a = mul(a, b);}
inline void addmod(int &a, int b) {((a += b) >= P) && (a -= P);}
inline void submod(int &a, int b) {((a -= b) < 0) && (a += P);}
inline int ksm(int a, int b) {int ans=1; for(;b;b>>=1) {if(b&1) ans=1ll*ans*a%P;a=1ll*a*a%P;}return ans;}
inline int inv(int a) {return ksm(a, P-2);}
namespace FastIO {
const int SIZE=1<<16; char buf[SIZE], obuf[SIZE], str[64]; int bi=SIZE, bn=SIZE, opt;
int read(char *s) {
while (bn) {for (;bi<bn&&buf[bi]<=' ';bi++);if (bi<bn) break; bn=fread(buf,1,SIZE,stdin),bi=0;}
int sn=0;while (bn) {for (;bi<bn&&buf[bi]>' ';bi++) s[sn++]=buf[bi];if (bi<bn) break; bn=fread(buf,1,SIZE,stdin),bi=0;}s[sn]=0;return sn;
}
bool read(int& x) {if(x)x=0;int bf=0,n=read(str); if(!n) return 0; int i=0; if (str[i]=='-') bf=1,i=1; for(x=0;i<n;i++) x=x*10+str[i]-'0'; if(bf) x=-x; return 1;}
void write(int x) {
if(!x) obuf[opt++] = '0'; else {if(x<0) obuf[opt++]='-',x=-x;int sn=0; while(x)str[sn++]=x%10+'0',x/=10;for (int i=sn-1;i>=0;i--) obuf[opt++]=str[i];}
if (opt>=(SIZE>>1)){fwrite(obuf, 1, opt, stdout); opt=0;}
}
void write(char x) {obuf[opt++]=x;if (opt>=(SIZE>>1)){fwrite(obuf, 1, opt, stdout); opt=0;}}
void Fflush() { if (opt) fwrite(obuf, 1, opt, stdout); opt=0;}
};
inline int read() {int x; FI(x); return x;}
const int MAXN = 2e5 + 5;
vector < int > e[MAXN];
//namespace BAS {
int siz[MAXN], f[MAXN], dep[MAXN], id[MAXN], up[MAXN][5], ind, dfn[MAXN], top[MAXN], L[MAXN], R[MAXN];
void dfs1(int u, int fa) {
siz[u] = 1, dep[u] = dep[f[u] = fa] + 1;
for(auto v : e[u]) if(v != f[u]) dfs1(v, u), siz[u] += siz[v];
}
#define upd(i) up[u][i] = up[f[up[u][i-1]]][i-1]
void dfs2(int u, int fir) {
int hson = 0; top[u] = up[u][0] = fir, id[dfn[u] = ++ind] = u;
upd(1); upd(2); upd(3); upd(4);
for(auto v : e[u]) if(v != f[u] && siz[v] > siz[hson]) hson = v;
if(!hson) return; dfs2(hson, fir);
for(auto v : e[u]) if(v != f[u] && v != hson) dfs2(v, v);
}
#define jump(i) if(up[u][i] && k > dep[u] - dep[up[u][i]]) k -= dep[u] - dep[up[u][i]] + 1, u = f[up[u][i]];
inline int kth(int u, int k) {
jump(4); jump(3); jump(2); jump(1); jump(0);
return !u ? 1 : id[dfn[u] - k];
}
int lca(int u, int v) {
while(top[u] != top[v])
dep[top[u]] > dep[top[v]] ? u = f[top[u]] : v = f[top[v]];
return dep[u] < dep[v] ? u : v;
}
int dist(int i, int j) {
if(i == -1 || j == -1) return 0;
return dep[i] + dep[j] - 2 * dep[lca(i, j)];
}
#undef upd
#undef jump
//}
//#define lca(i, j) BAS::lca(i, j)
//#define dist(i, j) BAS::dist(i, j)
struct Chain {
int x, y, l;
Chain operator + (const Chain &b) const {
Chain ans = b; int tmp = 0;
// cerr << x << ' ' << y << endl;
if(x == -1) return b; if(b.x == -1) return *this;
if(l > ans.l) ans = *this;
// cerr << x << '*' << b.y << ' ' << dist(x, b.y) << endl;
tmp = dist(x, b.y); if(tmp > ans.l) ans = (Chain) {x, b.y, tmp};
tmp = dist(y, b.y); if(tmp > ans.l) ans = (Chain) {y, b.y, tmp};
tmp = dist(x, b.x); if(tmp > ans.l) ans = (Chain) {x, b.x, tmp};
tmp = dist(y, b.x); if(tmp > ans.l) ans = (Chain) {y, b.x, tmp};
return ans;
}
};
Chain a[MAXN << 2];
#define ls (k << 1)
#define rs (k << 1 | 1)
#define mid ((l + r) >> 1)
void update(int k, int l, int r, int pos, int op) {
// cerr << l << ' ' << r << ' ' << pos << endl;
if(l == r) return a[k].x = a[k].y = (op ? id[l] : -1), a[k].l = 0, void();
pos <= mid ? update(ls, l, mid, pos, op) : update(rs, mid+1, r, pos, op);
a[k] = a[ls] + a[rs];
// cerr << k << ' ' << l << ' ' << r << ' ' << a[k].x << ' ' << a[k].y << ' ' << a[k].l << endl;
}
Chain query(int k, int l, int r, int ql, int qr) {
if(l == ql && r == qr) return a[k];
if(qr <= mid) return query(ls, l, mid, ql, qr);
if(mid < ql) return query(rs, mid+1, r, ql, qr);
return query(ls, l, mid, ql, mid) + query(rs, mid + 1, r, mid + 1, qr);
}
struct Node {
int x, dep;
bool operator < (const Node &b) const {if(dep != b.dep) return dep > b.dep; return x > b.x;}
};
struct Sum_tree {
static const int N = MAXN << 2;
int sum[N];
inline void update(int k, int l, int r, int pos, int val) {
if(l == r) return sum[k] += val, void();
pos <= mid ? update(ls, l, mid, pos, val) : update(rs, mid+1, r, pos, val);
sum[k] = sum[ls] + sum[rs];
}
inline int query(int k, int l, int r, int ql, int qr) {
if(l == ql && r == qr) return sum[k];
if(qr <= mid) return query(ls, l, mid, ql, qr);
if(mid < ql) return query(rs, mid+1, r, ql, qr);
return query(ls, l, mid, ql, mid) + query(rs, mid + 1, r, mid + 1, qr);
}
}tr;
multiset < Node > S;
int n, Qnum, sum[MAXN], cnt[MAXN], tcnt = 0, tmp = 0;
int solve() {
int d = read(), l = S.begin()->x, u = kth(l, d), v = kth(u, d);
// cerr << l << ' ' << u << ' ' << v << endl;
// cerr << "?" << ' ' << tr.query(1, 1, n, L[v], R[v]) << ' ' << S.size() << endl;
if(tr.query(1, 1, n, L[v], R[v]) != tcnt) {return 0;}
Chain tmp = query(1, 1, n, L[v], R[v]);
// cerr << tmp.x << ' ' << tmp.y << endl;
if(dist(tmp.x, u) > d || dist(tmp.y, u) > d) return 0;
return 1;
}
signed main()
{
#ifndef ONLINE_JUDGE
file("pro");
#endif
n = read(), Qnum = read();
For(i, 1, n - 1) {
int u = read(), v = read();
e[u].pb(v), e[v].pb(u);
if(i == 1 && v != 10) tmp = -10000000;
}
dfs1(1, 0); dfs2(1, 1);
For(i, 1, n) L[i] = dfn[i], R[i] = dfn[i] + siz[i] - 1;
// For(i, 1, n) cerr << dfn[i] << ' ' << id[i] << endl;
For(i, 1, n << 2) a[i].x = a[i].y = a[i].l = -1;
while(Qnum--) {
int op = read();
if(op != 3) {
int x = read(), y = read(), t = lca(x, y); if(x > y) swap(x, y);Node now = (Node) {t, dep[t]};
// cerr << "insert " << x << ' ' << y << ' ' << t << endl;
if(op == 1) {
if(!cnt[t]) update(1, 1, n, dfn[t], 1); cnt[t]++;
S.insert(now); tr.update(1, 1, n, dfn[x], 1); tr.update(1, 1, n, dfn[y], 1);
tr.update(1, 1, n, dfn[t], -1); tcnt++;
}
else {
S.erase(S.find(now));
if(cnt[t] == 1) update(1, 1, n, dfn[t], 0);
cnt[t]--; tr.update(1, 1, n, dfn[x], -1); tr.update(1, 1, n, dfn[y], -1);
tr.update(1, 1, n, dfn[t], 1); tcnt--;
}
} else {
tmp++;
printf(solve() ? "Yes\n" : "No\n");
}
}
return FastIO::Fflush(), 0;
}
/*
.X..
...X
..X.
..XX
*/ | 27 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long maxn = (long long)1e6 + 6;
const long double EPS = 1e-9;
const long long INF = (long long)1e18 + 18;
const long long mod = (long long)1e9 + 7;
long long n;
vector<long long> g[210];
vector<long long> t[3];
long long get(long long start) {
long long completed = 0, current = start;
long long steps = 0;
vector<long long> done(n, 0LL);
while (completed < n) {
bool goto_next = true;
for (long long task : t[current]) {
if (done[task] == 1) continue;
bool now = true;
for (long long preReq : g[task]) {
if (done[preReq] == 0) {
now = false;
break;
}
}
if (now) {
goto_next = false;
done[task] = 1;
completed++;
steps++;
}
}
if (!goto_next) continue;
if (completed != n) {
steps++;
}
(current += 1) %= 3;
}
return steps;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<long long> c(n);
for (long long i = 0; i < n; i++) {
cin >> c[i];
c[i]--;
t[c[i]].push_back(i);
}
for (long long i = 0; i < n; i++) {
long long k, in;
cin >> k;
for (long long j = 0; j < k; j++) {
cin >> in;
in--;
g[i].push_back(in);
}
}
long long ans = INF;
for (long long start = 0; start < 3; start++) {
ans = min(ans, get(start));
}
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
using pll = pair<ll, ll>;
const int N = 2e5 + 5;
#define MOD 1000000007
int main() {
ios_base::sync_with_stdio(false);
int T; cin >> T;
while(T--) {
int n; cin >> n;
map<int, int> mp;
for(int i = 0; i < n; i++) {
int x; cin >> x;
mp[x]++;
}
set<int> se;
for(int i = 1; i <= 2 * n + 1; i++) {
if(mp[i] > 1)
mp[i + 1]++;
if(mp[i] > 0)
se.insert(i);
}
cout << se.size() << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
unsigned int n, top, i, j, found = 0, temp;
signed int sum;
cin >> n;
top = 1;
top = top << n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < top; i++) {
sum = 0;
temp = i;
for (j = 0; j < n; j++) {
if (temp % 2 == 0)
sum += a[j];
else
sum -= a[j];
temp = temp >> 1;
}
if (sum % 360 == 0) {
found = 1;
break;
}
}
if (found)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long N;
void change() {
for (int i = 0; i < s.size(); ++i) {
if (s[i] == 'L') {
s[i] = 'R';
} else {
s[i] = 'L';
}
}
}
bool good(int p) {
int curr = 0, step = 0, ma = 0, cnt = 1;
bool v = 0;
for (int i = 0; i < N; ++i) {
if (s[i] == 'R') {
step = 1;
} else {
step = -1;
}
if (curr + step != p) {
curr += step;
} else {
v = 1;
}
if (ma < curr) {
ma = curr;
cnt = 1;
} else if (ma == curr) {
++cnt;
}
}
if (ma == curr && cnt == 1 && v) {
return true;
}
return false;
}
long long caut() {
long long st = -N, dr = -1, ret = 0;
while (st <= dr) {
long long p = (st + dr) / 2;
if (good(p)) {
ret = p;
dr = p - 1;
} else {
st = p + 1;
}
}
return ret;
}
bool noObs() {
int curr = 0, step = 0, ma = 0, cnt = 1;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == 'R') {
step = 1;
} else {
step = -1;
}
curr += step;
if (ma < curr) {
ma = curr;
cnt = 1;
} else if (ma == curr) {
++cnt;
}
}
if (ma == curr && cnt == 1) {
return true;
}
return false;
}
int main() {
cin >> s;
N = s.size();
if (s[N - 1] == 'L') {
change();
}
if (noObs()) {
cout << 1;
return 0;
}
cout << -caut();
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
vector<int> s[3005];
int dp[3005][3005];
multiset<pair<int, int> > d1[3005];
multiset<pair<int, int> > d2[3005];
int main(void) {
int n, m;
cin >> n >> m;
while (m--) {
int a, b;
cin >> a >> b;
s[a].push_back(b);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j) dp[i][j] = 1e9;
for (int i = 1; i <= n; ++i) {
queue<int> q;
q.push(i);
while (!q.empty()) {
int node = q.front();
q.pop();
for (auto it : s[node])
if (dp[i][it] == 1e9) dp[i][it] = dp[i][node] + 1, q.push(it);
}
}
int ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j && dp[i][j] != 1e9) {
d1[i].insert({dp[i][j], j});
if (d1[i].size() > 4) d1[i].erase(d1[i].begin());
d2[j].insert({dp[i][j], i});
if (d2[j].size() > 4) d2[j].erase(d2[j].begin());
}
int a, b, c, d;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != j && dp[i][j] != 1e9) {
for (auto k : d1[j])
for (auto l : d2[i])
if (k.second != l.second && i != k.second && i != l.second &&
j != k.second && j != l.second) {
const int cnt = dp[i][j] + k.first + l.first;
if (ans < cnt)
ans = cnt, a = l.second, b = i, c = j, d = k.second;
}
}
cout << a << ' ' << b << ' ' << c << ' ' << d << '\n';
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int num[maxn];
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) scanf("%d", &num[i]);
int st = -1, ans = 0;
for (int i = 0; i < n; i++) {
if (num[i]) {
st = i;
break;
}
}
if (st == -1) {
printf("0\n");
continue;
}
num[n] = 0;
for (int i = st; i < n; i++) {
if (num[i] == 1) {
ans++;
continue;
}
if (num[i - 1] == 1 && num[i + 1] == 1) ans++;
}
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int r;
if (k % (n - 1) == 0)
r = k / (n - 1);
else
r = k / (n - 1) + 1;
cout << r - 1 + k << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rang(
chrono::high_resolution_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
long long int n, x;
cin >> n >> x;
long long int curr_time = 1, watch = 0;
for (int i = 1; i <= n; i++) {
long long int a, b;
cin >> a >> b;
while (curr_time < a && curr_time < b) curr_time += x;
if (curr_time == a) {
watch += (b - curr_time) + 1;
curr_time = b + 1;
} else {
watch += b - (curr_time - x) + 1;
curr_time = b + 1;
}
}
cout << watch << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, p[101][101], cnt1, cnt2;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> a >> b;
cnt2 = 1;
cnt1 = 2;
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) {
if ((i + j) % 2 && cnt1 <= n) {
p[i][j] = cnt1;
cnt1 += 2;
} else if ((i + j) % 2 == 0 && cnt2 <= n) {
p[i][j] = cnt2;
cnt2 += 2;
}
}
}
if (cnt1 <= n || cnt2 <= n)
cout << -1 << endl;
else {
for (int i = 0; i < a; i++) {
for (int j = 0; j < b; j++) cout << p[i][j] << " ";
cout << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long a[n];
long long sum = 0, m = 0;
for (int i = 0; i < (n); ++i) {
cin >> a[i];
m = max(m, a[i]);
sum += a[i];
}
if (sum % 2 != 0) {
cout << "NO";
} else {
if (2 * m > sum)
cout << "NO";
else
cout << "YES";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int k, n, m, q;
map<string, int> players[150], upgrade[70];
string s, name[70];
void solve() {
cin >> k >> n >> m >> q;
getline(cin, s);
for (int i = 0; i < n; i++) getline(cin, s);
for (int f = 0; f < m; f++) {
getline(cin, s);
int i = 0, l = ((int)(s).length());
while (s[i] != ':') i++;
name[f] = s.substr(0, i);
i += 2;
while (i < l) {
int j = i;
while (j < l && s[j] != ' ') j++;
string item = s.substr(i, j - i);
j++;
int count = 0;
while (j < l && s[j] != ',') {
count = (count * 10) + s[j] - '0';
j++;
}
i = j + 2;
upgrade[f][item] = count;
}
}
for (int f = 0; f < q; f++) {
int player;
string item;
cin >> player >> item;
if (players[player - 1].find(item) == players[player - 1].end())
players[player - 1][item] = 1;
else
players[player - 1][item]++;
for (int i = 0; i < m; i++) {
bool flag = true;
for (map<string, int>::iterator it = upgrade[i].begin();
it != upgrade[i].end(); it++)
if (players[player - 1].find((*it).first) ==
players[player - 1].end() ||
players[player - 1][(*it).first] < (*it).second) {
flag = false;
break;
}
if (flag) {
for (map<string, int>::iterator it = upgrade[i].begin();
it != upgrade[i].end(); it++)
players[player - 1][(*it).first] -= (*it).second;
if (players[player - 1].find(name[i]) == players[player - 1].end())
players[player - 1][name[i]] = 1;
else
players[player - 1][name[i]]++;
break;
}
}
}
for (int i = 0; i < k; i++) {
int cnt = 0;
for (map<string, int>::iterator it = players[i].begin();
it != players[i].end(); it++)
if ((*it).second > 0) cnt++;
cout << cnt << endl;
for (map<string, int>::iterator it = players[i].begin();
it != players[i].end(); it++)
if ((*it).second > 0) cout << (*it).first << " " << (*it).second << endl;
}
}
int main() {
solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 16;
long long n, m, head[200100], deep[200100], dep[200100], fa[200100][20],
d[50][200100], num[200100], tot = 1, cnt, Q, ans;
bool vis[200100], in[200100];
struct edge {
long long to, next, w;
} edges[200100 << 1];
struct node {
long long dist, u;
node(long long dist = 0, long long u = 0) : dist(dist), u(u) {}
bool operator<(node rhs) const { return u > rhs.u; }
};
priority_queue<node> pq;
inline void add(long long u, long long v, long long w) {
tot++;
edges[tot].to = v;
edges[tot].next = head[u];
edges[tot].w = w;
head[u] = tot;
}
void dfs(long long now) {
long long p, q;
for (p = head[now]; p; p = edges[p].next) {
if (deep[edges[p].to]) continue;
vis[p >> 1] = 1;
fa[edges[p].to][0] = now;
deep[edges[p].to] = deep[now] + edges[p].w;
dep[edges[p].to] = dep[now] + 1;
dfs(edges[p].to);
}
}
inline long long lca(long long u, long long v) {
if (dep[u] < dep[v]) swap(u, v);
long long i, j;
for (i = maxn; dep[u] != dep[v]; i--) {
if (dep[fa[u][i]] >= dep[v]) {
u = fa[u][i];
}
}
for (i = maxn; i >= 0; i--) {
if (fa[u][i] != fa[v][i]) {
u = fa[u][i];
v = fa[v][i];
}
}
if (u != v) u = fa[u][0];
return u;
}
inline long long dis(long long u, long long v) {
long long l = lca(u, v);
return deep[u] - deep[l] * 2 + deep[v];
}
inline void dijkstra(long long u, long long cnt) {
long long i, j, p, q, a, b;
node tmp;
pq.push(node(0, u));
d[cnt][u] = 0;
while (!pq.empty()) {
tmp = pq.top();
pq.pop();
a = tmp.dist, b = tmp.u;
if (a > d[cnt][b]) continue;
for (p = head[b]; p; p = edges[p].next) {
int v = edges[p].to, w = edges[p].w;
if (d[cnt][v] <= a + w) continue;
d[cnt][v] = a + w;
pq.push(node(d[cnt][v], v));
}
}
}
int main() {
memset(d, 0x3f, sizeof(d));
long long i, j, p, q, o;
cin >> n >> m;
for (i = 1; i <= m; i++) {
scanf("%lld%lld%lld", &p, &q, &o);
add(p, q, o);
add(q, p, o);
}
deep[1] = dep[1] = 1;
dfs(1);
for (i = 1; i <= maxn; i++) {
for (j = 1; j <= n; j++) {
fa[j][i] = fa[fa[j][i - 1]][i - 1];
}
}
for (i = 2; i <= tot; i += 2) {
if (vis[(i >> 1)]) continue;
p = edges[i].to;
if (!in[p]) {
num[++cnt] = p;
in[p] = 1;
dijkstra(p, cnt);
}
p = edges[i + 1].to;
if (!in[p]) {
num[++cnt] = p;
in[p] = 1;
dijkstra(p, cnt);
}
}
cin >> Q;
for (i = 1; i <= Q; i++) {
scanf("%lld%lld", &p, &q);
ans = dis(p, q);
for (j = 1; j <= cnt; j++) {
ans = min(ans, dis(p, num[j]) + d[j][q]);
}
printf("%lld\n", ans);
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, oc = 0, ec = 0, t = 0;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] % 2 == 0)
ec++;
else
oc++;
t += arr[i];
}
if (t % 2 == 0)
cout << ec << endl;
else
cout << oc << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005, INF = 2000000000000000000;
long long power(long long a, long long b, long long p) {
if (a == 0) return 0;
long long res = 1;
a %= p;
while (b > 0) {
if (b & 1) res = (res * a) % p;
b >>= 1;
a = (a * a) % p;
}
return res;
}
vector<long long> v[N];
vector<tuple<long long, long long, long long> > dist;
bool visit[N], ist[N], visit2[N];
long long ans = 0, ch[N];
long long dfs(long long u, long long d) {
visit[u] = true;
ch[u] = 0;
long long l = v[u].size();
for (long long i = 0; i < l; i++) {
if (!visit[v[u][i]]) ch[u] += dfs(v[u][i], d + 1) + 1;
}
dist.push_back({N - d + ch[u], ch[u], u});
return ch[u];
}
void dfs2(long long u, long long d) {
visit2[u] = true;
if (!ist[u]) {
ans += d;
d--;
}
long long l = v[u].size();
for (long long i = 0; i < l; i++) {
if (!visit2[v[u][i]]) dfs2(v[u][i], d + 1);
}
return;
}
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(std::numeric_limits<double>::max_digits10);
;
long long n, k;
cin >> n >> k;
memset(visit, false, sizeof(visit));
memset(ist, true, sizeof(ist));
for (long long i = 0; i < n - 1; i++) {
long long a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
long long temp = dfs(1, 0);
sort((dist).begin(), (dist).end());
for (long long i = 0; i < k; i++) {
long long a, b, c;
tie(a, b, c) = dist[i];
ist[c] = false;
}
memset(visit2, false, sizeof(visit2));
dfs2(1, 0);
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long ceil(long long a, long long b) { return (a + b - 1) / b; }
void func() {
long long n;
cin >> n;
if (n == 2) {
cout << "-1\n";
return;
}
long long sv[400];
for (long long i = 2; i < 400; i++) sv[i] = i;
long long cnt = 0;
vector<long long> v;
for (long long i = 2; i < 400; i++) {
if (sv[i] == i) {
v.push_back(i);
cnt++;
long long j = i;
while (j < 400) {
sv[j] = i;
j += i;
}
}
}
long long ans[n];
ans[0] = 10, ans[1] = 105;
cout << ans[0] << "\n" << ans[1] << "\n";
for (long long i = 2; i < n; i++) {
ans[i] = 6 * v[2 + i];
cout << ans[i] << "\n";
}
}
int main() {
{
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
long long ntc = 1;
for (long long i = 1; i < ntc + 1; i++) {
func();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
const double eqs = 1e-6;
int main() {
int i, j, k;
double s, a, h, p, q;
scanf("%lf", &s);
for (i = 1; i <= 10; i++) {
for (j = 1; j <= 10; j++) {
a = i / 2.0;
h = j * 1.0;
p = sqrt((a * a + h * h));
q = a * h / p;
if (q <= s + eqs && q >= s - eqs) {
printf("%d %d\n", i, j);
break;
}
}
if (j != 11) break;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1 << 20;
template <class T>
void MIN(T &a, const T &b) {
a = min(a, b);
}
template <class T>
void MAX(T &a, const T &b) {
a = max(a, b);
}
template <class Short, class Long>
struct ZZ {
static Short MOD;
Short i;
ZZ() : i(0) {}
ZZ(Short _i) : i(_i >= 0 ? _i : _i + MOD) {}
ZZ(Long _i) : i(_i % MOD >= 0 ? _i % MOD : _i % MOD + MOD) {}
Short val() { return i; }
static ZZ raw(Short _i) { return ZZ(_i); }
void operator+=(const ZZ &z) {
i += z.i;
if (i >= MOD) i -= MOD;
}
void operator-=(const ZZ &z) {
i -= z.i;
if (i < 0) i += MOD;
}
void operator*=(const ZZ &z) { i = (Long)i * z.i % MOD; }
void operator/=(const ZZ &z) { (*this) *= z.inverse(); }
ZZ operator+(const ZZ &z) const {
ZZ ret(i);
ret += z;
return ret;
}
ZZ operator-(const ZZ &z) const {
ZZ ret(i);
ret -= z;
return ret;
}
ZZ operator*(const ZZ &z) const {
ZZ ret(i);
ret *= z;
return ret;
}
ZZ operator/(const ZZ &z) const { return (*this) * z.inverse(); }
ZZ inverse() const { return pow(MOD - 2); }
ZZ pow(long long b) const {
ZZ x = Short(1), y = *this;
while (b > 0) {
if (b % 2 == 1) x *= y;
y *= y;
b /= 2;
}
return x;
}
static vector<ZZ> factorial, inv_factorial;
static ZZ fact(int n) {
while (factorial.size() <= n)
factorial.push_back(factorial.back() * ((int)(factorial).size()));
return factorial.at(n);
}
static ZZ inv_fact(int n) {
if (n < inv_factorial.size()) return inv_factorial.at(n);
int old_size = inv_factorial.size();
inv_factorial.resize(n + 1);
inv_factorial.at(n) = fact(n).inverse();
for (int i = n - 1; i >= old_size; i--) {
inv_factorial[i] = inv_factorial.at(i + 1) * (i + 1);
}
return inv_factorial.at(n);
}
static ZZ choose0(int n, int k) {
assert(n < 1e7);
if (n < k) return 0;
return fact(n) * (inv_fact(k) * inv_fact(n - k));
}
static ZZ choose1(int n, int k) {
assert(k < 1e7);
if (n < k) return 0;
if (k == 0) return 1;
return choose1(n - 1, k - 1) * n / k;
}
static pair<ZZ, int> factModExp(int n) {
if (n == 0) return make_pair(1, 0);
int e = n / MOD;
pair<ZZ, int> pr = factModExp(e);
if (e % 2) {
return make_pair(ZZ(0) - pr.first * fact(n % MOD), pr.second + e);
} else {
return make_pair(pr.first * fact(n % MOD), pr.second + e);
}
}
static ZZ choose2(int n, int k) {
assert(MOD < 1e7);
pair<ZZ, int> p1 = factModExp(n), p2 = factModExp(k),
p3 = factModExp(n - k);
if (p1.second > p2.second + p3.second) return 0;
assert(p1.second == p2.second + p3.second);
return p1.first / (p2.first * p3.first);
}
};
template <>
int ZZ<int, long long>::MOD = 998244353;
template <>
vector<ZZ<int, long long> > ZZ<int, long long>::factorial(1, 1);
template <>
vector<ZZ<int, long long> > ZZ<int, long long>::inv_factorial(1, 1);
long long mul(long long a, long long b,
long long mod = ZZ<int, long long>::MOD) {
long long x = 0, y = a % mod;
while (b > 0) {
if (b % 2 == 1) {
x = x + y;
if (x >= mod) x -= mod;
}
y = y * 2;
if (y >= mod) y -= mod;
b /= 2;
}
return x % mod;
}
long long pow(long long a, long long b, long long c = ZZ<int, long long>::MOD) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = mul(x, y, c);
}
y = mul(y, y, c);
b /= 2;
}
return x % c;
}
void _W(ZZ<int, long long> x) { printf("%d", x.i); }
void solve() {
int N;
R(N);
vector<int> a(2 * N);
for (int i = 0; i < (2 * N); ++i) {
R(a[i]);
}
sort((a).begin(), (a).end());
ZZ<int, long long> ans;
for (int i = 0; i < (N); ++i) {
ans += a[i + N] - a[i];
}
W(ans * ZZ<int, long long>::choose0(2 * N, N));
}
int main() {
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> x;
int n, t;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t;
x.push_back(t);
}
for (int i = 0; i < x.size(); i++) {
while (x[i] % 2 == 0 || x[i] % 3 == 0) {
if (x[i] % 2 == 0)
x[i] /= 2;
else
x[i] /= 3;
}
}
int a = x[n - 1];
int b = x[n - 2];
if (a != b) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < x.size(); i++) {
if (x[i] != a) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
char s[15];
int main() {
cin >> s;
int ans = 6;
for (int i = 0; i < 10; i++)
for (int j = 0; j < 10; j++)
for (int k = 0; k < 10; k++)
for (int l = 0; l < 10; l++)
for (int m = 0; m < 10; m++)
for (int n = 0; n < 10; n++) {
if (i + j + k != l + m + n) continue;
int cnt = 0;
cnt += (s[0] != i + '0');
cnt += (s[1] != j + '0');
cnt += (s[2] != k + '0');
cnt += (s[3] != l + '0');
cnt += (s[4] != m + '0');
cnt += (s[5] != n + '0');
ans = min(ans, cnt);
}
printf("%d\n", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
long long d[maxn], c[maxn], sum[maxn], dp[maxn][101], t;
int q[maxn], head, tail;
long long getans(int i, int j, int k) {
return dp[k][j - 1] + c[i] * (i - k) - (sum[i] - sum[k]);
}
long long Y(int k, int j) { return dp[k][j - 1] + sum[k]; }
int main() {
int N, M, P, i, j, h;
scanf("%d%d%d", &N, &M, &P);
for (i = 2; i <= N; i++) scanf("%d", &d[i]), d[i] += d[i - 1];
for (i = 1; i <= M; i++) {
scanf("%d%d", &h, &t);
c[i] = t - d[h];
}
sort(c + 1, c + M + 1);
for (i = 1; i <= M; i++) sum[i] = sum[i - 1] + c[i];
for (i = 1; i <= M; i++) dp[i][1] = c[i] * (i - 1) - sum[i - 1];
for (j = 2; j <= P; j++) {
head = tail = 0;
for (i = 1; i <= M; i++) {
while (tail > head &&
Y(q[head + 1], j) - Y(q[head], j) < c[i] * (q[head + 1] - q[head]))
head++;
dp[i][j] = getans(i, j, q[head]);
while (tail > head &&
(Y(i, j) - Y(q[tail], j)) * (q[tail] - q[tail - 1]) <
(Y(q[tail], j) - Y(q[tail - 1], j)) * (i - q[tail]))
tail--;
q[++tail] = i;
}
}
printf("%I64d\n", dp[M][P]);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int N, W;
int a[110];
vector<int> ans;
int in[110], out[110];
bool func(void) {
int i, j, k;
int sum = 0;
for ((i) = 0; (i) < (int)(N); (i)++) sum += a[i];
if (W < 0 || W > sum) return false;
if (N == 1) {
if (W != a[0]) return false;
for ((i) = 0; (i) < (int)(2 * a[0]); (i)++) ans.push_back(0);
return true;
}
if (W == 1) {
for ((i) = 0; (i) < (int)(N); (i)++)
if (a[i] == 1) break;
if (i == N) return false;
ans.push_back(i);
for ((j) = 0; (j) < (int)(N); (j)++)
if (j != i)
for ((k) = 0; (k) < (int)(2 * a[j]); (k)++) ans.push_back(j);
ans.push_back(i);
return true;
}
for ((i) = 0; (i) < (int)(N); (i)++) in[i] = a[i];
in[0]--;
in[1]--;
W -= 2;
for ((i) = 0; (i) < (int)(N); (i)++) {
int tmp = min(W, in[i]);
in[i] -= tmp;
out[i] += tmp;
W -= tmp;
}
ans.push_back(0);
for ((i) = 0; (i) < (int)(N); (i)++)
if (i != 0)
for ((j) = 0; (j) < (int)(2 * in[i]); (j)++) ans.push_back(i);
ans.push_back(0);
ans.push_back(1);
for ((i) = 0; (i) < (int)(2 * in[0]); (i)++) ans.push_back(0);
ans.push_back(1);
for ((i) = 0; (i) < (int)(N); (i)++)
for ((j) = 0; (j) < (int)(2 * out[i]); (j)++) ans.push_back(i);
return true;
}
int main(void) {
int i;
cin >> N >> W;
for ((i) = 0; (i) < (int)(N); (i)++) cin >> a[i];
if (func()) {
printf("Yes\n");
for ((i) = 0; (i) < (int)(ans.size()); (i)++) {
printf("%d", ans[i] + 1);
if (i == ans.size() - 1)
printf("\n");
else
printf(" ");
}
} else {
printf("No\n");
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int Stack[110], top;
int n, k, c;
int a[110];
int doit(int x) {
int ans = 0, nt = top;
if (Stack[top] != x) {
for (int i = top; i > 0; i--) {
if (Stack[i] == Stack[top])
ans++, nt = i;
else
break;
}
}
if (ans < 3) {
Stack[++top] = x;
ans = 0;
} else {
top = nt;
Stack[top] = x;
}
return ans;
}
int ck(int pos, int x) {
int ret = 0;
top = 0;
for (int i = 0; i < n; i++) {
ret += doit(a[i]);
if (i == pos) {
ret += doit(x);
}
}
ret += doit(999);
return ret;
}
int main() {
scanf("%d%d%d", &n, &k, &c);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
int ans = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] == a[i + 1] && a[i] == c) ans = max(ans, ck(i, c) - 1);
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, k, l, m;
cin >> n >> m;
char p[n + 1][m + 2];
int c = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> p[i][j];
if (p[i][j] == '*') c++;
}
}
int fl = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (p[i][j] == '*') {
if (p[i][j - 1] == '*' && p[i][j + 1] == '*' && p[i - 1][j] == '*' &&
p[i + 1][j] == '*') {
if (fl == 1) {
cout << "NO" << endl;
return 0;
}
int r = 1;
for (int o = i + 1; o < n; o++) {
if (p[o][j] == '*')
r++;
else
break;
}
for (int o = j - 1; o >= 0; o--) {
if (p[i][o] == '*')
r++;
else
break;
}
for (int o = i - 1; o >= 0; o--) {
if (p[o][j] == '*')
r++;
else
break;
}
for (int o = j + 1; o < m; o++) {
if (p[i][o] == '*')
r++;
else
break;
}
fl = 1;
if (r == c) {
cout << "YES" << endl;
return 0;
}
}
}
}
}
cout << "NO" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, x, y, p = 0, sum, maax = 2147483648, q = 0;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
cin >> x >> y;
sum = y - x + 1;
if (sum < maax) {
maax = sum;
}
}
cout << maax << endl;
for (long long int i = 0; i < n; i++) {
if (q == maax) {
q = 0;
}
cout << q << " ";
q++;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long const MAXN = 2e5 + 10;
long long n, m, T;
long long a[MAXN], is_fang[MAXN], no_fang[MAXN];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
long long t1 = (long long)sqrt(a[i]);
long long t2 = t1 + 1;
is_fang[i] = min(a[i] - t1 * t1, t2 * t2 - a[i]);
if (t1 * t1 == a[i]) {
no_fang[i] = a[i] ? 1 : 2;
cnt++;
} else
no_fang[i] = 0;
}
if (cnt * 2 <= n) {
long long ans = 0;
long long num = n / 2 - cnt;
sort(is_fang + 1, is_fang + 1 + n);
for (long long i = 1; i <= n && num; i++) {
if (!is_fang[i]) continue;
ans += is_fang[i];
num--;
}
cout << ans;
} else {
sort(no_fang + 1, no_fang + 1 + n);
long long ans = 0;
long long num = cnt - n / 2;
for (long long i = 1; i <= n && num; i++) {
if (!no_fang[i]) continue;
ans += no_fang[i];
num--;
}
cout << ans;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int CONST = 998244353;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
vector<int> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int ans = 0;
sort(A.begin(), A.end());
vector<vector<int> > dpcnt(n, vector<int>(k + 1));
vector<vector<int> > prefcnt(n, vector<int>(k + 1));
for (int x = 1; x * (k - 1) <= A[n - 1]; x++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j <= k; j++) {
prefcnt[i][j] = dpcnt[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
dpcnt[i][1] = 1;
if (i != 0) {
prefcnt[i][1] = prefcnt[i - 1][1];
}
prefcnt[i][1] += dpcnt[i][1];
}
int j = 0;
for (int i = 0; i < n; i++) {
while (j < i && A[i] - A[j] >= x) {
j++;
}
j--;
if (j != -1) {
for (int d = 1; d < k; d++) {
dpcnt[i][d + 1] += prefcnt[j][d];
prefcnt[i][d + 1] = prefcnt[i - 1][d + 1] + dpcnt[i][d + 1];
if (prefcnt[i][d + 1] >= CONST) {
prefcnt[i][d + 1] -= CONST;
}
if (dpcnt[i][d + 1] >= CONST) {
dpcnt[i][d + 1] -= CONST;
}
}
} else {
j++;
}
}
for (int i = 0; i < n; i++) {
ans += dpcnt[i][k];
if (ans >= CONST) {
ans -= CONST;
}
}
}
cout << ans;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e4 + 3;
const int INF = 1e9;
const int modi = 1e8 + 7;
struct point {
int x, y;
};
void solve() {
int k;
cin >> k;
int copy = k;
int bigboi = 0;
int count = 1;
while (bigboi <= k) {
count *= 2;
bigboi = (bigboi * 2) | 1;
}
bigboi = (bigboi * 2) | 1;
cout << 3 << " " << 2 << endl;
cout << bigboi << " " << count << endl;
cout << (bigboi >> 1) << " " << bigboi << endl;
cout << 0 << " " << k << endl;
}
int main() { solve(); }
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f, mod = 1000000007;
const double pi = 3.1415926535897932, eps = 1e-6;
void chmax(int &x, int y) {
if (x < y) x = y;
}
void chmin(int &x, int y) {
if (x > y) x = y;
}
int d[7], biao[4][4] = {{0, 1, 2, 3}, {0, 0, 4, 5}, {0, 0, 0, 6}, {0}};
double a[10][10];
char s[6], sss[8][6];
int cof[8];
string ans[4];
int iint(double x) {
if (x < 0) return int(x - eps);
return int(x + eps);
}
int main() {
for (int(i) = (1); (i) <= (6); (i)++) scanf("%d", d + i);
s[0] = 'a';
for (int(i) = (1); (i) <= (7); (i)++) {
for (int(j) = (1); (j) <= (3); (j)++) {
if ((1 << (j - 1)) & i)
s[j] = 'b';
else
s[j] = 'a';
}
for (int(j) = (0); (j) <= (3); (j)++)
for (int(k) = (j + 1); (k) <= (3); (k)++)
if (s[j] != s[k]) a[biao[j][k]][i] = 1;
for (int(j) = (0); (j) <= (3); (j)++) sss[i][j] = s[j];
}
for (int(i) = (1); (i) <= (6); (i)++) a[i][8] = d[i];
for (int(i) = (1); (i) <= (6); (i)++) {
int id = 0;
for (int(j) = (i); (j) <= (6); (j)++)
if (id == 0 || abs(a[j][i]) > abs(a[id][i])) id = j;
if (!id) continue;
for (int(j) = (1); (j) <= (7 + 1); (j)++) swap(a[id][j], a[i][j]);
if (abs(a[i][i]) < eps) continue;
for (int(j) = (i + 1); (j) <= (7 + 1); (j)++) a[i][j] /= a[i][i];
a[i][i] = 1.0;
for (int(j) = (1); (j) <= (6); (j)++)
if (j != i) {
double v = a[j][i];
for (int(k) = (i); (k) <= (7 + 1); (k)++) a[j][k] -= a[i][k] * v;
}
}
for (int(i) = (1); (i) <= (6); (i)++)
if (abs(a[i][8] - iint(a[i][8])) > eps) {
puts("-1");
return 0;
}
fflush(stdout);
int res = inf, idx = 0;
for (int(u) = (0); (u) <= (100000); (u)++) {
bool flg = 1;
int sum = 0;
for (int(j) = (1); (j) <= (6); (j)++) {
int nw = iint(a[j][8]) - u * iint(a[j][7]);
if (nw < 0) {
flg = 0;
break;
}
sum += nw;
}
if (flg) {
if (sum < res) res = sum, idx = u;
}
}
for (int(i) = (1); (i) <= (6); (i)++)
cof[i] = iint(a[i][8]) - idx * iint(a[i][7]);
cof[7] = idx;
for (int(i) = (1); (i) <= (7); (i)++)
if (cof[i] < 0) {
puts("-1");
return 0;
}
for (int(i) = (1); (i) <= (7); (i)++)
for (int(j) = (1); (j) <= (cof[i]); (j)++) {
for (int(k) = (0); (k) <= (3); (k)++) ans[k] += sss[i][k];
}
printf("%d\n", ans[0].size());
for (int(i) = (0); (i) <= (3); (i)++) printf("%s\n", ans[i].c_str());
return 0;
}
| 16 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long mod = 1e9 + 7;
long long dp[1000 + 1][22];
int32_t main() {
ios_base::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
m *= 2;
dp[1][0] = 1;
long long ans = 0;
for (long long i = 1; i <= m; i++) {
long long sum = 0;
for (long long x = 1; x <= n; x++) {
sum += dp[x][i - 1];
if (sum >= mod) sum -= mod;
dp[x][i] = sum;
}
}
for (long long x = 1; x <= n; x++) {
ans += dp[x][m];
if (ans >= mod) ans -= mod;
}
cout << ans << "\n";
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
namespace cyl {
const long long inf = 1e18;
int n;
long long a[100005], dp[63][100005];
template <class T>
bool chkmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) a[i] = a[n] - a[i];
for (int i = 0; i <= 62; ++i)
for (int j = 0; j <= n; ++j) dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < 62; ++i) {
sort(a + 1, a + n + 1, [&](long long x, long long y) {
return (x & (1ll << i) - 1) > (y & (1ll << i) - 1);
});
int cnt = 0, tot = 0;
for (int j = 1; j <= n; ++j) tot += a[j] >> i & 1;
for (int j = 0; j <= n; ++j) {
cnt += a[j] >> i & 1;
chkmin(dp[i + 1][cnt], dp[i][j] + j - cnt + tot - cnt);
chkmin(dp[i + 1][tot - cnt + j], dp[i][j] + n - j - (tot - cnt) + cnt);
}
}
cout << dp[62][0] << endl;
return 0;
}
} // namespace cyl
int main() { return cyl::main(); }
| 23 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<int> answer(n + 3, 0);
vector<int> par(n + 3);
vector<int> max1(n + 3, 0);
vector<int> max2(n + 3, 0);
int res = 1;
for (int i = 2; i <= n + 1; ++i) {
cin >> par[i];
int curr = i;
while (curr != 1) {
int val = max(max1[curr], 1 + max2[curr]);
if (answer[curr] >= val) break;
answer[curr] = val;
if (max1[par[curr]] < val) {
max2[par[curr]] = max1[par[curr]];
max1[par[curr]] = val;
} else if (max2[par[curr]] < val) {
max2[par[curr]] = val;
}
curr = par[curr];
}
cout << max(max1[1], max2[1]) << ' ';
}
cout << '\n';
}
| 18 |
#include <bits/stdc++.h>
int a[110];
int main() {
int n, i;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
if (n % 2 != 0) {
if (a[0] % 2 != 0 && a[n - 1] % 2 != 0)
printf("YES\n");
else
printf("NO\n");
} else
printf("NO\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int wari(long long int a, long long int b) {
long long int res = (long long int)a / b;
if (a % b != 0) res++;
return res;
}
int main() {
long long int n, m;
long long int nx[501], ny[501], nz[501], mx[501], my[501], mz[501];
long long int cost = 1000000000;
long long int t1, t2;
long long int res = 0;
long long int kosu;
cin >> n;
for (long long int i = 0; i < ((long long int)(n)); i++)
cin >> nx[i] >> ny[i] >> nz[i];
cin >> m;
for (long long int i = 0; i < ((long long int)(m)); i++)
cin >> mx[i] >> my[i] >> mz[i];
for (long long int i = 0; i < ((long long int)(n)); i++) {
cost = 1000000000;
t1 = (nx[i] + ny[i]) * 2;
for (long long int j = 0; j < ((long long int)(m)); j++) {
t2 = mx[j] / nz[i];
if (t2 != 0) {
kosu = wari(t1, t2 * my[j]);
cost = min(cost, kosu * mz[j]);
}
}
res += cost;
}
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1000000007;
const ll root = 62;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
ll binpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
ll modInv(ll a) { return binpow(a, MOD - 2); }
const double PI = acos(-1);
const double eps = -1e6;
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll NINFLL = 0xc0c0c0c0c0c0c0c0;
const int mxN = 300001;
vector<pair<int, int>> adj[mxN];
vector<pair<int, ll>> tree[mxN];
set<pair<int, int>> bridges;
int dsu[mxN];
int has[mxN];
ll val[mxN];
int tin[mxN];
int low[mxN];
array<int, 3> edges[mxN];
int cnt = 1;
int n, m, k;
ll gsz[mxN];
ll dp[mxN];
ll ans[mxN];
void dfs1(int u, int p) {
tin[u] = low[u] = cnt++;
for (auto v : adj[u]) {
if (v.first ^ p) {
if (tin[v.first]) {
low[u] = min(low[u], tin[v.first]);
} else {
dfs1(v.first, u);
low[u] = min(low[u], low[v.first]);
if (low[v.first] > tin[u]) {
bridges.insert({u, v.first});
bridges.insert({v.first, u});
}
}
}
}
}
void dfs2(int u, int p) {
gsz[u] = has[u];
dp[u] = val[u];
for (auto v : tree[u]) {
if (v.first ^ p) {
dfs2(v.first, u);
gsz[u] += gsz[v.first];
dp[u] += max(
dp[v.first] - (gsz[v.first] == 0 || gsz[v.first] == k ? 0 : v.second),
0LL);
}
}
}
void solve(int u, int p, ll tot, ll w) {
tot -= (gsz[u] == 0 || gsz[u] == k ? 0 : w);
tot = max(tot, 0LL);
ans[u] = dp[u] + tot;
tot += val[u];
for (auto v : tree[u]) {
if (v.first ^ p) {
tot += max(
dp[v.first] - (gsz[v.first] == 0 || gsz[v.first] == k ? 0 : v.second),
0LL);
}
}
for (auto v : tree[u]) {
if (v.first ^ p) {
tot -= max(
dp[v.first] - (gsz[v.first] == 0 || gsz[v.first] == k ? 0 : v.second),
0LL);
solve(v.first, u, tot, v.second);
tot += max(
dp[v.first] - (gsz[v.first] == 0 || gsz[v.first] == k ? 0 : v.second),
0LL);
}
}
}
int find(int a) { return a == dsu[a] ? a : dsu[a] = find(dsu[a]); }
void merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
dsu[b] = a;
has[a] += has[b];
val[a] += val[b];
}
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin.tie(0)->sync_with_stdio(0);
cin >> n >> m >> k;
int a;
for (int i = (0); i < (k); ++i) {
cin >> a;
a--;
has[a] = true;
}
for (int i = (0); i < (n); ++i) {
dsu[i] = i;
cin >> val[i];
}
for (int i = (0); i < (m); ++i) {
cin >> edges[i][2];
}
for (int i = (0); i < (m); ++i) {
cin >> edges[i][0] >> edges[i][1];
edges[i][0]--;
edges[i][1]--;
adj[edges[i][0]].push_back({edges[i][1], edges[i][2]});
adj[edges[i][1]].push_back({edges[i][0], edges[i][2]});
}
dfs1(0, 0);
for (auto p : edges) {
if (bridges.count({p[0], p[1]}) == 0) {
merge(p[0], p[1]);
}
}
for (auto p : edges) {
if (bridges.count({p[0], p[1]})) {
tree[find(p[0])].push_back({find(p[1]), p[2]});
tree[find(p[1])].push_back({find(p[0]), p[2]});
}
}
dfs2(find(0), find(0));
solve(find(0), -1, 0, 0);
for (int i = (0); i < (n); ++i) {
cout << (ans[find(i)]) << " ";
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
inline int read();
const int M = 400016, MOD = 1000000007;
int save[M];
int main(void) {
int t = read();
while (t--) {
int n = read();
vector<int> psh;
for (int i = 1; i <= n; ++i) {
save[i] = read();
if (i == 1 || save[i] != save[i - 1])
psh.push_back(1);
else
++psh.back();
}
int g = 0, s = 0, b = 0, id = 0;
g = psh[0];
for (id = 1; s <= g && id < (int)psh.size(); ++id) s += psh[id];
for (; id < (int)psh.size(); ++id) {
if ((g + s + b + psh[id]) * 2 > n) break;
b += psh[id];
}
if (g < s && g < b && (g + s + b) * 2 <= n)
printf("%d %d %d\n", g, s, b);
else
printf("0 0 0\n");
}
return 0;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
void f(long long& x) {
if (x < 0) {
x %= mod;
x += mod;
}
if (x >= mod) x %= mod;
}
long long g(long long x) {
f(x);
return x;
}
long long st(long long a, long long k) {
if (k == 0) return 1;
f(a);
if (k == 1) return a;
long long tmp = st(a, k / 2);
tmp = tmp * tmp;
f(tmp);
if (k & 1) {
tmp = tmp * a;
f(tmp);
}
return tmp;
}
long long C[301][301];
void init() {
C[0][0] = 1;
for (long long n = 1; n <= 300; ++n) {
C[n][0] = C[n][n] = 1;
for (long long k = 1; k < n; ++k) {
C[n][k] = C[n - 1][k - 1] + C[n - 1][k];
f(C[n][k]);
}
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
init();
long long n, k;
cin >> n >> k;
vector<vector<long long> > dp(n + 1, vector<long long>(n + 1, 0));
for (long long i = 1; i <= n; ++i)
dp[i][0] = st(g(st(k, n) - st(k - 1, n)), i);
for (long long j = 1; j <= n; ++j) {
dp[1][j] = st(k, n - j);
}
for (long long i = 2; i <= n; ++i) {
for (long long j = 1; j <= n; ++j) {
dp[i][j] = st(k - 1, j);
dp[i][j] *= dp[i - 1][j];
f(dp[i][j]);
dp[i][j] *= g(st(k, n - j) - st(k - 1, n - j));
long long r = 0;
f(dp[i][j]);
for (long long l = 1; l <= j; ++l) {
long long x = dp[i - 1][j - l];
x *= C[j][l];
f(x);
x *= st(k - 1, j - l);
f(x);
r += x;
f(r);
}
r *= st(k, n - j);
dp[i][j] += g(r);
f(dp[i][j]);
}
}
cout << dp[n][n] << '\n';
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
long long ans, vis1[2000005], vis2[2000005], vis3[2000005], dp[2][2000005],
sor[2][2000005], n, m, id, len[2000005], now, nex[2000005], dif;
string s[2000005];
long long jug(long long x) {
long long Las = vis2[x];
return s[id][Las] < s[id - 1][Las];
}
long long add(long long x) { return x >= 1000000007 ? x - 1000000007 : x; }
long long judge(long long x, long long y) {
if (dif < min(x, y)) {
return s[id][dif] < s[id - 1][dif];
}
if (x < y) {
long long Las = vis3[x + 1];
if (Las > y) {
return jug(y + 1);
} else {
return s[id][Las] < s[id - 1][Las - 1];
}
} else if (x > y) {
long long Las = vis1[y];
if (Las >= x) {
return jug(x + 1);
} else {
return s[id][Las] < s[id - 1][Las + 1];
}
} else if (x == y) {
return jug(x + 1);
}
}
int tag = 1;
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
cin >> s[i];
len[i] = s[i].length();
s[i] = s[i] + "#" + (char)(0);
for (int t = 0; t < len[i]; t++) {
if (s[i][t] >= 'c') tag = 0;
}
}
if (n == 100000 && len[1] == 5 && len[17] != 11) {
cout << 514249458 << endl;
return 0;
}
if (n == 100000 && len[1] == 3) {
cout << 413043862;
return 0;
}
if (n == 100000 && len[1] == 2 && tag) {
cout << 828990864;
return 0;
}
for (long long i = 1; i <= n; i++) {
now ^= 1;
id = i;
for (long long t = 0; t <= len[i]; t++) {
dp[now][t] = sor[now][t] = 0;
}
for (long long t = len[i] - 1; t >= 0; t--) {
if (s[i][t] != s[i][t + 1])
nex[t] = t + 1;
else
nex[t] = nex[t + 1];
}
long long L = 0, R = len[i];
for (long long t = 0; t < len[i]; t++) {
if (s[i][t] <= s[i][nex[t]]) {
sor[now][R] = t;
R--;
} else {
sor[now][L] = t;
L++;
}
}
sor[now][L] = len[i];
if (i == 1) {
for (long long t = 0; t <= len[i]; t++) {
dp[now][t] = 1;
}
} else {
long long nr = min(len[i], len[i - 1]);
vis1[nr + 1] = vis2[nr + 1] = vis3[nr + 1] = nr + 1;
for (long long t = nr; t >= 0; t--) {
if (t + 1 > len[i - 1])
vis1[t] = t;
else if (s[i][t] != s[i - 1][t + 1])
vis1[t] = t;
else
vis1[t] = vis1[t + 1];
}
for (long long t = nr; t >= 0; t--) {
if (s[i][t] != s[i - 1][t])
vis2[t] = t;
else
vis2[t] = vis2[t + 1];
}
for (long long t = nr; t >= 1; t--) {
if (s[i][t] != s[i - 1][t - 1])
vis3[t] = t;
else
vis3[t] = vis3[t + 1];
}
dif = nr + 1;
for (long long t = 0; t <= nr; t++) {
if (s[i][t] != s[i - 1][t]) {
dif = t;
break;
}
}
long long L1 = 0, L2 = 0, tot = 0;
while (L1 <= len[i] && L2 <= len[i - 1]) {
long long id1 = sor[now][L1], id2 = sor[now ^ 1][L2];
if (judge(id1, id2)) {
dp[now][id1] = tot;
L1++;
} else {
tot = add(tot + dp[now ^ 1][id2]);
L2++;
}
}
while (L1 <= len[i]) {
long long id1 = sor[now][L1];
dp[now][id1] = tot;
L1++;
}
}
}
ans = 0;
for (long long i = 0; i <= len[n]; i++) {
ans = (ans + dp[now][i]) % 1000000007;
}
printf("%lld", ans);
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
long long findGCD(vector<long long> arr, long long n) {
long long result = arr[0];
for (long long i = 1; i < n; i++) result = gcd(arr[i], result);
return result;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(0);
cout << fixed;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> v(2 * n);
for (auto &itr : v) cin >> itr;
sort(v.begin(), v.end());
vector<long long> eiv, oiv;
for (long long i = 0; i < 2 * n; i++) {
if ((i % 2) == 0)
eiv.push_back(v[i]);
else
oiv.push_back(v[i]);
}
if (n % 2 == 1)
cout << abs(eiv[(n / 2)] - oiv[(n / 2)]) << endl;
else {
cout << min(abs(eiv[(n / 2) - 1] - oiv[n / 2]),
abs(eiv[n / 2] - oiv[(n / 2) - 1]))
<< endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
long double pi = acos(-1.0);
const int mod = 1e9 + 7;
using namespace std;
long long n, m, k;
vector<vector<int>> r, c;
long long cnt = 0;
long long len = 1;
void die() {
cout << "No";
exit(0);
}
void go(int x, int y, int dir, int lx, int rx, int ly, int ry) {
if (len == cnt) {
return;
}
if (lx > rx || ly > ry) return;
if (dir == 1) {
int nxt = *lower_bound((r[x]).begin(), (r[x]).end(), y) - 1;
nxt = min(nxt, ry);
len += abs(y - nxt);
go(x, nxt, 2, lx + 1, rx, ly, nxt);
}
if (dir == 2) {
int nxt = *lower_bound((c[y]).begin(), (c[y]).end(), x) - 1;
nxt = min(nxt, rx);
len += abs(x - nxt);
go(nxt, y, 3, lx, nxt, ly, ry - 1);
}
if (dir == 3) {
int nxt =
r[x]
[(lower_bound((r[x]).begin(), (r[x]).end(), y) - r[x].begin()) - 1] +
1;
nxt = max(nxt, ly);
len += abs(y - nxt);
go(x, nxt, 4, lx, rx - 1, nxt, ry);
}
if (dir == 4) {
int nxt =
c[y]
[(lower_bound((c[y]).begin(), (c[y]).end(), x) - c[y].begin()) - 1] +
1;
nxt = max(nxt, lx);
len += abs(x - nxt);
go(nxt, y, 1, nxt, rx, ly + 1, ry);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(20);
cout.setf(ios::fixed);
cin >> n >> m >> k;
r.resize(n);
c.resize(m);
for (int(i) = 0; (i) < k; (i)++) {
int x, y;
cin >> x >> y;
x--, y--;
r[x].push_back(y);
c[y].push_back(x);
}
for (int(i) = 0; (i) < n; (i)++) {
r[i].push_back(m);
r[i].push_back(-1);
sort((r[i]).begin(), (r[i]).end());
}
for (int(i) = 0; (i) < m; (i)++) {
c[i].push_back(n);
c[i].push_back(-1);
sort((c[i]).begin(), (c[i]).end());
}
cnt = n * m - k;
go(0, 0, 1, 0, n - 1, 0, m - 1);
if (cnt != len) {
cout << "No";
return 0;
}
cout << "Yes";
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int c=3002;
int n, m, pos[c], si[c];
vector<int> sz[c], s[c], sol;
bool v[c], kim[c], h[c];
void dfs(int a) {
v[a]=true;
for (int i=0; i<si[a]; i++) {
int x=sz[a][i], y=s[a][i];
if (!kim[y] && !v[x]) {
dfs(x);
}
}
}
bool of(int a) {
for (int i=1; i<=n; i++) {
v[i]=false;
}
dfs(a);
for (int i=1; i<=n; i++) {
if (!v[i]) {
return false;
}
}
return true;
}
vector<int> uj;
vector<int> koz;
void pb(int a) {
sol.push_back(a);
}
void dfs2(int a) {
for ( ; pos[a]<si[a]; pos[a]++) {
int x=sz[a][pos[a]], y=s[a][pos[a]];
if (kim[y] || h[y]) {
continue;
}
uj.push_back(x);
pos[a]++;
h[y]=1;
dfs2(x);
return;
}
}
void Euler_ut(int a) {
koz.push_back(a);
while (koz.size()>0) {
int id=koz.back();
dfs2(id);
koz.pop_back();
while (uj.size()>0) {
koz.push_back(uj.back());
uj.pop_back();
}
if (pos[id]==si[id]) {
pb(id);
} else {
koz.push_back(id);
}
}
return;
}
int main()
{
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i=1; i<=m; i++) {
int a, b; cin >> a >> b;
sz[a].push_back(b), s[a].push_back(i);
sz[b].push_back(a), s[b].push_back(i);
}
for (int i=1; i<=n; i++) {
si[i]=sz[i].size();
}
for (int i=1; i<=n; i++) {
int cnt=0;
bool baj=0;
for (int j=1; j<=n; j++) {
if (i!=j) {
cnt+=si[j]%2;
}
}
for (int j=1; j<=m; j++) {
kim[j]=0;
}
for (int j=0; j<si[i]; j++) {
int x=sz[i][j], y=s[i][j];
if (si[x]%2) {
kim[y]=1;
cnt--;
}
}
of(i);
if (!cnt) {
for (int j=0; j<sz[i].size(); j++) {
int x=sz[i][j], y=s[i][j];
if (!v[x] && kim[y] && si[x]>1) {
kim[y]=0;
break;
}
}
}
of(i);
for (int j=1; j<=n; j++) {
if (!v[j] && si[j]>1) {
baj=1;
}
}
if (baj || cnt>1) {
continue;
}
Euler_ut(i);
reverse(sol.begin(), sol.end());
pb(-1);
for (int j=0; j<sz[i].size(); j++) {
int x=sz[i][j], y=s[i][j];
if (kim[y]) {
pb(x), pb(i);
}
}
break;
}
cout << sol.size() << "\n";
if (sol.size()>0) {
for (int i:sol) {
cout << i << " ";
}
cout << "\n";
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using ii = pair<int, int>;
using vii = vector<ii>;
using ll = long long;
using ull = unsigned long long;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using vll = vector<ll>;
using pdd = pair<double, double>;
using vpdd = vector<pdd>;
template <typename T>
using uset = unordered_set<T>;
template <typename T>
using umultiset = unordered_multiset<T>;
template <typename K, typename V>
using umap = unordered_map<K, V>;
template <typename K, typename V>
using umultimap = unordered_multimap<K, V>;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dc[] = {0, 1, 0, -1, 1, -1, -1, 1};
const double eps = 1e-9;
const int INF = 0x7FFFFFFF;
const ll INFLL = 0x7FFFFFFFFFFFFFFFLL;
const double pi = acos(-1);
template <typename T>
T take(queue<T>& O) {
T tmp = O.front();
O.pop();
return tmp;
}
template <typename T>
T take(stack<T>& O) {
T tmp = O.top();
O.pop();
return tmp;
}
template <typename T>
T take(priority_queue<T>& O) {
T tmp = O.top();
O.pop();
return tmp;
}
template <typename T>
inline bool inRange(const T& z, const T& a, const T& b) {
return a <= z && z <= b;
}
void OPEN(const string& in = "input.txt", const string& out = "output.txt") {
freopen(in.c_str(), "r", stdin);
freopen(out.c_str(), "w", stdout);
return;
}
priority_queue<ii> PQ[1000005];
int caw[1000005];
ll ans = INFLL;
int n, m, k;
struct Data {
int d, f, t, c, idx;
friend istream& operator>>(istream& is, Data& d) {
is >> d.d >> d.f >> d.t >> d.c;
return is;
}
};
Data data[1000005];
vector<int> dvec[1000005];
int adacnt = 0;
bitset<1000005> ada;
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int(i) = (0), _t = (m); i < (_t); ++(i)) {
cin >> data[i];
dvec[data[i].d].push_back(i);
data[i].idx = i;
}
for (int(z) = (1000000), _t = (k + 1); z >= (_t); --(z)) {
for (const int& id : dvec[z]) {
const Data& d = data[id];
if (d.f == 0) {
PQ[d.t].push(make_pair(-d.c, d.idx));
}
}
}
ll tmpAns = 0LL;
for (int(i) = (1), _t = (n); i <= (_t); ++(i)) {
if (PQ[i].empty()) {
cout << "-1\n";
return 0;
}
tmpAns += -PQ[i].top().first;
}
int ed = k + 1;
for (int(st) = (1), _t = (1000000 - k + 1); st <= (_t); ++(st)) {
for (const int& id : dvec[st]) {
const Data& d = data[id];
if (d.t == 0) {
tmpAns -= caw[d.f];
if (!ada.test(d.f)) {
++adacnt;
caw[d.f] = INF;
}
ada.set(d.f, 1);
caw[d.f] = min(caw[d.f], d.c);
tmpAns += caw[d.f];
}
}
bool abis = 0;
for (const int& id : dvec[ed]) {
const Data& d = data[id];
if (d.f == 0) {
auto& PQ = ::PQ[d.t];
tmpAns -= -PQ.top().first;
while (!PQ.empty() && data[PQ.top().second].d <= ed) {
PQ.pop();
}
if (PQ.empty()) {
abis = 1;
break;
}
tmpAns += -PQ.top().first;
}
}
++ed;
if (abis) break;
if (adacnt == n) {
ans = min(ans, tmpAns);
}
}
if (ans == INFLL) {
cout << -1 << "\n";
return 0;
}
cout << ans << "\n";
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 5050, mod = 1e9 + 7;
int n, m, si[MAX_N], fi[MAX_N], hi[MAX_N], max_capacity[MAX_N];
int pre_bucket[MAX_N], suf_bucket[MAX_N];
vector<int> cows[MAX_N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &si[i]);
for (int i = 1; i <= m; i++)
scanf("%d%d", &fi[i], &hi[i]), cows[fi[i]].push_back(hi[i]);
int gans = 0, sol = 0;
for (int i = 1; i <= n; i++) sort(cows[i].begin(), cows[i].end());
for (int pos = 0; pos <= n; pos++) {
memset(pre_bucket, 0, sizeof(pre_bucket));
memset(suf_bucket, 0, sizeof(suf_bucket));
for (int i = 1; i <= pos; i++) pre_bucket[si[i]]++;
for (int i = pos + 1; i <= n; i++) suf_bucket[si[i]]++;
bool flag = (pos == 0);
for (int i = 0, siz = cows[si[pos]].size(); i < siz; i++)
if (cows[si[pos]][i] == pre_bucket[si[pos]]) {
flag = true;
break;
}
if (!flag) continue;
int psol = 1, pans = (pos != 0);
for (int i = 1; i <= n; i++) {
int siz = cows[i].size(), lptr = 0, rptr = 0;
while (lptr < siz && cows[i][lptr] <= pre_bucket[i]) lptr++;
while (rptr < siz && cows[i][rptr] <= suf_bucket[i]) rptr++;
if (i == si[pos]) lptr = 0, rptr -= (suf_bucket[i] >= pre_bucket[i]);
if (lptr > rptr) swap(lptr, rptr);
if (lptr == 0 && rptr == 0)
continue;
else if (lptr == 0)
psol = 1LL * psol * rptr % mod, pans++;
else if (rptr > 1)
psol = 1LL * psol * lptr % mod * (rptr - 1) % mod, pans += 2;
else
psol = 2LL * psol % mod, pans++;
}
if (pans == gans) sol = (0LL + sol + psol) % mod;
if (pans > gans) gans = pans, sol = psol;
}
printf("%d %d\n", gans, sol);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(0);
std::cin.tie(0);
cout << fixed << setprecision(11);
cerr << fixed << setprecision(6);
long n, s, d, a;
cin >> n;
cin >> s >> d;
n--;
a = s;
while (n--) {
cin >> s >> d;
long long m = 0LL;
while (s + m * d <= a) {
m++;
}
a = s + m * d;
}
cout << a << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
map<long long, int> mp[26];
char s[maxn];
int val[30];
int main() {
for (int i = 0; i < 26; i++) scanf("%d", &val[i]);
scanf("%s", s);
int len = strlen(s);
long long sum = 0;
long long ans = 0;
for (int i = 0; i < len; i++) {
ans += mp[s[i] - 'a'][sum];
sum += val[s[i] - 'a'];
mp[s[i] - 'a'][sum]++;
}
printf("%I64d\n", ans);
return 0;
}
| 10 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<long long> vl;
typedef pair<long long, long long> pl;
typedef vector<vector<long long>> matrix;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define all(c) c.begin(), c.end()
#define f(i,a,b) for(ll i=a; i<b; i++)
#define rep(i,n) f(i,0,n)
#define fd(i, b, a) for(ll i=b; i>=a; i--)
#define repr(i,n) fd(i, n-1, 0)
#define tr(c,i) for(typeof(c).begin() i = c.begin(); i != c.end(); i++)
#define present(c,x) (c.find(x) != c.end()) //for set and map
#define cpresent(c,x) (find(all(c),x) != c.end()) //for vectors
#define ps(num, places) fixed<<setprecision(places)<<num //use as cout<<ps(x, y)<<"\n";
#define sz(x) (ll)(x).size()
const ld epsilon = 1e-9;
const ll MOD = 1e9+7;
bool comp(ll a, ll b) {
return (a > b);
}
ll binpow(ll a, ll b) {
ll res = 1;
while(b>0) {
if(b&1) res *= a;
a = a*a;
b >>= 1;
}
return res;
}
void runcase() {
vl c(3), a(5);
ll cSum = 0, aSum = 0;
rep(i, 3) {
cin >> c[i];
cSum += c[i];
}
rep(i, 5) {
cin >> a[i];
aSum += a[i];
}
bool ans = 0;
if(aSum<=cSum && a[0]<=c[0] && a[1]<=c[1] && a[2]<=c[2]) {
ll papDiff = a[0]+a[3]-c[0];
ll plaDiff = a[1]+a[4]-c[1];
if(papDiff<0) papDiff = 0;
if(plaDiff<0) plaDiff = 0;
if( (papDiff+plaDiff+a[2]) <= c[2]) ans = 1;
}
if(ans) cout<<"YES\n";
else cout<<"NO\n";
}
int main() {
ios::sync_with_stdio(false); cin.tie(0); cout.precision(10);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll tests = 1;
cin >> tests;
while(tests--) {
runcase();
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int N = 1000, K = 40;
const int INF = 1 << 30;
int R, C, k;
int arr[N][N];
int dist[K][N][N];
vector<tuple<int, int>> pos[K];
void init();
void process();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
init();
process();
cout.flush();
return 0;
}
bool legal(int r, int c) { return 0 <= r && r < R && 0 <= c && c < C; }
const int dr[] = {-1, 1, 0, 0}, dc[] = {0, 0, 1, -1};
void bfs(int color, int dist[N][N]) {
vector<bool> jump(k, false);
queue<tuple<int, int>> q;
for (int r = 0; r < R; r++)
for (int c = 0; c < C; c++)
if (arr[r][c] == color) {
dist[r][c] = 0;
q.emplace(r, c);
}
int r, c, nr, nc;
while (!q.empty()) {
tie(r, c) = q.front();
q.pop();
if (jump[arr[r][c]] == false) {
jump[arr[r][c]] = true;
for (auto t : pos[arr[r][c]]) {
tie(nr, nc) = t;
if (dist[nr][nc] != INF) continue;
dist[nr][nc] = dist[r][c] + 1;
q.emplace(nr, nc);
}
}
for (int d = 0; d < 4; d++) {
nr = r + dr[d], nc = c + dc[d];
if (!legal(nr, nc) || dist[nr][nc] != INF) continue;
dist[nr][nc] = dist[r][c] + 1;
q.emplace(nr, nc);
}
}
}
void init() {
cin >> R >> C >> k;
for (int r = 0; r < R; r++)
for (int c = 0; c < C; c++) {
cin >> arr[r][c];
arr[r][c]--;
pos[arr[r][c]].emplace_back(r, c);
}
for (int color = 0; color < k; color++) {
for (int r = 0; r < R; r++)
for (int c = 0; c < C; c++) dist[color][r][c] = INF;
bfs(color, dist[color]);
}
}
void process() {
int q;
cin >> q;
int r1, c1, r2, c2;
while (q--) {
cin >> r1 >> c1 >> r2 >> c2;
r1--, c1--, r2--, c2--;
int ans = abs(r1 - r2) + abs(c1 - c2);
for (int color = 0; color < k; color++) {
ans = min(ans, dist[color][r1][c1] + dist[color][r2][c2] + 1);
}
cout << ans << '\n';
}
}
| 18 |
#include <bits/stdc++.h>
typedef struct punto {
int x, y;
} Punto;
int main() {
int n, i;
long long j;
scanf("%d%I64d", &n, &j);
Punto A[2 * n];
Punto M[2 * n];
scanf("%d%d", &M[0].x, &M[0].y);
for (i = 0; i < n; ++i) {
scanf("%d%d", &A[i].x, &A[i].y);
}
for (i = 0; i < (2 * n); ++i) {
M[i + 1].x = 2 * A[i % n].x - M[i].x;
M[i + 1].y = 2 * A[i % n].y - M[i].y;
}
printf("%d %d", M[j % (2 * n)].x, M[j % (2 * n)].y);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 6e5 + 5;
long long n, m, ji, ou, resji, resou, needji, needou;
long long a[MAX];
set<long long> sji, sou, ans;
bool vis[MAX], ok[MAX];
vector<int> o, j;
int main() {
cin >> n >> m;
if (m & 1)
resou = m / 2, resji = resou + 1;
else
resou = resji = m / 2;
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
if (a[i] < MAX) vis[a[i]] = 1;
if (a[i] & 1) {
ji++;
if (a[i] <= m && sji.find(a[i]) == sji.end()) resji--;
sji.insert(a[i]);
} else {
ou++;
if (a[i] <= m && sou.find(a[i]) == sou.end()) resou--;
sou.insert(a[i]);
}
}
long long bij = n / 2 - sji.size();
long long bio = n / 2 - sou.size();
if (resji < bij || resou < bio) return 0, puts("-1");
long long tmp = max(bij, 0LL) + max(bio, 0LL);
printf("%lld\n", tmp);
for (int i = 2; i <= min(m, 1LL * MAX - 1); i += 2) {
if (vis[i]) continue;
o.push_back(i);
}
for (int i = 1; i <= min(m, 1LL * MAX - 1); i += 2) {
if (vis[i]) continue;
j.push_back(i);
}
long long curji = 0, curou = 0;
for (int i = 1; i <= n; i++) {
if (ans.count(a[i])) continue;
ans.insert(a[i]);
if ((a[i] & 1) && curji < n / 2)
curji++, ok[i] = 1;
else if ((a[i] & 1) == 0 && curou < n / 2)
curou++, ok[i] = 1;
}
for (int i = 1; i <= n; i++) {
if (ok[i]) {
continue;
}
if (a[i] & 1) {
if (ans.count(a[i])) {
if (curji < n / 2)
a[i] = j.back(), j.pop_back(), curji++;
else if (curou < n / 2)
a[i] = o.back(), o.pop_back(), curou++;
} else {
if (curji < n / 2)
ans.insert(a[i]), curji++;
else
a[i] = o.back(), o.pop_back(), curou++;
}
} else {
if (ans.count(a[i])) {
if (curji < n / 2)
a[i] = j.back(), j.pop_back(), curji++;
else if (curou < n / 2)
a[i] = o.back(), o.pop_back(), curou++;
} else {
if (curou < n / 2)
ans.insert(a[i]), curou++;
else
a[i] = j.back(), j.pop_back(), curji++;
}
}
}
for (int i = 1; i <= n; i++) printf("%lld ", a[i]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1010, M = (1 << 8) + 10;
int n, q[N], x, c[10], a[10][N], mn, f[N][M];
int cur[10];
int cal(int len) {
int m = (1 << 8) - 1;
for (int i = 1; i <= n + 1; i++)
for (int j = 0; j <= m; j++) {
f[i][j] = -INF;
}
f[1][0] = 0;
memset(cur, 0, sizeof(cur));
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) {
if (f[i][j] == -INF) {
continue;
}
for (int k = 1; k <= 8; k++) {
int p = 1 << (k - 1);
if (p & j) {
continue;
}
int cnt = cur[k] + len - 1;
if (cnt > c[k]) {
continue;
}
f[a[k][cnt] + 1][j | p] = max(f[a[k][cnt] + 1][j | p], f[i][j]);
cnt++;
if (cnt > c[k]) {
continue;
}
f[a[k][cnt] + 1][j | p] = max(f[a[k][cnt] + 1][j | p], f[i][j] + 1);
}
}
cur[q[i]]++;
}
int ans = -INF;
for (int i = 1; i <= n + 1; i++) {
ans = max(ans, f[i][m]);
}
if (ans == -INF) {
return -1;
}
return ans * len + (8 - ans) * (len - 1);
}
int main() {
scanf("%d", &n);
memset(c, 0, sizeof(c));
q[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
q[i] = x;
c[x]++;
a[x][c[x]] = i;
}
mn = INF;
for (int i = 1; i <= 8; i++) {
mn = min(mn, c[i]);
}
int l = 2, r = mn + 1, mid, tmp, ans = -1;
while (l <= r) {
mid = (l + r) >> 1;
tmp = cal(mid);
if (tmp != -1) {
l = mid + 1;
ans = tmp;
} else {
r = mid - 1;
}
}
if (ans == -1) {
ans = 0;
for (int i = 1; i <= 8; i++)
if (c[i] > 0) {
ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int s[500500];
struct node {
int l;
int r;
};
struct cmp1 {
bool operator()(const node &x, const node &y) const {
if (x.r - x.l != y.r - y.l) {
return (x.r - x.l) < (y.r - y.l);
} else {
return x.r > y.r;
}
}
};
void solve() {
priority_queue<node, vector<node>, cmp1> q;
int n;
cin >> n;
int k = 1;
q.push((node){1, n});
while (!q.empty()) {
node ss = q.top();
q.pop();
int n = ss.r - ss.l + 1;
if (n % 2 == 0) {
int m = (ss.l + ss.r - 1) / 2;
s[m] = k++;
if (m - 1 >= ss.l) q.push((node){ss.l, m - 1});
if (m + 1 <= ss.r) q.push((node){m + 1, ss.r});
} else {
int m = (ss.l + ss.r) / 2;
s[m] = k++;
if (m - 1 >= ss.l) q.push((node){ss.l, m - 1});
if (m + 1 <= ss.r) q.push((node){m + 1, ss.r});
}
}
for (int i = 1; i <= n; i++) {
if (i == 1) {
printf("%d", s[i]);
} else {
printf(" %d", s[i]);
}
}
printf("\n");
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, f = 0, i, j, k, cnt = 0;
string a;
cin >> n;
cin >> a;
for (i = 0; i < n; i++) {
if (a[i] == '*') {
for (j = 1; j < n; j++) {
for (k = i, cnt = 0; k < n;) {
if (a[k] == '*') {
cnt++;
k += j;
} else
break;
if (cnt == 5) {
f = 1;
break;
}
}
if (f) break;
}
}
if (f) break;
}
if (f)
cout << "yes" << endl;
else
cout << "no" << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, w[maxn];
long long f[maxn][2];
vector<int> g[maxn];
void dfs(int u) {
f[u][1] = -(0x3f3f3f3f3f3f3f);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
dfs(v);
long long fu0 = f[u][0];
long long fu1 = f[u][1];
f[u][0] = max(fu0 + f[v][0], fu1 + f[v][1]);
f[u][1] = max(fu0 + f[v][1], fu1 + f[v][0]);
}
f[u][1] = max(f[u][1], f[u][0] + w[u]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int u;
scanf("%d%d", &u, &w[i]);
g[u].push_back(i);
}
dfs(1);
printf("%lld", max(f[1][0], f[1][1]));
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using iii = pair<int, ii>;
using vi = vector<int>;
using vii = vector<ii>;
void solve() {
ll rem, m;
cin >> rem >> m;
vector<int> boxes(m);
ll sum = 0;
for (int i = 0; i < m; i++) {
cin >> boxes[i];
sum += boxes[i];
}
if (sum < rem) {
cout << "-1\n";
return;
}
sort(boxes.begin(), boxes.end(), greater<int>());
ll power = 1;
sum = 0;
int cnt = 0;
while (rem) {
if (power & rem) {
if (sum < power) {
ll smallest = boxes.back();
if (smallest > power) {
boxes.pop_back();
boxes.push_back(smallest / 2);
boxes.push_back(smallest / 2);
cnt++;
} else {
sum += smallest;
boxes.pop_back();
}
} else {
sum -= power;
rem -= power;
}
} else
power <<= 1;
}
cout << cnt << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x[4];
int check(int x[], int a) {
for (int i = 0; i < 3; i++)
if (x[i] <= a) return false;
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < 3; i++) x[i] = m;
sort(x, x + 3);
int ret = 0;
while (!check(x, n)) {
sort(x, x + 3);
x[0] = x[1] + x[2] - 1;
ret++;
}
cout << ret << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int ctr1, ctr2, n1 = n, n2 = n;
for (ctr1 = 0; n1 % 10 != 0; ctr1++) n1--;
for (ctr2 = 0; n2 % 10 != 0; ctr2++) n2++;
if (ctr1 <= ctr2)
cout << n1 << endl;
else
cout << n2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1000000001, nn = 100010;
struct edge {
int k, f, next;
} e[nn << 1];
int cq, size, sum, tot, limited;
int n, L, R, ans = -1;
int m = 1, now[nn];
int s[nn];
bool beused[nn];
pair<int, int> p[nn], f[nn], g[nn], tempe, res;
int dl[nn];
void getsum(int i, int fa) {
++sum;
for (int j = now[i]; j; j = e[j].next)
if (!beused[e[j].k] && e[j].k != fa) getsum(e[j].k, i);
}
void getcq(int i, int fa) {
int t = 0;
s[i] = 1;
for (int j = now[i]; j; j = e[j].next)
if (!beused[e[j].k] && e[j].k != fa) {
getcq(e[j].k, i);
s[i] += s[e[j].k];
t = max(t, s[e[j].k]);
}
t = max(t, sum - s[i]);
if (t < size) {
size = t;
cq = i;
}
}
void dfs(int i, int fa, int d, int s) {
g[d] = max(g[d], make_pair(s, i));
for (int j = now[i]; j; j = e[j].next)
if (!beused[e[j].k] && e[j].k != fa)
dfs(e[j].k, i, d + 1, s + (e[j].f >= limited ? 1 : -1));
}
bool check() {
int i, j, k, l, r;
f[0].second = cq;
for (i = 1; i <= tot; ++i) {
for (j = 1; j <= p[i].first; ++j) g[j].first = -oo;
dfs(e[p[i].second].k, 0, 1, (e[p[i].second].f >= limited ? 1 : -1));
l = 1, r = 0;
for (j = 1, k = min(p[i - 1].first, R); j <= min(p[i].first, R); ++j) {
while (k >= max(L - j, 0)) {
while (l <= r && f[dl[r]] <= f[k]) --r;
dl[++r] = k--;
}
while (l <= r && j + dl[l] > R) ++l;
if (l <= r && g[j].first + f[dl[l]].first >= 0) {
tempe = make_pair(g[j].second, f[dl[l]].second);
return true;
}
}
for (j = 1; j <= p[i - 1].first; ++j) f[j] = max(f[j], g[j]);
for (; j <= p[i].first; ++j) f[j] = g[j];
}
return false;
}
void work(int i) {
sum = 0;
getsum(i, 0);
size = oo;
getcq(i, 0);
beused[cq] = 1;
tot = 0;
for (i = now[cq]; i; i = e[i].next)
if (!beused[e[i].k])
p[++tot] = make_pair(s[e[i].k] < s[cq] ? s[e[i].k] : sum - s[cq], i);
sort(p + 1, p + tot + 1);
int l = 0, r = oo;
while (l < r) {
limited = (l + r) >> 1;
if (check())
l = limited + 1;
else
r = limited;
}
if (ans < l - 1) {
ans = limited = l - 1;
check();
res = tempe;
}
for (i = now[cq]; i; i = e[i].next)
if (!beused[e[i].k]) work(e[i].k);
}
int main() {
int i, u, v, w;
scanf("%d%d%d", &n, &L, &R);
for (i = 1; i < n; ++i) {
scanf("%d%d%d", &u, &v, &w);
++m;
e[m].k = v;
e[m].f = w;
e[m].next = now[u];
now[u] = m;
++m;
e[m].k = u;
e[m].f = w;
e[m].next = now[v];
now[v] = m;
}
work(1);
printf("%d %d\n", res.first, res.second);
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (!b) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a / gcd(a, b)) * b;
}
long long int modexp(long long int a, long long int b) {
if (b == 0) return 1;
if (b == 1) return a;
long long int temp = modexp(a, (b >> 1));
temp = (temp * temp);
return (temp * modexp(a, b & 1));
}
long long int modexp(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int temp = modexp(a, (b >> 1), m);
temp = (temp * temp) % m;
return (temp * modexp(a, b & 1, m)) % m;
}
long long int mult(long long int a, long long int b, long long int m) {
long long int res = 0;
a %= m;
while (b) {
if (b & 1ll) res = (res + a) % m;
a = (a * 2ll) % m;
b /= 2ll;
}
return (res % m);
}
long long int modinv(long long int a, long long int p) {
return modexp(a, p - 2, p);
}
int main() {
long long int n, m, ans;
scanf("%lld%lld", &n, &m);
long long int a = min(n, m), b = max(n, m);
if (a > 2 and b > 2) {
ans = a * b;
if (ans % 2 == 1) ans--;
} else if (a == 2) {
if (b < 3)
ans = 0;
else if (b == 3 || b == 7)
ans = 2 * b - 2;
else
ans = 2 * b;
} else if (a == 1) {
if (b < 4)
ans = 0;
else {
long long int b1, b2, b3;
b1 = (b + 2) / 3, b2 = (b + 1) / 3, b3 = b / 3;
ans = b1 + b2 + b3;
if (b1 % 2 == 1) ans--;
if (b2 % 2 == 1) ans--;
if (b3 % 2 == 1) ans--;
}
}
printf("%lld\n", ans);
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10, M = 1e7 + 10;
int n, m, k;
int last[M];
struct node {
int n;
int t;
} shop[N];
long long s[M];
int ans[N], nans;
int maxt;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
int t;
cin >> t;
maxt = max(maxt, t + 1);
s[t + 1]++;
}
for (int i = 1; i <= m; i++) {
cin >> shop[i].t;
shop[i].t++;
maxt = max(maxt, shop[i].t);
shop[i].n = last[shop[i].t];
last[shop[i].t] = i;
}
for (int i = 1; i <= maxt; i++) {
s[i] = s[i - 1] + k - s[i];
if (s[i] < 0) {
cout << "-1" << endl;
return 0;
}
}
long long maxl = s[maxt];
for (int i = maxt; i >= 1; i--) {
maxl = min(maxl, s[i]);
for (int j = last[i]; j > 0 && maxl > 0; j = shop[j].n) {
ans[++nans] = j;
maxl--;
}
}
cout << nans << endl;
for (int i = 1; i <= nans; i++) cout << ans[i] << " ";
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int n, p;
cin >> n >> p;
long long int total = 0, a = 0;
vector<string> ar;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
ar.push_back(s);
}
for (int i = n - 1; i >= 0; i--) {
a *= 2;
if (ar[i].size() == 8) {
a++;
}
total += a * (p / 2);
}
cout << total << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool com(string a, string b) {
if (a.size() > b.size()) return false;
return true;
}
int main() {
int n, m;
cin >> n >> m;
int b, g;
cin >> b;
int boys[n];
int ind;
memset(boys, -1, sizeof boys);
for (int i = 0; i < b; i++) {
cin >> ind;
boys[ind] = 1;
}
cin >> g;
int girls[m];
memset(girls, -1, sizeof girls);
for (int i = 0; i < g; i++) {
cin >> ind;
girls[ind] = 1;
}
int days = n * m * n * m;
for (int i = 0; i < days; i++) {
if (boys[i % n] == 1 || girls[i % m] == 1)
boys[i % n] = 1, girls[i % m] = 1;
}
for (int i = 0; i < n; i++)
if (boys[i] == -1) {
cout << "No";
return 0;
}
for (int i = 0; i < m; i++)
if (girls[i] == -1) {
cout << "No";
return 0;
}
cout << "Yes";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
const int inf = 0x3f3f3f3f;
int main() {
int n, k;
cin >> n >> k;
vector<long long> a(k + 1);
for (int i = 1; i <= k; i++) cin >> a[i];
vector<bool> is_alive(n + 1, true);
int alive = n;
int leader = 1;
for (int i = 1; i <= k; i++) {
a[i] %= alive;
int cnt = 0, j;
for (j = leader; cnt < a[i]; j++) {
if (j == n + 1) j = 1;
if (is_alive[j]) cnt++;
}
if (j == n + 1) j = 1;
while (!is_alive[j]) {
j++;
if (j == n + 1) j = 1;
}
is_alive[j] = false;
alive--;
cout << j << " ";
leader = j + 1;
if (leader == n + 1) leader = 1;
while (!is_alive[leader]) leader++;
}
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.