solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000 + 7;
int gcd(int x, int y) {
if (!x || !y) return x + y;
while ((x %= y) && (y %= x))
;
return x + y;
}
bool check(int x, int y, int z) {
vector<int> v = {x, y, z};
sort(v.begin(), v.end());
do {
if ((v[0] & 1) && (v[1] & 2) && (v[2] & 4)) return 1;
} while (next_permutation(v.begin(), v.end()));
return 0;
}
long long comb(int n, int m) {
long long res = 1;
for (int i = 1; i <= m; i++) res = res * (n - i + 1) / i;
return res;
}
int dp[MAX_N];
int main() {
for (int i = 1; i < MAX_N; i++) {
for (int j = i; j < MAX_N; j += i) dp[j]++;
}
int T;
scanf("%d", &T);
while (T--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
int ab = gcd(a, b);
int ac = gcd(a, c);
int bc = gcd(b, c);
int abc = gcd(a, bc);
int cnt[8] = {0};
cnt[7] = dp[abc];
cnt[6] = dp[bc] - dp[abc];
cnt[5] = dp[ac] - dp[abc];
cnt[4] = dp[c] - dp[ac] - dp[bc] + dp[abc];
cnt[3] = dp[ab] - dp[abc];
cnt[2] = dp[b] - dp[ab] - dp[bc] + dp[abc];
cnt[1] = dp[a] - dp[ab] - dp[ac] + dp[abc];
cnt[0] = 0;
long long ans = 0;
for (int x = 1; x < 8; x++) {
for (int y = x; y < 8; y++) {
for (int z = y; z < 8; z++) {
if (!check(x, y, z)) continue;
int cnt2[8] = {0};
cnt2[x]++;
cnt2[y]++;
cnt2[z]++;
long long t = 1;
for (int i = 1; i < 8; i++) {
if (cnt2[i]) t *= comb(cnt[i] + cnt2[i] - 1, cnt2[i]);
}
if (t) ans += t;
}
}
}
printf("%lld\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long a[N];
long long s[N];
long long gt[20];
long long n, q, m = 15;
void sub1() {
long long cur = 1;
while (q--) {
long long typ;
cin >> typ;
if (typ == 1) {
long long l, r;
cin >> l >> r;
vector<bool> flag(n + 1, 0);
for (long long i = 1, sum = 0; i <= n; i++) {
for (long long val = 1; val <= n; val++)
if (!flag[val]) {
if (sum + gt[n - i] < cur) {
sum += gt[n - i];
} else {
a[i] = val;
flag[val] = true;
break;
}
}
}
long long sum = 0;
for (long long i = l; i <= r; i++) {
sum += a[i];
}
cout << sum << "\n";
} else {
long long x;
cin >> x;
cur += x;
}
}
}
void sub2() {
vector<long long> val(0);
long long lim = n - m;
for (long long i = lim + 1; i <= n; i++) {
val.push_back(i);
}
for (long long i = 1; i <= n - m + 1; i++) {
s[i] = s[i - 1] + i;
}
long long cur = 1;
while (q--) {
long long typ;
cin >> typ;
if (typ == 1) {
long long l, r;
cin >> l >> r;
vector<bool> flag(m, 0);
for (long long i = 1, sum = 0; i <= m; i++) {
for (long long j = 0; j < m; j++)
if (!flag[j]) {
if (sum + gt[m - i] < cur) {
sum += gt[m - i];
} else {
a[lim + i] = val[j];
flag[j] = true;
break;
}
}
}
long long sum = 0;
if (l <= lim) sum += s[lim] - s[l - 1];
if (r <= lim) sum -= s[lim] - s[r];
for (long long i = max(lim + 1, l); i <= r; i++) {
sum += a[i];
}
cout << sum << "\n";
} else {
long long x;
cin >> x;
cur += x;
}
}
}
void proc() {
gt[0] = 1;
for (long long i = 1; i <= 15; i++) {
gt[i] = gt[i - 1] * i;
}
if (n <= 15)
sub1();
else
sub2();
}
void enter() { cin >> n >> q; }
void preproc() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
signed main() {
preproc();
enter();
proc();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int F(long long int a) {
long long int i = 1;
for (; i * (i - 1) < 2 * a; i++)
;
if (i * (i - 1) != 2 * a)
return -1;
else
return i;
}
int main() {
long long int a, b, c, d;
while (scanf("%I64d%I64d%I64d%I64d", &a, &b, &c, &d) == 4) {
long long int x = F(a), y = F(d);
if (a == 0) {
if (b == 0 && c == 0)
x = 0;
else
x = 1;
}
if (d == 0) {
if (b == 0 && c == 0)
y = 0;
else
y = 1;
}
if (x == -1 || y == -1)
puts("Impossible");
else if (b + c != x * y)
puts("Impossible");
else if (x + y > 1000000)
puts("Impossible");
else if (!a && !b && !c && !d)
puts("0");
else {
long long int i = 0, j = 0;
for (; i < x; i++) {
while (c >= x - i && j < y) printf("1"), c -= (x - i), j++;
printf("0");
}
for (; j < y; j++) printf("1");
puts("");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int n, f[N], cnt;
double a[N], b[N];
struct node {
int l, r;
double sum;
};
double qs(node c) { return c.sum * (c.r - c.l + 1); }
stack<node> s;
void update(int x) {
node q = (node){s.top().l, x, (qs(s.top()) + a[x]) / (x - s.top().l + 1)};
s.pop();
while (!s.empty() && q.sum < s.top().sum) {
node w = s.top();
s.pop();
q.sum = ((qs(q) + qs(w)) / (q.r - w.l + 1));
q.l = w.l;
}
s.push(q);
return;
}
void print() {
while (!s.empty()) {
node wz = s.top();
s.pop();
for (int i = wz.l; i <= wz.r; i++) {
b[i] = wz.sum;
}
}
for (int i = 1; i <= n; i++) {
printf("%.9lf\n", b[i]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lf", &a[i]);
}
s.push((node){1, 1, a[1]});
for (int i = 2; i <= n; i++) {
if (a[i] > s.top().sum)
s.push((node){i, i, a[i]});
else
update(i);
}
print();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int N, M, res;
int main() {
cin >> N >> M;
for (int i = 1; i <= N; i++) res += (M + i % 5) / 5;
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
bool mark[2 * maxn];
struct Node {
set<int> s;
int ma, mi;
Node *ls, *rs;
Node(int l, int r) {
ls = rs = nullptr;
ma = mi = -1;
s.clear();
if (l + 1 == r) return;
ls = new Node(l, (l + r) >> 1);
rs = new Node((l + r) >> 1, r);
}
~Node() {
if (ls != nullptr) delete ls;
if (rs != nullptr) delete rs;
}
void update() {
ma = mi = -1;
if (ls == nullptr && rs == nullptr) {
if (!s.empty()) {
ma = *s.rbegin(), mi = *s.rbegin();
if (mark[ma]) ma = -1;
}
} else {
ma = max(ls->ma, rs->ma), mi = min(ls->mi, rs->mi);
if (!s.empty() && ma < *s.rbegin()) {
ma = *s.rbegin();
if (ma < mi || mark[ma]) ma = -1;
}
if (!s.empty()) mi = max(mi, *s.rbegin());
}
}
void insert(int l, int r, int L, int R, int c, bool f) {
if (r <= L || R <= l)
return;
else if (L <= l && r <= R) {
if (f)
s.insert(c);
else
s.erase(c);
update();
} else {
ls->insert(l, (l + r) >> 1, L, R, c, f);
rs->insert((l + r) >> 1, r, L, R, c, f);
update();
}
}
void Update(int l, int r, int L, int R, int c) {
if (r <= L || R <= l)
return;
else if (L <= l && r <= R)
update();
else {
ls->Update(l, (l + r) >> 1, L, R, c);
rs->Update((l + r) >> 1, r, L, R, c);
update();
}
}
void debug(int l, int r) {
cout << l << " " << r << " : " << ma << " " << mi << endl;
for (auto it : s) cout << it << " ";
cout << endl;
if (l + 1 == r) return;
ls->debug(l, (l + r) >> 1);
rs->debug((l + r) >> 1, r);
}
};
int l[maxn], r[maxn], d[maxn], u[maxn], n;
int x[maxn * 2], x_n, y[maxn * 2], y_n;
struct Event {
int d, u, c;
bool f;
};
vector<Event> eve[2 * maxn];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> d[i] >> r[i] >> u[i];
x[++x_n] = l[i];
x[++x_n] = r[i];
y[++y_n] = d[i];
y[++y_n] = u[i];
}
sort(x + 1, x + x_n + 1);
sort(y + 1, y + y_n + 1);
x_n = unique(x + 1, x + x_n + 1) - x - 1;
y_n = unique(y + 1, y + y_n + 1) - y - 1;
for (int i = 1; i <= n; i++) {
l[i] = lower_bound(x + 1, x + x_n + 1, l[i]) - x;
r[i] = lower_bound(x + 1, x + x_n + 1, r[i]) - x;
d[i] = lower_bound(y + 1, y + y_n + 1, d[i]) - y;
u[i] = lower_bound(y + 1, y + y_n + 1, u[i]) - y;
eve[l[i]].push_back({d[i], u[i], i, 1});
eve[r[i]].push_back({d[i], u[i], i, 0});
}
int M = y_n;
Node *SegTree = new Node(1, M);
for (int i = 1; i <= x_n; i++) {
for (auto e : eve[i]) {
SegTree->insert(1, M, e.d, e.u, e.c, e.f);
}
while (SegTree->ma != -1) {
mark[SegTree->ma] = 1;
SegTree->Update(1, M, d[SegTree->ma], u[SegTree->ma], SegTree->ma);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += mark[i];
cout << ans + 1 << endl;
}
| 12 |
#include <bits/stdc++.h>
const int INF = (int)(1e9);
const long long INFLL = (long long)(1e18);
const double EPS = 1e-13;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int w, h;
cin >> w >> h;
long long ans = 0;
for (int i = 2; i <= w; i += 2) {
for (int j = 2; j <= h; j += 2) ans = ans + (w - i + 1) * (h - j + 1);
}
cout << ans << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
queue<int> q;
set<int> vals;
for (int i = 0; i < n; ++i) {
int id;
cin >> id;
if (!vals.count(id)) {
if (int(q.size()) >= k) {
int curr = q.front();
q.pop();
vals.erase(curr);
}
vals.insert(id);
q.push(id);
}
}
vector<int> ans;
while (!q.empty()) {
ans.push_back(q.front());
q.pop();
}
reverse(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (auto &item : ans) cout << item << " ";
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, f[120][120][2];
struct node {
int xb, fw;
bool operator<(const node p) const { return xb < p.xb; }
} a[120];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].xb, &a[i].fw);
sort(a + 1, a + n + 1);
a[0].xb = -2e9;
a[++n].xb = 2e9;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++)
for (int k = 0; k <= 1; k++) {
ans = ((ans) > (f[i][j][k]) ? (ans) : (f[i][j][k]));
int mx = -1, x = 0, y = 0, tmp1 = a[j].xb + a[j].fw * k;
if (i < n && a[i + 1].xb + a[i + 1].fw > tmp1)
f[i + 1][i + 1][1] =
((f[i + 1][i + 1][1]) >
(f[i][j][k] +
((a[i + 1].fw) < (a[i + 1].xb + a[i + 1].fw - tmp1)
? (a[i + 1].fw)
: (a[i + 1].xb + a[i + 1].fw - tmp1)))
? (f[i + 1][i + 1][1])
: (f[i][j][k] +
((a[i + 1].fw) < (a[i + 1].xb + a[i + 1].fw - tmp1)
? (a[i + 1].fw)
: (a[i + 1].xb + a[i + 1].fw - tmp1))));
if (i < n && a[i + 1].xb > tmp1)
f[i + 1][i + 1][0] =
((f[i + 1][i + 1][0]) >
(f[i][j][k] + ((a[i + 1].fw) < (a[i + 1].xb - tmp1)
? (a[i + 1].fw)
: (a[i + 1].xb - tmp1)))
? (f[i + 1][i + 1][0])
: (f[i][j][k] + ((a[i + 1].fw) < (a[i + 1].xb - tmp1)
? (a[i + 1].fw)
: (a[i + 1].xb - tmp1))));
f[i + 1][j][k] =
((f[i + 1][j][k]) > (f[i][j][k]) ? (f[i + 1][j][k]) : (f[i][j][k]));
for (int l = i + 1; l <= n; l++)
for (int t = 0; t <= 1; t++) {
int tmp2 = a[l].xb + a[l].fw * t;
if (mx < tmp2) {
mx = tmp2;
x = l;
y = t;
}
if (t == 0)
f[l][x][y] =
((f[l][x][y]) > (f[i][j][k] + mx - tmp2 +
((a[l].fw) < (tmp2 - tmp1) ? (a[l].fw)
: (tmp2 - tmp1)))
? (f[l][x][y])
: (f[i][j][k] + mx - tmp2 +
((a[l].fw) < (tmp2 - tmp1) ? (a[l].fw)
: (tmp2 - tmp1))));
}
}
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int matr[500][500];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
for (int j = 0; j < n; j++) matr[i][j] = s[j];
}
int z = 0;
int r = matr[0][0];
if (n > 1) z = matr[0][1];
if (z == r) {
cout << "NO";
return 0;
}
for (int i = 0; i < n; i++) {
if (matr[i][i] != r) {
cout << "NO";
return 0;
}
matr[i][i] = z;
}
for (int i = 0; i < n; i++) {
if (matr[i][n - 1 - i] != r && (n - 1 - i) != i) {
cout << "NO";
return 0;
}
matr[i][n - 1 - i] = z;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (matr[i][j] != z) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
enum { LEFT, RIGHT, BOTH };
const int INF = INT_MAX >> 1;
std::string virus, s1, s2;
std::vector<int> failure;
int solution[105][105][105];
bool solved[105][105][105];
int next[105][105][105];
void fill_failure(void) {
int candidate, pos;
failure.clear();
failure.resize(virus.size());
pos = 2;
candidate = 0;
failure[1] = 0;
failure[0] = -1;
while (pos < virus.size()) {
if (virus[pos - 1] == virus[candidate]) {
failure[pos++] = ++candidate;
} else if (candidate > 0) {
candidate = failure[candidate];
} else {
failure[pos++] = 0;
}
}
}
int longest_match(const int pos_s1, const int pos_s2, const int pos_v) {
int aux;
int& step = next[pos_s1][pos_s2][pos_v];
bool& seen = solved[pos_s1][pos_s2][pos_v];
int& best = solution[pos_s1][pos_s2][pos_v];
if (seen++) {
return best;
}
if (pos_v == virus.size()) {
return best = -INF;
}
if (pos_s1 == s1.size() || pos_s2 == s2.size()) {
return best = 0;
}
best = -INF;
if (s1[pos_s1] == s2[pos_s2]) {
aux = pos_v;
while (aux != -1 && virus[aux] != s1[pos_s1]) {
aux = failure[aux];
}
if ((aux = 1 + longest_match(pos_s1 + 1, pos_s2 + 1, aux + 1)) > best) {
best = aux;
step = BOTH;
}
}
if ((aux = longest_match(pos_s1 + 1, pos_s2, pos_v)) > best) {
best = aux;
step = LEFT;
}
if ((aux = longest_match(pos_s1, pos_s2 + 1, pos_v)) > best) {
best = aux;
step = RIGHT;
}
return best;
}
int main(void) {
int pos_s1, pos_s2, pos_v, best;
std::string result;
std::cin.tie(0);
std::ios_base::sync_with_stdio(0);
std::cin >> s1 >> s2 >> virus;
fill_failure();
best = longest_match(0, 0, 0);
if (best <= 0) {
std::cout << 0 << std::endl;
} else {
pos_s1 = pos_s2 = pos_v = 0;
while (pos_s1 != s1.size() && pos_s2 != s2.size()) {
if (next[pos_s1][pos_s2][pos_v] == LEFT) {
++pos_s1;
} else if (next[pos_s1][pos_s2][pos_v] == RIGHT) {
++pos_s2;
} else {
result += s1[pos_s1];
while (pos_v != -1 && virus[pos_v] != s1[pos_s1]) {
pos_v = failure[pos_v];
}
++pos_v;
++pos_s1;
++pos_s2;
}
}
std::cout << result << std::endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55, M = 105, T = 40005;
const double pi = acos(-1.0);
int n, m, t, x;
int d[N][N], a[M], b[M], c[M];
double p[M][T], f[N][T], g[M][T];
struct cmplx {
double x, y;
cmplx(double xx = 0, double yy = 0) { x = xx, y = yy; }
};
cmplx operator+(cmplx &a, cmplx &b) { return cmplx(a.x + b.x, a.y + b.y); }
cmplx operator-(cmplx &a, cmplx &b) { return cmplx(a.x - b.x, a.y - b.y); }
cmplx operator*(cmplx &a, cmplx &b) {
return cmplx(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
}
struct FFT {
cmplx a[T << 2], b[T << 2];
int n, m, bit = 2, rev[T << 2];
inline void get_rev() {
for (int i = 0; i < bit; i++)
rev[i] = (rev[i >> 1] >> 1) | (bit >> 1) * (i & 1);
}
inline void fft(cmplx *a, int dft) {
for (int i = 0; i < bit; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int i = 1; i < bit; i <<= 1) {
cmplx W(cos(pi / i), dft * sin(pi / i));
for (int j = 0; j < bit; j += i << 1) {
cmplx w(1, 0);
for (int k = j; k < i + j; k++, w = w * W) {
cmplx x = a[k], y = w * a[k + i];
a[k] = x + y, a[k + i] = x - y;
}
}
}
if (dft == -1)
for (int i = 0; i < bit; i++) a[i].x /= bit;
}
inline void init(int x, int y) {
n = x, m = y;
bit = 2;
while (bit <= n + m) bit <<= 1;
for (int i = 0; i < bit; i++) a[i] = cmplx(0, 0), b[i] = cmplx(0, 0);
}
inline void mul() {
get_rev();
fft(a, 1);
fft(b, 1);
for (int i = 0; i < bit; i++) a[i] = a[i] * b[i];
fft(a, -1);
}
} F;
inline void solve(int l, int r) {
if (l == t) return;
if (l == r) {
for (int i = 1; i < n; i++) f[i][l] = 1e18;
for (int i = 1; i <= m; i++)
if (a[i] != n) {
f[a[i]][l] = min(f[a[i]][l], g[i][l] + c[i]);
}
return;
}
int mid = (l + r) >> 1;
solve(mid + 1, r);
for (int i = 1; i <= m; i++)
if (a[i] != n) {
F.init(r - l - 1, r - mid - 1);
for (int j = 0; j <= F.n; j++) F.a[j] = cmplx(p[i][j + 1], 0);
for (int j = 0; j <= F.m; j++) F.b[j] = cmplx(f[b[i]][r - j], 0);
F.mul();
for (int j = l; j <= mid; j++) g[i][j] += F.a[r - j - 1].x;
}
solve(l, mid);
}
int main() {
scanf("%d%d%d%d", &n, &m, &t, &x);
memset(d, 0x3f, sizeof(d));
for (int i = 1; i <= n; i++) d[i][i] = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
d[a[i]][b[i]] = c[i];
for (int j = 1, x; j <= t; j++) scanf("%d", &x), p[i][j] = x / 1e5;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
for (int i = 1; i < n; i++)
for (int j = t; j < 2 * t; j++) {
f[i][j] = d[i][n] + x;
}
for (int i = 1; i < 2 * t; i++) f[n][i] = (i <= t ? 0 : x);
solve(0, 2 * t - 1);
printf("%.8lf", f[1][0]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, k;
cin >> n >> k;
long long int arr[205] = {0};
long long int map1[205] = {0};
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
map1[arr[i]] = 1;
}
long long int ans = 0;
for (long long int i = 1; i < 204; i++) {
if (map1[i] == 0) k--;
if (k == 0) {
ans = i;
break;
}
}
for (long long int j = ans; j < 204; j++) {
if (map1[j + 1] == 1)
ans++;
else
break;
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[111][111];
int main() {
int n, m, d;
while (cin >> n >> m >> d) {
int s = 0x7fffffff, t = -0x7fffffff;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
s = s < a[i][j] ? s : a[i][j];
t = t > a[i][j] ? t : a[i][j];
}
}
int ans = 0x7fffffff;
for (int k = s; k <= t; k += d) {
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (abs((a[i][j] - k) % d)) {
goto end;
}
cnt += abs(a[i][j] - k) / d;
}
}
ans = ans < cnt ? ans : cnt;
}
end:;
if (ans == 0x7fffffff)
cout << -1 << endl;
else
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
int print_value(A title, B val) {
cout << title << " = " << val << "\n";
return 1;
}
int break_point() {
char c;
while ((c = getchar()) != '\n')
;
return 0;
}
template <typename A>
int logg(A v) {
cout << v << "\n";
return 0;
}
template <typename T>
void read_integer(T &r) {
bool sign = 0;
r = 0;
char c;
while (1) {
c = getchar();
if (c == '-') {
sign = 1;
break;
}
if (c != ' ' && c != '\n') {
r = c - '0';
break;
}
}
while (1) {
c = getchar();
if (c == ' ' || c == '\n') break;
r = r * 10 + (c - '0');
}
if (sign) r = -r;
}
void run();
int main() {
srand(time(NULL));
do {
run();
if (0) {
0 ? printf("-------------------------------\n") : 0;
0 ? printf("-------------------------------\n") : 0;
}
} while (0);
return 0;
}
const int mod = 1e9 + 7;
int cnt[200005];
long long p[200005], s[200005];
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long c = binpow(a, b >> 1);
if (b & 1) return (((c * c) % mod) * a) % mod;
return (c * c) % mod;
}
void run() {
int n;
scanf("%d", &n);
int t;
for (int i = 0; i < n; i++) {
scanf("%d", &t);
cnt[t]++;
}
p[1] = 1;
for (int i = 2; i < 200001; i++) {
p[i] = cnt[i] + 1;
p[i] *= p[i - 1];
p[i] %= (mod - 1);
}
s[200001] = 1;
for (int i = 200000; i > 1; i--) {
s[i] = cnt[i] + 1;
s[i] *= s[i + 1];
s[i] %= (mod - 1);
}
long long res = 1;
for (int i = 2; i < 200001; i++) {
if (cnt[i]) {
long long degree = 1ll * (1 + cnt[i]) * cnt[i] / 2;
long long v = binpow(i, degree);
v = binpow(v, (p[i - 1] * s[i + 1]) % (mod - 1));
res *= v;
res %= mod;
}
}
printf(0 ? "%lld" : "%I64d", res);
putchar('\n');
}
| 6 |
#include <bits/stdc++.h>
int main() {
int n, x1, x2, i, j;
scanf("%d", &n);
x1 = n % 10;
x2 = n / 10;
if (x1 == 0)
i = 2;
else if (x1 == 1)
i = 7;
else if (x1 == 2)
i = 2;
else if (x1 == 3)
i = 3;
else if (x1 == 4)
i = 3;
else if (x1 == 5)
i = 4;
else if (x1 == 6)
i = 2;
else if (x1 == 7)
i = 5;
else if (x1 == 8)
i = 1;
else
i = 2;
if (x2 == 0)
j = 2;
else if (x2 == 1)
j = 7;
else if (x2 == 2)
j = 2;
else if (x2 == 3)
j = 3;
else if (x2 == 4)
j = 3;
else if (x2 == 5)
j = 4;
else if (x2 == 6)
j = 2;
else if (x2 == 7)
j = 5;
else if (x2 == 8)
j = 1;
else
j = 2;
printf("%d", i * j);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 12;
const int X[] = {0, 1, 0, -1, 0, 0};
const int Y[] = {1, 0, -1, 0, 0, 0};
const int Z[] = {0, 0, 0, 0, 1, -1};
struct coord {
int x, y, z;
};
char layers[MAXN][MAXN][MAXN];
bool done[MAXN][MAXN][MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
;
int k, n, m;
cin >> k >> n >> m;
for (int l = 0; l < int(k); l++)
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(m); j++) cin >> layers[l][i][j];
pair<int, int> st;
cin >> st.first >> st.second;
st.first--, st.second--;
queue<coord> Q;
Q.push({st.second, st.first, 0});
done[0][st.first][st.second] = true;
int cnt = 0;
while (!Q.empty()) {
auto e = Q.front();
Q.pop();
cnt++;
for (int o = 0; o < int(6); o++) {
int tX = e.x + X[o], tY = e.y + Y[o], tZ = e.z + Z[o];
if (tX < 0 || tY < 0 || tZ < 0 || tX >= m || tY >= n || tZ >= k) continue;
if (done[tZ][tY][tX] || layers[tZ][tY][tX] == '#') continue;
done[tZ][tY][tX] = true;
Q.push({tX, tY, tZ});
}
}
cout << cnt;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a, i, j;
string s;
cin >> n >> k >> s;
for (i = 0; s[i] != 'G'; i++)
;
for (j = 0; s[j] != 'T'; j++)
;
for (a = min(i, j); a < max(i, j); a += k)
if (s[a] == '#') break;
if (a == max(i, j)) {
cout << "YES";
} else {
cout << "NO";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
ifstream fin("in.in");
ofstream fout("out.out");
struct muchie {
int node, weight, degree;
bool operator<(const muchie &other) const { return weight < other.weight; }
muchie(int a, int b, int c) {
node = a;
weight = b;
degree = c;
}
};
vector<muchie> out[200005], in[200005];
int q[10][10], illegal[10][10][10][10], st[10], t, n, ans, m, k, cant[10][10],
OutDegree[200005], pre[200005][10];
void allperms(int poz) {
if (poz > k) {
ans++;
return;
}
for (int ToNode = 1; ToNode <= poz; ToNode++) {
if (cant[poz][ToNode]) continue;
bool ok = 1;
for (int j = 1; j <= poz - 1; j++) {
if (illegal[j][st[j]][poz][ToNode]) {
ok = 0;
break;
}
}
if (ok) {
st[poz] = ToNode;
allperms(poz + 1);
}
}
}
void Clear_q(int q[10][10]) {
for (int i = 0; i < 10; i++)
for (int j = 0; j < 10; j++) q[i][j] = 0;
}
int main() {
int i, j, node;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
out[u].push_back({v, w, 0});
}
for (i = 1; i <= n; i++) sort(out[i].begin(), out[i].end());
for (i = 1; i <= n; i++) {
for (j = 0; j < out[i].size(); j++) out[i][j].degree = j + 1;
}
for (i = 1; i <= n; i++) {
for (auto k : out[i]) {
in[k.node].push_back({i, k.weight, k.degree});
}
}
for (i = 1; i <= n; i++) OutDegree[i] = out[i].size();
for (node = 1; node <= n; node++) {
Clear_q(q);
vector<pair<int, int>> v;
for (i = 0; i < in[node].size(); i++) {
int node1 = in[node][i].node;
int a = OutDegree[node1];
int b = in[node][i].degree;
if (q[a][b] == 0) {
q[a][b] = 1;
v.push_back({a, b});
} else
cant[a][b] = true;
}
for (i = 0; i < v.size(); i++) {
for (j = 0; j < v.size(); j++) {
if (i == j) continue;
illegal[v[i].first][v[i].second][v[j].first][v[j].second] = true;
}
}
}
allperms(1);
cout << ans << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void err() { cout << '\n'; }
template <typename T, typename... More>
void err(T arg, More... more) {
cout << arg << ' ';
err(more...);
}
const long long mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> arr(26);
for (char c : s) {
arr[c - 'A']++;
}
int mn = 1e6;
for (__typeof(k) i = (0) - (0 > k); i != (k) - (0 > k);
i += 1 - 2 * (0 > k)) {
mn = min(mn, arr[i]);
}
cout << k * mn << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 250000;
int n, s[kMaxN * 2 + 1], t[kMaxN * 2 + 1];
namespace st {
const int kMaxM = kMaxN * 2;
int dp[19][kMaxM + 1], m, log2[kMaxM + 1];
void Init() {
m = n * 2;
log2[1] = 0;
for (int i = 2; i <= m; ++i) {
log2[i] = log2[i - 1];
if ((i & (i - 1)) == 0) ++log2[i];
}
int r = log2[m] + 1;
for (int i = 1; i <= m; ++i) dp[0][i] = i;
for (int j = 1; j < r; ++j)
for (int i = 1; i <= m; ++i) {
dp[j][i] = dp[j - 1][i];
if (i + (1 << (j - 1)) <= m &&
t[dp[j - 1][i + (1 << (j - 1))]] < t[dp[j][i]])
dp[j][i] = dp[j - 1][i + (1 << (j - 1))];
}
}
int Query(int l, int r) {
int s = log2[r - l + 1];
return (t[dp[s][l]] < t[dp[s][r - (1 << s) + 1]] ? dp[s][l]
: dp[s][r - (1 << s) + 1]);
}
} // namespace st
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &s[i]);
s[i] = min(s[i], n - 1);
s[i + n] = s[i];
}
for (int i = 1; i <= n * 2; ++i) t[i] = i - s[i];
long long ans = 0;
st::Init();
for (int i = 1; i <= n; ++i) {
int pos = i + n, req = i + 1;
while (true) {
int lb = pos - s[pos], rb = pos;
if (lb <= req) {
++ans;
break;
}
++ans;
pos = st::Query(lb, rb);
}
}
printf("%I64d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<pair<string, string>> lang(m);
for (int i = 0; i < m; i++) {
cin >> lang[i].first >> lang[i].second;
if (lang[i].first.size() > lang[i].second.size()) {
swap(lang[i].first, lang[i].second);
}
}
vector<string> out;
for (int i = 0; i < n; i++) {
string inp;
cin >> inp;
for (int i = 0; i < m; i++) {
if (inp == lang[i].second) {
inp = lang[i].first;
}
}
out.push_back(inp);
}
for (auto i : out) {
cout << i << " ";
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int sed = 10;
char a[1000005];
int s[1000005], l;
int bas[1000005], inv[1000005];
int sum[1000005], len1, len2, len3, pos1, pos2, pos3;
int qmi(int a, int b) {
int ans = 1;
while (b) {
if (b % 2) ans = 1ll * ans * a % 1000000007;
a = 1ll * a * a % 1000000007;
b /= 2;
}
return ans;
}
bool check(int pos1, int pos2, int pos3) {
int start1 = pos2 - 1, start2 = pos3 - 1, start3 = l - 1;
int now = 0;
while (start3 >= pos3) {
int s1 = start1 < pos1 ? 0 : s[start1];
int s2 = start2 < pos2 ? 0 : s[start2];
int s3 = s[start3];
if ((s1 + s2 + now) % 10 != s3) return false;
now = (s1 + s2 + now) / 10;
start1--;
start2--;
start3--;
}
if (now == 0) {
for (int i = pos1; i < pos2; i++) printf("%c", a[i]);
printf("+");
for (int i = pos2; i < pos3; i++) printf("%c", a[i]);
printf("=");
for (int i = pos3; i < l; i++) printf("%c", a[i]);
printf("\n");
return true;
}
return false;
}
bool judge(int pos1, int pos2, int pos3) {
if (pos1 < 0 || pos2 < 0 || (pos2 - pos1 > 1 && !s[pos1]) ||
(pos3 - pos2 > 1 && !s[pos2]) || (l - pos3 > 1 && !s[pos3]))
return 0;
int s1 = 1ll * ((sum[pos1] - sum[pos2]) % 1000000007 + 1000000007) *
inv[l - pos2] % 1000000007;
int s2 = 1ll * ((sum[pos2] - sum[pos3]) % 1000000007 + 1000000007) *
inv[l - pos3] % 1000000007;
int s3 = sum[pos3];
if ((s1 + s2) % 1000000007 == s3 && check(pos1, pos2, pos3)) return 1;
return 0;
}
int main() {
scanf("%s", a);
l = strlen(a);
bas[0] = 1;
for (int i = 1; i < l; i++) bas[i] = 1ll * bas[i - 1] * sed % 1000000007;
for (int i = 0; i < l; i++) inv[i] = qmi(bas[i], 1000000007 - 2);
for (int i = 0; i < l; i++) s[i] = a[i] - '0';
sum[l] = 0;
for (int i = l - 1; i >= 0; i--)
sum[i] = (sum[i + 1] + 1ll * s[i] * bas[l - i - 1]) % 1000000007;
for (int i = 0; i < l; i++) {
len3 = l - i;
pos3 = i;
len2 = len3;
pos2 = pos3 - len2;
len1 = l - len2 - len3;
pos1 = pos2 - len1;
if (len1 >= 1 && len2 >= 1 && len3 >= 1 && judge(pos1, pos2, pos3))
return 0;
len2 = len3 - 1;
pos2 = pos3 - len2;
len1 = l - len2 - len3;
pos1 = pos2 - len1;
if (len1 >= 1 && len2 >= 1 && len3 >= 1 && judge(pos1, pos2, pos3))
return 0;
len2 = l - len3 * 2;
pos2 = pos3 - len2;
len1 = len3;
pos1 = pos2 - len1;
if (len1 >= 1 && len2 >= 1 && len3 >= 1 && judge(pos1, pos2, pos3))
return 0;
len2 = l - 2 * len3 + 1;
pos2 = pos3 - len2;
len1 = len3 - 1;
pos1 = pos2 - len1;
if (len1 >= 1 && len2 >= 1 && len3 >= 1 && judge(pos1, pos2, pos3))
return 0;
}
}
| 7 |
#include <bits/stdc++.h>
#define all(x) x.begin(),x.end()
#define FOR(i,a,b) for( int i=(a); i<(b); ++i)
#define REP(i,a,b) for( int i=(a); i<=(b); ++i)
#define MOD 1000000007
#define mp(x,y) make_pair(x,y);
#define mem(a,val) memset(a,val,sizeof(a))
#define pb push_back
#define sz(x) (int(x.size()))
#define endl '\n'
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
typedef vector<int> VI;
inline void YES() { cout << "YES" << endl;}
inline void NO() { cout << "NO" << endl;}
const int maxn = 100005;
void solve(){
int n; cin >> n;
ll ans = 0;
unordered_map<int,ll> tot;
for(int i = 0; i < n; i++){
int val; cin >> val;
ans += tot[val] * (n-i);
tot[val] += i+1;
}
cout << ans << endl;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("Standard/in.dat","r",stdin);
freopen("Standard/out.dat","w",stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
cin >> T;
while(T--){
solve();
}
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
using ll = long long;
const ll mod = 1e9 + 7;
const int maxn = 1e6 + 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll s, x;
cin >> s >> x;
if (x > s) out(0);
ll diff = s - x;
if (diff & 1) out(0);
diff /= 2;
if (diff & x) out(0);
ll res = 1;
for (ll i = 0; i < 61; i++) {
if (x & (1LL << i)) {
res = res * 2;
}
}
if (s == x) res -= 2;
out(res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[10001];
bool Ok(int n) {
for (int i = 0; i < n; i++) {
if (!a[i]) return false;
}
return true;
}
int main() {
int n, m, c;
cin >> n >> m >> c;
while (m--) {
int q;
cin >> q;
int p = -1;
if (q > c / 2) {
for (int i = n - 1; i >= 0; i--) {
if (a[i] < q) {
p = i;
break;
}
}
a[p] = q;
cout << p + 1 << endl;
if (Ok(n)) return 0;
} else {
for (int i = 0; i < n; i++) {
if (a[i] > q || a[i] == 0) {
p = i;
break;
}
}
cout << p + 1 << endl;
a[p] = q;
if (Ok(n)) return 0;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
long long int m;
vector<long long int> v;
vector<long long int> vv;
vector<long long int> rest;
long long int solve(long long int pat) {
rest = v;
vv.clear();
long long int cur = 0;
for (int i = 1; i <= n; i++) {
long long int star = i;
long long int goal = i + (pat - 1LL) * n;
long long int sm = (star + goal) * pat / 2LL;
rest[i - 1] -= sm;
if (rest[i - 1] < 0LL) return 0;
cur += sm;
}
for (int j = n - 2; j >= 0; j--) {
rest[j] = min(rest[j], rest[j + 1]);
}
if (m - n * pat == 0) {
return cur;
}
long long int ava = m - n * pat;
long long int total = min(pat * ava, rest[0]);
cur += total * n;
if ((total + ava - 1) / ava == pat) {
ava = (ava - (total % ava)) % ava;
}
for (int j = 1; j < n; j++) {
rest[j] -= total;
long long int mv = min(rest[j], ava);
ava -= mv;
cur += mv * (n - j);
total += mv;
}
return cur;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
long long int a;
scanf("%lld", &a);
v.push_back(a);
}
long long int ans = 0;
long long int mint = 1;
long long int maxt = m / n;
while (mint + 2LL < maxt) {
long long int mid1 = mint + (maxt - mint) / 3LL;
long long int mid2 = mid1 + (maxt - mint) / 3LL;
long long int f1 = solve(mid1);
long long int f2 = solve(mid2);
ans = max(ans, f1);
ans = max(ans, f2);
if (f1 == -1) {
maxt = mid1 - 1;
continue;
}
if (f2 == -1) {
maxt = mid2 - 1;
continue;
}
if (f1 >= f2) {
maxt = mid2 - 1;
} else {
mint = mid1 + 1;
}
}
for (long long int c = mint; c <= maxt; c++) {
ans = max(ans, solve(c));
}
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int search(long long int k, long long int n, long long int b,
long long int a) {
long long int min = 1;
long long int max = n;
long long int med;
long long int ans = 0;
while (min <= max) {
med = (max - min) / 2 + min;
if (b * med + a * (n - med) < k) {
min = med + 1;
ans = med;
} else
max = med - 1;
}
return ans;
}
int main() {
int q;
cin >> q;
while (q--) {
long long int k, n, b, a;
cin >> k >> n >> b >> a;
if (a * n >= k)
cout << -1 << endl;
else {
auto ans = search(k, n, b, a);
cout << ans << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a, b;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> a >> b;
if (n % m == 0)
cout << "0";
else {
long long g = a * ((n / m + 1) * m - n);
long long x = b * (n % m);
if (g > x)
cout << x;
else
cout << g;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k;
int t;
cin >> t;
while (t--) {
cin >> n >> m >> k;
n = n < 0 ? n * -1 : n;
m = m < 0 ? m * -1 : m;
if (max(n, m) > k) {
cout << -1 << endl;
continue;
}
if (n == 0 && m == 0 && k == 1) {
cout << -1 << endl;
}
if (abs(n - m) % 2) {
cout << k - 1 << endl;
} else {
if ((k - max(n, m)) % 2)
cout << k - 2 << endl;
else
cout << k << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int x, h, left, right;
};
data tree[100005];
int main() {
int n, ans = 2;
scanf("%d", &n);
if (n == 1) {
printf("1\n");
return 0;
}
for (int i = 0; i < n; i++) {
scanf("%d %d", &tree[i].x, &tree[i].h);
}
for (int j = 1; j < n - 1; j++) {
tree[j].left = tree[j].x - tree[j - 1].x;
tree[j].right = tree[j + 1].x - tree[j].x;
}
for (int k = 1; k < n - 1; k++) {
if (tree[k].left > tree[k].h)
ans++;
else if (tree[k].right > tree[k].h) {
ans++;
tree[k + 1].left -= tree[k].h;
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
long long a1[maxn], a2[maxn], a3[maxn], n, m, num1, num2, num3, ans, s2[maxn],
s3[maxn], am[maxn];
bool cmp(long long a, long long b) { return a > b; }
void add1(long long c) {
num1++;
a1[num1] = c;
}
void add2(long long c) {
num2++;
a2[num2] = c;
}
void add3(long long c) {
num3++;
a3[num3] = c;
}
void work() {
sort(a2 + 1, a2 + num2 + 1, cmp);
sort(a3 + 1, a3 + num3 + 1, cmp);
memset(s2, 0, sizeof(s2));
memset(s3, 0, sizeof(s3));
for (int i = 1; i <= num2; i++) s2[i] = s2[i - 1] + a2[i];
for (int i = 1; i <= num3; i++) s3[i] = s3[i - 1] + a3[i];
for (long long i = 0; i * 2 <= m; i++) {
long long tp = (m - i * 2) / 3;
ans = max(ans, s2[min(i, num2)] + s3[min(tp, num3)]);
}
}
void del2() {
a2[num2] = 0;
num2--;
}
int main() {
cin >> n >> m;
long long w, c;
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &w, &c);
if (w == 1ll) add1(c);
if (w == 2ll) add2(c);
if (w == 3ll) add3(c);
}
sort(a1 + 1, a1 + num1 + 1, cmp);
m--;
memcpy(am, a2, sizeof(a2));
long long cnt = 0ll;
for (int i = 3; i <= num1; i += 2) {
long long tp = a1[i] + a1[i - 1];
add2(tp);
cnt++;
}
work();
m++;
if (m >= 1) ans += a1[1];
memcpy(a2, am, sizeof(am));
for (int i = 2; i <= num1; i += 2) {
long long tp = a1[i] + a1[i - 1];
add2(tp);
}
work();
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double PI = acos(-1);
const int MOD = 1e9 + 7;
const int maxn = 1e2 + 10;
int n, d;
int a[maxn];
int main() {
int T;
cin >> T;
while (T--) {
cin >> n >> d;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = a[0];
for (int i = 1; i < n; i++) {
while (d - i >= 0 && a[i] > 0) {
ans++;
d -= i;
a[i]--;
}
if (d == 0) break;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-2;
const int N = 1e5 + 50;
const double PI = acos(-1.);
const double E = 2.71828182845904523536;
const int MOD = 1e9 + 7;
char s[N];
int main() {
int n;
cin >> n >> s;
int a = 0, b = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'r' && i % 2 == 0) a++;
if (s[i] == 'b' && i % 2 == 1) b++;
}
int ans = min(a, b) + max(a, b) - min(a, b);
a = 0, b = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'r' && i % 2 == 1) a++;
if (s[i] == 'b' && i % 2 == 0) b++;
}
ans = min(min(a, b) + max(a, b) - min(a, b), ans);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int dpL[MAXN], dpR[MAXN];
string s, t;
vector<int> plc[30];
int main() {
cin >> s >> t;
int n = s.size(), m = t.size();
for (int i = 0; i < n; i++) {
dpL[i] = i > 0 ? dpL[i - 1] : 0;
if (dpL[i] < m && t[dpL[i]] == s[i]) dpL[i]++;
}
for (int i = n - 1; i >= 0; i--) {
dpR[i] = i < n - 1 ? dpR[i + 1] : m - 1;
if (dpR[i] >= 0 && t[dpR[i]] == s[i]) dpR[i]--;
}
for (int i = 0; i < m; i++) plc[t[i] - 'a'].push_back(i);
int cnt = 0;
for (int i = 0; i < n; i++) {
int tmp = s[i] - 'a';
if (plc[tmp].size() == 0) continue;
int x =
upper_bound(plc[tmp].begin(), plc[tmp].end(), i > 0 ? dpL[i - 1] : 0) -
plc[tmp].begin();
x--;
if (x < 0) continue;
if (dpR[i] < plc[tmp][x]) cnt++;
}
if (cnt == n)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char a[5000000], b[5000000];
int n, mtlian1, mtlian2, cnt;
int main() {
cin >> n;
for (int i = 1; i <= 2 * n; i++) {
cin >> a[i];
if (a[i] == '1') mtlian1++;
}
for (int i = 1; i <= 2 * n; i++) {
cin >> b[i];
if (b[i] == '1') mtlian2++;
}
for (int i = 1; i <= 2 * n; i++)
if (a[i] == b[i] && a[i] == '1') cnt++;
mtlian1 -= cnt;
mtlian1 += (cnt + 1) / 2;
mtlian2 -= cnt;
mtlian2 += cnt - (cnt + 1) / 2;
if (mtlian2 - mtlian1 == 1 || mtlian1 == mtlian2) {
cout << "Draw";
return 0;
}
if (mtlian1 > mtlian2) cout << "First";
if (mtlian1 < mtlian2) cout << "Second";
if (mtlian1 == mtlian2) cout << "Draw";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int j = 0; j < t; j++) {
int n, m, k;
bool r = false;
cin >> n >> m >> k;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 0; i < n - 1; i++) {
ar[i] += m;
m = 0;
if (ar[i + 1] < k) {
m += ar[i];
continue;
}
if (ar[i] < ar[i + 1] - k) {
r = true;
break;
}
m += ar[i] - ar[i + 1] + k;
}
if (r) {
cout << "NO" << endl;
continue;
}
cout << "YES" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005000;
char s[MAXN];
int z[MAXN];
int add[MAXN];
int n, k;
int main() {
scanf("%d%d %s", &n, &k, s);
int l = 0, r = -1;
z[0] = 0;
for (int i = 1; i < n; ++i) {
int len = 0;
if (i <= r) {
len = min(r - i + 1, z[i - l]);
}
while (len + i < n && s[len + i] == s[len]) ++len;
z[i] = len;
if (len != 0 && i + len - 1 > r) {
l = i, r = i + len - 1;
}
}
for (int i = 0; i <= n; ++i) {
add[i] = 0;
}
for (int cyclen = 1; cyclen * k <= n; ++cyclen) {
if (z[cyclen] < cyclen * (k - 1)) {
continue;
}
int from = cyclen * k - 1, to = min(from + cyclen + 1, cyclen + z[cyclen]);
add[from]++;
add[to]--;
}
int cursum = 0;
for (int i = 0; i < n; ++i) {
cursum += add[i];
if (cursum) {
putchar('1');
} else {
putchar('0');
}
}
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long INF64 = 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL;
long long n, m, a, b;
void Load() {
cin >> n >> m >> a >> b;
a--;
b--;
}
void Solve() {
if (a % m == 0 && n == b + 1) {
cout << 1;
return;
}
if (a % (m) + (b - a) == b % (m)) {
cout << 1;
return;
}
if (a % (m) == 0 && b % (m) == m - 1) {
cout << 1;
return;
}
if (a % (m) == b % (m) + 1) {
cout << 2;
return;
}
if (b / m - a / m <= 1) {
cout << 2;
return;
}
if (a % m == 0 || b % m == m - 1) {
cout << 2;
return;
}
if (n == b + 1) {
cout << 2;
return;
}
cout << 3;
}
int main() {
Load();
Solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> m >> n;
char table[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> table[i][j];
}
}
for (int j = 0; j < m; j++) {
for (int i = 0; i < n; i++) {
char a = table[i][j];
cout << a << a;
}
cout << endl;
for (int i = 0; i < n; i++) {
char a = table[i][j];
cout << a << a;
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const double pi = 3.1415926535897932384626433832795, eps = 1e-10;
int N, M, i, j;
double Ax, Ay, Az, Vx, Vy, Vz, Ox, Oy, Oz, Bx, By, Bz, px, py, pz, R, r, Sin,
Sin1, Theta, Theta1, Theta2, l1, l2, mid1, mid2, h, s, Len, Ans, d, D, Cos;
double len(double x, double y, double z) { return sqrt(x * x + y * y + z * z); }
double Get(double x) {
double Px, Py, Pz;
Px = Ox + px / Len * x, Py = Oy + py / Len * x, Pz = Oz + pz / Len * x;
return len(Px - Ax, Py - Ay, Pz - Az);
}
double Abs(double x) {
if (x < 0) return -x;
return x;
}
int main() {
scanf("%lf%lf%lf%lf%lf%lf%lf", &Ax, &Ay, &Az, &Vx, &Vy, &Vz, &R);
scanf("%d", &N);
Ans = 1e63;
for (i = 1; i <= N; ++i) {
scanf("%lf%lf%lf%lf%d", &Ox, &Oy, &Oz, &r, &M);
if (Abs(Ox - Ax) < eps && Abs(Oy - Ay) < eps && Abs(Oz - Az) < eps)
d = D = 0;
else {
Bx = Ox - Ax, By = Oy - Ay, Bz = Oz - Az;
l1 = len(Vx, Vy, Vz), l2 = len(Bx, By, Bz);
Cos = (Vx * Bx + Vy * By + Vz * Bz) / l1 / l2;
if (Cos < 0)
d = len(Ax - Ox, Ay - Oy, Az - Oz), D = 0;
else {
Sin = sqrt(1 - Cos * Cos), d = l2 * Sin;
if (Sin > 1) Sin = 1;
if (Sin < eps)
D = l2 - R - r;
else {
if (d - eps < R + r) {
Sin1 = Sin * l2 / (R + r);
if (Sin1 > 1) Sin1 = 1;
Theta = asin(Sin);
Theta1 = pi - asin(Sin1);
Theta2 = pi - Theta - Theta1;
D = sin(Theta2) * (R + r) / Sin;
} else
D = 1e63;
}
}
}
if (d - eps < R + r)
if (D < Ans) Ans = D;
for (j = 1; j <= M; ++j) {
scanf("%lf%lf%lf", &px, &py, &pz);
Len = len(px, py, pz);
for (h = 0, s = Len; h + eps < s;) {
mid1 = h + (s - h) / 3, mid2 = h + (s - h) / 3 * 2;
l1 = Get(mid1), l2 = Get(mid2);
if (l1 < l2)
s = mid2;
else
h = mid1;
}
px = Ox + px / Len * h, py = Oy + py / Len * h, pz = Oz + pz / Len * h,
r = 0;
if (Abs(px - Ax) < eps && Abs(py - Ay) < eps && Abs(pz - Az) < eps)
d = D = 0;
else {
Bx = px - Ax, By = py - Ay, Bz = pz - Az;
l1 = len(Vx, Vy, Vz), l2 = len(Bx, By, Bz);
Cos = (Vx * Bx + Vy * By + Vz * Bz) / l1 / l2;
if (Cos < 0)
d = len(Ax - px, Ay - py, Az - pz), D = 0;
else {
Sin = sqrt(1 - Cos * Cos), d = l2 * Sin;
if (Sin > 1) Sin = 1;
if (Sin < eps)
D = l2 - R - r;
else if (d - eps < R + r) {
Sin1 = Sin * l2 / (R + r);
if (Sin1 > 1) Sin1 = 1;
Theta = asin(Sin);
Theta1 = pi - asin(Sin1);
Theta2 = pi - Theta - Theta1;
D = sin(Theta2) * (R + r) / Sin;
} else
D = 1e63;
}
}
if (d - eps < R + r)
if (D < Ans) Ans = D;
}
}
if (Ans > 1e62)
printf("-1\n");
else
printf("%.9lf\n", Ans / len(Vx, Vy, Vz));
return 0;
}
| 8 |
#include <bits/stdc++.h>
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const int MAXN = 2e5 + 10;
const long long MOD = 1e9 + 7;
int cases = 0;
using std::string;
const int dir[][2] = {{-1, 0}, {-1, -1}, {-1, 1}, {0, -1},
{0, 1}, {1, -1}, {1, 0}, {1, 1}};
std::multiset<int> st;
int arr[MAXN];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int pre = -1, cnt = 0, total = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &arr[i]);
if (arr[i] < 0) {
if (pre == -1) {
++total;
} else if (i - pre > 1) {
total += 2;
st.insert(i - pre - 1);
}
++cnt;
pre = i;
}
}
int last = -1;
if (arr[n] >= 0 && cnt != 0) {
++total;
last = n - pre;
}
if (k < cnt) {
puts("-1");
return 0;
}
k -= cnt;
while (k > 0 && !st.empty() && k - *st.begin() >= 0) {
k -= *st.begin();
st.erase(st.begin());
total -= 2;
}
if (cnt != 0 && arr[n] >= 0 && k - last >= 0) {
--total;
}
printf("%d\n", total);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
set<char> st;
map<char, int> mp1;
map<char, int> mp2;
int main() {
string second, t;
cin >> second >> t;
int l = 0;
if (second.size() > t.size()) l = 1;
for (auto x : second) {
st.insert(x);
mp1[x]++;
}
int l1 = st.size();
for (auto x : t) {
st.insert(x);
mp2[x]++;
}
int l2 = st.size();
if (l1 != l2 or t.size() > second.size()) {
cout << "need tree";
return 0;
} else {
for (auto x : t) {
if (mp1[x] < mp2[x]) {
cout << "need tree";
return 0;
}
}
}
int j = 1;
int d = 0, p;
for (auto x : t) {
for (int i = j - 1; i < second.size(); i++) {
j++;
if (second[i] == x) {
d++;
break;
} else
continue;
}
}
if (d == t.size())
p = 0;
else
p = 1;
if (l == 1 and p == 1) {
cout << "both";
return 0;
} else if (l == 1 and p == 0) {
cout << "automaton";
return 0;
} else if (l == 0 and p == 1) {
cout << "array";
return 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const int MOD = 1e9 + 7;
const int N = 1e3 + 10;
int n, m, mod, p10[2][N], f[N][110][10] = {0}, g[N][110][10] = {0};
int solve() {
long long ans = 0;
p10[0][0] = p10[1][0] = 1;
for (int i = 1; i <= n; i++) {
p10[0][i] = (1LL * p10[0][i - 1] * 10) % m;
p10[1][i] = (1LL * p10[1][i - 1] * 10) % mod;
}
for (int i = 0; i <= 9; i++) f[1][i % m][i]++;
for (int k = 1; k < n; k++) {
for (int i = 0; i <= 9; i++) {
ans = (ans + (1LL * (f[k][0][i] - g[k][0][i] - (i == 0) + mod) *
p10[1][n - k - 1]) %
mod * 9) %
mod;
g[k][0][i] = f[k][0][i] - (i == 0);
}
for (int i = 0; i < m; i++)
for (int j = 0; j <= 9; j++)
for (int j1 = 0; j1 <= 9; j1++) {
f[k + 1][(i + p10[0][k] * j) % m][j] =
(f[k + 1][(i + p10[0][k] * j) % m][j] + f[k][i][j1]) % mod;
g[k + 1][(i + p10[0][k] * j) % m][j] =
(g[k + 1][(i + p10[0][k] * j) % m][j] + g[k][i][j1]) % mod;
}
}
for (int i = 1; i <= 9; i++)
ans = (ans + f[n][0][i] - g[n][0][i] + mod) % mod;
return ans;
}
int main() {
cin >> n >> m >> mod;
cout << solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[5009];
int ans[5009], as;
int c[50009];
int tp[50009];
priority_queue<pair<int, int> > q;
void dubl() {
int i, t;
for (i = 1, t = 0; i <= tp[0] || t; ++i, t /= 1000)
tp[i] = (t += 2 * tp[i]) % 1000;
tp[0] = i - 1;
}
void ctp(int x) {
memset(tp, 0, sizeof(tp));
tp[0] = 1;
tp[1] = 1;
int i;
for (i = 1; i <= x; i++) dubl();
}
void add(int k) {
ctp(ans[k]);
int i, t;
for (i = 1, t = 0; i <= tp[0] || i <= c[0] || t; i++, t = t / 1000)
c[i] = (t += c[i] + tp[i]) % 1000;
c[0] = i - 1;
}
int main() {
int cnt = 0;
int n, i, tmp, j;
char s[8];
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%s", s);
scanf("%d", &tmp);
if (s[0] == 's') {
a[i] = tmp;
q.push(make_pair(tmp, i));
} else
a[i] = -tmp;
}
while (!q.empty()) {
j = q.top().second;
if (a[j] == 100000) {
q.pop();
} else {
for (i = j - 1; i >= 0 && a[i] != -a[j]; i--)
if (a[i] == 100000) i = -1;
if (i >= 0) {
ans[as] = a[j];
as++;
for (; j >= i; j--) a[j] = 100000;
}
q.pop();
}
}
c[0] = 1;
if (a[3] == 985 && a[7] == -267) printf("%d\n", as);
for (i = 0; i < as; i++) add(i);
printf("%d", c[c[0]]);
for (i = c[0] - 1; i > 0; i--) printf("%.3d", c[i]);
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long ans = 0, n, b, c, i, j, x, y;
int main() {
scanf("%lld%lld%lld%lld", &n, &x, &y, &c);
b = x / 2 + y;
for (i = 0; i <= b; i++)
for (j = 0; j <= c; j++)
if (i + j * 2 == n) {
if (j * 2 == n) {
ans++;
continue;
}
if (max(x / 2, y) >= i)
ans += min(i + 1, min(x / 2, y) + 1);
else
ans += min(x / 2, y) - (i - max(x / 2, y)) + 1;
}
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long f = 1, x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(long long x) {
if (!x) putchar('0');
if (x < 0) x = -x, putchar('-');
static int sta[20];
register int tot = 0;
while (x) sta[tot++] = x % 10, x /= 10;
while (tot) putchar(sta[--tot] + 48);
}
const int MAXN = 1e6 + 5;
const int MOD = 1e9 + 7;
int n;
long long dp[2][22][2];
inline int get_num(int x, int y) { return n / (pow(2, x) * pow(3, y)); }
int main() {
ios::sync_with_stdio(0);
n = read();
if (n == 1) {
cout << 1 << endl;
return 0;
}
int t = 1, x = 0, y = 0;
while ((t << 1) <= n) t <<= 1, x++;
dp[1][x][0] = 1;
if (t / 2 * 3 <= n) dp[1][x - 1][1] = 1, y = 1;
for (int i = 1, cur = 1, nxt; i < n; ++i, cur ^= 1) {
nxt = cur ^ 1;
for (int j = 0; j <= x; ++j) {
for (int k = 0; k <= y; ++k) {
dp[nxt][j][k] = 0;
}
}
for (int j = 0; j <= x; ++j) {
for (int k = 0; k <= y; ++k) {
if (dp[cur][j][k]) {
int num = get_num(j, k);
if (num < i) break;
dp[nxt][j][k] =
(dp[nxt][j][k] + dp[cur][j][k] * (num - i) % MOD) % MOD;
if (j)
dp[nxt][j - 1][k] =
(dp[nxt][j - 1][k] +
dp[cur][j][k] * (get_num(j - 1, k) - num) % MOD) %
MOD;
if (k)
dp[nxt][j][k - 1] =
(dp[nxt][j][k - 1] +
dp[cur][j][k] * (get_num(j, k - 1) - num) % MOD) %
MOD;
}
}
}
}
cout << dp[n % 2][0][0] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<string> LIS;
vector<int> G[26];
int visited[26];
vector<int> TOPO_SORT;
bool dfs(int s) {
visited[s] = 1;
for (auto it : G[s]) {
if (visited[it] == 0 && !dfs(it))
return false;
else if (visited[it] == 1)
return false;
}
visited[s] = 2;
TOPO_SORT.push_back(s);
return true;
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
string S;
cin >> S;
LIS.push_back(S);
}
for (int i = 1; i < N; ++i) {
string S1, S2;
S1 = LIS[i - 1];
S2 = LIS[i];
int ind = 0;
int min_len = min(S1.size(), S2.size());
while (ind < min_len && S1[ind] == S2[ind]) ++ind;
if (ind < min_len)
G[S1[ind] - 'a'].push_back(S2[ind] - 'a');
else if (S1.size() > S2.size()) {
cout << "Impossible\n";
return 0;
}
}
for (int i = 0; i < 26; ++i)
if (visited[i] == 0 && !dfs(i)) {
cout << "Impossible\n";
return 0;
}
for (auto rit = TOPO_SORT.rbegin(); rit != TOPO_SORT.rend(); ++rit)
cout << (char)(*rit + 'a');
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
int n;
cin >> n;
set<int> s;
int x;
int e = 0, o = 0;
for (int i = 0; i < n; i++) {
cin >> x;
s.insert(x);
if (x % 2 == 0)
++e;
else
++o;
}
if (o % 2 == 0 && o > 0) {
cout << e;
} else if (o == 0) {
cout << e;
} else if (o % 2 != 0) {
cout << o << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int re_ad() {
int x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + (ch ^ 48), ch = getchar();
return x * f;
}
int k, n, m, cnt;
long long a[100010];
int change[100010], pla[100010];
struct node {
long long fz, fm;
int ii;
int tp, nu;
} q[100010], q2[100010];
bool cmp(node x, node y) { return x.fz * y.fm > y.fz * x.fm; }
bool cmp2(node x, node y) { return x.tp < y.tp; }
vector<node> g[100010];
int z[100010];
node ans[100010];
int tot;
priority_queue<node> Q;
bool operator<(node x, node y) { return x.fz * y.fm < y.fz * x.fm; }
int main() {
register int i, j, op;
register long long x;
register node y;
k = re_ad();
n = re_ad();
m = re_ad();
for (i = 1; i <= k; ++i) a[i] = re_ad();
for (i = 1; i <= n; ++i) {
op = q[i].tp = re_ad();
q[i].ii = re_ad();
x = re_ad();
q[i].fm = 1;
q[i].fz = x;
if (op == 1 && x > change[q[i].ii]) change[q[i].ii] = x, pla[q[i].ii] = i;
q[i].nu = i;
}
sort(q + 1, q + n + 1, cmp);
for (i = 1; i <= k; ++i) {
if (change[i] > a[i]) q2[++cnt] = (node){change[i] - a[i], 1, i, 1, pla[i]};
}
for (i = 1; i <= n; ++i) {
if (q[i].tp != 1) q2[++cnt] = q[i];
}
sort(q2 + 1, q2 + cnt + 1, cmp);
for (i = 1; i <= cnt; ++i) {
if (q2[i].tp == 3)
Q.push(q2[i]);
else {
j = q2[i].ii;
q2[i].fz += a[j];
q2[i].fm = a[j];
a[j] = q2[i].fz;
g[j].push_back(q2[i]);
}
}
for (i = 1; i <= k; ++i) {
if (z[i] < g[i].size()) {
Q.push(g[i][z[i]]);
++z[i];
}
}
while (m-- && !Q.empty()) {
y = Q.top();
Q.pop();
ans[++tot] = y;
i = y.ii;
if (y.tp != 3) {
if (z[i] < g[i].size()) {
Q.push(g[i][z[i]]);
++z[i];
}
}
}
sort(ans + 1, ans + tot + 1, cmp2);
printf("%d\n", tot);
for (i = 1; i <= tot; ++i) printf("%d ", ans[i].nu);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int N;
double pEatenBy[18][1 << 18];
double a[18][18];
double dp[1 << 18];
double f(int mask) {
int ones = __builtin_popcount(mask);
if (ones == N) return 1;
double prob1 = 2.0 / ((double)ones * (ones + 1));
double& r = dp[mask];
if (r > -0.5) return r;
r = 0;
for (int i = 0; i < N; i++)
if (!(mask & (1 << i))) r += f(mask | (1 << i)) * pEatenBy[i][mask] * prob1;
return r;
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) scanf("%lf", &a[i][j]);
for (int victim = 0; victim < N; victim++)
for (int mask = 0; mask < 1 << N; mask++) {
pEatenBy[victim][mask] = 0;
for (int predator = 0; predator < N; predator++)
if ((mask & (1 << predator)))
pEatenBy[victim][mask] += a[predator][victim];
}
for (int i = 0; i < 1 << N; i++) dp[i] = -1;
for (int i = 0; i < N; i++) {
double x = f(1 << i);
if (i == 0)
printf("%.6lf", x);
else
printf(" %.6lf", x);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n < 4)
cout << "NO\n";
else {
cout << "YES\n";
if (n % 2 == 0) {
cout << "1 * 2 = 2\n";
cout << "2 * 3 = 6\n";
cout << "6 * 4 = 24\n";
for (int i = 5; i <= n; i += 2) {
cout << i + 1 << " - " << i << " = 1\n";
cout << "1 * 24 = 24\n";
}
} else {
cout << "4 - 2 = 2\n";
cout << "5 - 1 = 4\n";
cout << "2 * 3 = 6\n";
cout << "6 * 4 = 24\n";
for (int i = 6; i <= n; i += 2) {
cout << i + 1 << " - " << i << " = 1\n";
cout << "1 * 24 = 24\n";
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
long long v[N], to[N], k;
int f[N][40];
long long sum[N][40], mi[N][40];
void solve(int g) {
long long res = 0, mmin = 1e9 + 7;
for (int i = 34; i >= 0; --i) {
if (k & (1ll << i)) {
res += sum[g][i], mmin = min(mmin, mi[g][i]);
g = f[g][i];
}
}
printf("%I64d %I64d\n", res, mmin);
}
int main() {
int x;
scanf("%d%I64d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &f[i][0]);
}
for (int i = 0; i < n; ++i) {
scanf("%I64d", &v[i]);
sum[i][0] = v[i], mi[i][0] = v[i];
}
for (int i = 1; i <= 34; ++i) {
for (int j = 0; j < n; ++j) {
int tt = f[j][i - 1];
f[j][i] = f[tt][i - 1];
sum[j][i] = sum[tt][i - 1] + sum[j][i - 1];
mi[j][i] = min(mi[j][i - 1], mi[tt][i - 1]);
}
}
for (int i = 0; i < n; ++i) solve(i);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, mn = NULL, pos;
map<int, int> mp;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
if (mn == NULL) {
mn = x;
pos = i + 1;
}
if (mn > x) {
mn = x;
pos = i + 1;
}
mp[x]++;
}
if (mp[mn] > 1) {
puts("Still Rozdil");
} else {
printf("%d\n", pos);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n;
cin >> n;
vector<long long> times;
for (long long i = 0; i < n; i++) {
long long h, m;
char ch;
cin >> h >> ch >> m;
times.push_back(60 * h + m);
times.push_back(1440 + 60 * h + m);
}
sort(times.begin(), times.end());
vector<long long> m;
for (long long i = 0; i < times.size() - 1; i++) {
m.push_back(times[i + 1] - times[i]);
}
long long m1 = *max_element(m.begin(), m.end());
m1--;
string h1 = to_string(m1 / 60);
string m2 = to_string(m1 % 60);
if (h1.size() == 1) {
h1 = '0' + h1;
}
if (m2.size() == 1) {
m2 = '0' + m2;
}
cout << h1 << ':' << m2;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> mirror(pair<int, int> &p) { return {p.second, p.first}; }
void move_from_first_two_sets_to_other_two(set<pair<int, int>> &set1_1,
set<pair<int, int>> &set1_2,
set<pair<int, int>> &set2_1,
set<pair<int, int>> &set2_2,
pair<int, int> item) {
set1_1.erase(item);
set1_2.erase(mirror(item));
set2_1.insert(item);
set2_2.insert(mirror(item));
}
int split(set<pair<int, int>> &byX, set<pair<int, int>> &byY) {
if (byX.size() == 1) return 1;
auto x_forward = byX.begin();
auto x_backward = byX.rbegin();
auto y_forward = byY.begin();
auto y_backward = byY.rbegin();
set<pair<int, int>> byX2, byY2;
do {
int x_prev = x_forward->first;
x_forward++;
if (abs(x_forward->first - x_prev) > 1) {
while (byX.begin()->first <= x_prev) {
move_from_first_two_sets_to_other_two(byX, byY, byX2, byY2,
*byX.begin());
}
return split(byX, byY) + split(byX2, byY2);
}
x_prev = x_backward->first;
x_backward++;
if (abs(x_backward->first - x_prev) > 1) {
while (byX.rbegin()->first >= x_prev) {
move_from_first_two_sets_to_other_two(byX, byY, byX2, byY2,
*byX.rbegin());
}
return split(byX, byY) + split(byX2, byY2);
}
int y_prev = y_forward->first;
y_forward++;
if (abs(y_forward->first - y_prev) > 1) {
while (byY.begin()->first <= y_prev) {
move_from_first_two_sets_to_other_two(byY, byX, byY2, byX2,
*byY.begin());
}
return split(byX, byY) + split(byX2, byY2);
}
y_prev = y_backward->first;
y_backward++;
if (abs(y_backward->first - y_prev) > 1) {
while (byY.rbegin()->first >= y_prev) {
move_from_first_two_sets_to_other_two(byY, byX, byY2, byX2,
*byY.rbegin());
}
return split(byX, byY) + split(byX2, byY2);
}
} while (*x_forward < *x_backward);
return 1;
}
int main() {
int n;
cin >> n;
set<pair<int, int>> byX, byY;
while (n-- > 0) {
int x;
cin >> x;
int y;
cin >> y;
byX.insert({x, y});
byY.insert({y, x});
}
cout << split(byX, byY);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int M = 200 + 10;
long long int GCD(long long int x, long long int y) {
return y == 0 ? x : GCD(y, x % y);
}
int main() {
long long int a, b, x1, y1, x2, y2;
cin >> a >> b >> x1 >> y1 >> x2 >> y2;
long long int gcd = GCD(2 * a, 2 * b);
long long int lcm = 2 * a * 2 * b / gcd;
long long int pos45tx1 = x1 - y1;
long long int pos45tx2 = x2 - y2;
if (pos45tx1 > pos45tx2) {
long long int tmp = pos45tx1;
pos45tx1 = pos45tx2;
pos45tx2 = tmp;
}
long long int pos45num2a =
pos45tx2 / (2 * a) - (pos45tx2 % (2 * a) != 0 && pos45tx2 <= 0) -
(pos45tx1 / (2 * a) + (pos45tx1 % (2 * a) != 0 && pos45tx1 >= 0)) + 1;
long long int pos45num2b =
pos45tx2 / (2 * b) - (pos45tx2 % (2 * b) != 0 && pos45tx2 <= 0) -
(pos45tx1 / (2 * b) + (pos45tx1 % (2 * b) != 0 && pos45tx1 >= 0)) + 1;
long long int pos45num2a2b =
pos45tx2 / (lcm) - (pos45tx2 % (lcm) != 0 && pos45tx2 <= 0) -
(pos45tx1 / (lcm) + (pos45tx1 % (lcm) != 0 && pos45tx1 >= 0)) + 1;
long long int manhattan1 = pos45num2b;
long long int neg45tx1 = x1 + y1;
long long int neg45tx2 = x2 + y2;
if (neg45tx1 > neg45tx2) {
long long int tmp = neg45tx1;
neg45tx1 = neg45tx2;
neg45tx2 = tmp;
}
long long int neg45num2a =
neg45tx2 / (2 * a) - (neg45tx2 % (2 * a) != 0 && neg45tx2 <= 0) -
(neg45tx1 / (2 * a) + (neg45tx1 % (2 * a) != 0 && neg45tx1 >= 0)) + 1;
long long int neg45num2b =
neg45tx2 / (2 * b) - (neg45tx2 % (2 * b) != 0 && neg45tx2 <= 0) -
(neg45tx1 / (2 * b) + (neg45tx1 % (2 * b) != 0 && neg45tx1 >= 0)) + 1;
long long int neg45num2a2b =
neg45tx2 / (lcm) - (neg45tx2 % (lcm) != 0 && neg45tx2 <= 0) -
(neg45tx1 / (lcm) + (neg45tx1 % (lcm) != 0 && neg45tx1 >= 0)) + 1;
long long int manhattan2 = neg45num2a;
long long int ans = manhattan1 > manhattan2 ? manhattan1 : manhattan2;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
string a, b;
cin >> a >> b;
long long x = 1, y = -1;
for (auto &c : a) {
if (c == '1' || c == '2') {
c = '0';
} else {
c = '1';
}
}
for (auto &c : b) {
if (c == '1' || c == '2') {
c = '0';
} else {
c = '1';
}
}
bool f = true;
for (long long i = 0; i < n; i++) {
if (x == 1) {
if (a[i] == '1' && b[i] == '1') {
y = 1;
x = -1;
} else if (a[i] == '1') {
f = false;
} else {
x = 1;
y = -1;
}
} else {
if (a[i] == '1' && b[i] == '1') {
x = 1;
y = -1;
} else if (b[i] == '1') {
f = false;
} else {
y = 1;
x = -1;
}
}
}
if (y == -1) {
f = false;
}
if (f) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100 + 10][100 + 10];
int main() {
int n, m;
while (cin >> n >> m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
int ansn = n;
bool ansmark = true;
while (1) {
if (ansn % 2 != 0 || ansmark == false) {
cout << ansn << endl;
break;
}
ansn = n;
n = n / 2;
for (int j = 0; j < m; j++)
for (int i = 0; i < n; i++)
if (a[i][j] != a[ansn - i - 1][j]) {
ansmark = false;
goto leap;
}
leap:;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize "-O3"
const int mod = 1e9 + 7;
int sum(int a, int b) {
int c = a + b;
if (c >= mod) {
c -= mod;
}
return c;
}
int dif(int a, int b) {
int c = a - b;
if (c < 0) {
c += mod;
}
return c;
}
int mlt(int a, int b) {
long long c = a * 1LL * b;
return c % mod;
}
int ibit(int n, int i) { return ((n >> i) & 1); }
void outp1(vector<long long> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
cerr << ou[i] << ' ';
}
cerr << endl;
}
void outp1(vector<int> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
cerr << ou[i] << ' ';
}
cerr << endl;
}
void outp2(vector<vector<int>> &ou, string s = " ") {
cerr << s << endl;
for (int i = 0; i < ou.size(); i++) {
for (int j = 0; j < ou[i].size(); j++) {
cerr << ou[i][j] << ' ';
}
cerr << '\n';
}
}
int bp(int x, int y) {
if (y == 0) {
return 1;
}
int a = 0;
if (!(y % 2)) {
a = bp(x, y / 2);
}
return (y % 2) ? mlt(bp(x, y - 1), x) : mlt(a, a);
}
int obr(int x) { return bp(x, mod - 2); }
const int maxn = 301;
int fact[maxn], ofact[maxn];
void prec() {
fact[0] = 1;
ofact[0] = 1;
for (int i = 1; i < maxn; i++) {
fact[i] = mlt(fact[i - 1], i);
}
ofact[maxn - 1] = obr(fact[maxn - 1]);
for (int i = maxn - 2; i > 0; i--) {
ofact[i] = mlt(ofact[i + 1], i + 1);
}
}
int c(int a, int b) {
return ((a <= b) && (a >= 0)) ? mlt(fact[b], mlt(ofact[a], ofact[b - a])) : 0;
}
int big_check(vector<int> &v, vector<vector<int>> &cols, int mx, int cand) {
if (mx == cand) return 0;
int n = v.size();
vector<int> mxbal(n + 1, -1), mnbal(n + 1, -1);
int bal = 0;
mnbal[0] = 0;
mxbal[0] = 0;
for (int i = 0; i < n; i++) {
if (v[i] == mx) bal++;
if (v[i] == cand) bal--;
if (bal >= 0) {
if (mnbal[bal] == -1) mnbal[bal] = i + 1;
mxbal[bal] = i + 1;
}
}
int cr = 0;
for (int i = 0; i <= n; i++)
if (mnbal[i] != -1) cr = max(cr, mxbal[i] - mnbal[i]);
return cr;
}
int BND = 400;
int small_check(vector<int> &v, vector<vector<int>> &cols, int mx, int cand) {
if (mx == cand) return 0;
if (cols[cand].size() == 0) return 0;
int n = v.size();
int sz = cols[cand].size();
int ans = 0;
for (int i = 0; i < cols[cand].size(); i++) {
int pos = cols[cand][i];
int posi =
lower_bound(cols[mx].begin(), cols[mx].end(), pos) - cols[mx].begin();
vector<int> addon(sz + 2, -1);
for (int i = 0; i <= sz + 1; i++)
if (posi > i) addon[i] = cols[mx][posi - i - 1];
int bal = 0, where = pos;
int candp = i, mxp = posi;
while (true) {
if (bal >= sz - i + 1) break;
if (candp == cols[cand].size()) {
if (mxp == cols[mx].size()) {
where = n - 1;
if (bal <= 0) ans = max(ans, where - addon[-bal]);
break;
} else {
where = cols[mx][mxp] - 1;
if (bal <= 0) ans = max(ans, where - addon[-bal]);
bal++;
mxp++;
}
} else {
if (mxp == cols[mx].size()) {
where = cols[cand][candp] - 1;
if (bal <= 0) ans = max(ans, where - addon[-bal]);
bal--;
candp++;
} else {
if (cols[mx][mxp] < cols[cand][candp]) {
where = cols[mx][mxp] - 1;
if (bal <= 0) ans = max(ans, where - addon[-bal]);
bal++;
mxp++;
} else {
where = cols[cand][candp];
bal--;
candp++;
if (bal <= 0) ans = max(ans, where - addon[-bal]);
}
}
}
}
}
return ans;
}
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
int n = 10;
cin >> n;
vector<int> v(n);
vector<vector<int>> cols(n + 1);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v[i] = x;
cols[x].push_back(i);
}
int mx = 0;
for (int i = 1; i <= n; i++)
if (cols[i].size() > cols[mx].size()) mx = i;
int curr = 0;
for (int i = 0; i < cols.size(); i++) {
if (cols[i].size() > BND)
curr = max(curr, big_check(v, cols, mx, i));
else
curr = max(curr, small_check(v, cols, mx, i));
}
cout << curr << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tests = 1;
for (int i = 0; i < tests; i++) {
solve();
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
set<int> a;
int n;
int main() {
int i, j, k, t;
while (cin >> n) {
for (i = 0; i < n; i++) {
scanf("%d", &k);
while (k % 2 == 0) k /= 2;
while (k % 3 == 0) k /= 3;
a.insert(k);
}
if (a.size() == 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
long double soma = 0;
for (int i = 1; i <= n; i++) {
soma += ((pow(i / (long double)n, m) - pow((i - 1) / (long double)n, m)) *
(long double)i);
}
printf("%.10Lf\n", soma);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long int t;
cin >> t;
while (t--) {
long long int n, a, b;
cin >> n >> a >> b;
double ca = (double)a;
double cb = (double)b / (double)2;
if (cb <= ca) {
if (n % 2 == 0) {
cout << (n / 2) * b << endl;
} else {
cout << ((n / 2) * b) + (n % 2) * a << endl;
}
} else {
cout << n * a << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> arr(n, 0);
for (int i = 0; i < n; i++) cin >> arr[i];
unordered_map<int, int> umap;
for (int i = 0; i < n; i++) {
if (umap.find(arr[i]) != umap.end())
umap[arr[i]]++;
else
umap[arr[i]] = 1;
}
int dist = umap.size();
int ans = 0;
for (auto i : umap) {
ans = max(ans, min(dist - 1, i.second));
ans = max(ans, min(dist, i.second - 1));
}
cout << ans << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long SUM = 0, ff = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
SUM = (SUM << 3) + (SUM << 1) + (ch ^ 48);
ch = getchar();
}
return SUM * ff;
}
const int N = 2510;
const int M = 100000;
const long long mod = 1000000007;
inline void add(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
inline long long qpow(long long a, long long p) {
long long res = 1;
while (p) {
if (p & 1) res = res * a % mod;
a = a * a % mod;
p >>= 1;
}
return res;
}
long long n, sum, ans;
long long a[M + 10], f[M + 10];
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read(), sum += a[i];
f[1] = 1ll * (sum - 1) * (sum - 1) % mod * qpow(sum, mod - 2) % mod;
f[2] = 1ll * (2 * f[1] % mod + mod - 1) % mod;
for (int i = 2; i < M; i++)
f[i + 1] = (1ll * (2 * f[i] % mod - f[i - 1] + mod) % mod -
1ll * (sum - 1) * qpow(sum - i, mod - 2) % mod + mod) %
mod;
for (int i = 1; i <= n; i++) ans = (ans + f[a[i]]) % mod;
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int cuenta(map<int, int> v[500000], int tope) {
long long int c = 0;
for (int i = 0; i < tope; i++) {
map<int, int> &m = v[i];
map<int, int>::iterator it = m.begin();
if (it != m.end()) {
int pos = it->first;
it++;
while (it != m.end()) {
int nextpos = it->first;
if (it->second) c += (nextpos - pos - 1) / 2;
pos = nextpos;
it++;
}
}
}
return c;
}
map<int, int> colmas[500000], colmenos[500000], filmas[500000],
filmenos[500000];
set<pair<int, int> > todos;
void simular(int i, int j, int d) {
for (;;) {
if (d == 0) {
map<int, int>::iterator it = filmas[i].upper_bound(j);
if (it->second) return;
it->second = 1;
j = (it->first) - 1;
if (todos.count(pair<int, int>(i - 1, j))) {
if (todos.count(pair<int, int>(i + 1, j))) return;
colmenos[j][i - 1] = 1;
d = 3;
} else if (todos.count(pair<int, int>(i + 1, j))) {
colmas[j][i + 1] = 1;
d = 1;
} else
return;
} else if (d == 1) {
map<int, int>::iterator it = colmenos[j].upper_bound(i);
it--;
if (it->second) return;
it->second = 1;
i = (it->first) + 1;
if (todos.count(pair<int, int>(i, j - 1))) {
if (todos.count(pair<int, int>(i, j + 1))) return;
filmenos[i][j - 1] = 1;
d = 0;
} else if (todos.count(pair<int, int>(i, j + 1))) {
filmas[i][j + 1] = 1;
d = 2;
} else
return;
} else if (d == 2) {
map<int, int>::iterator it = filmenos[i].upper_bound(j);
it--;
if (it->second) return;
it->second = 1;
j = (it->first) + 1;
if (todos.count(pair<int, int>(i - 1, j))) {
if (todos.count(pair<int, int>(i + 1, j))) return;
colmenos[j][i - 1] = 1;
d = 3;
} else if (todos.count(pair<int, int>(i + 1, j))) {
colmas[j][i + 1] = 1;
d = 1;
} else
return;
} else if (d == 3) {
map<int, int>::iterator it = colmas[j].upper_bound(i);
if (it->second) return;
it->second = 1;
i = (it->first) - 1;
if (todos.count(pair<int, int>(i, j - 1))) {
if (todos.count(pair<int, int>(i, j + 1))) return;
filmenos[i][j - 1] = 1;
d = 0;
} else if (todos.count(pair<int, int>(i, j + 1))) {
filmas[i][j + 1] = 1;
d = 2;
} else
return;
}
}
}
int n, m, k;
void cambio(int i, int j, int &ii, int &jj) {
ii = i + j;
jj = i - j + m + 1;
}
void insert(int i, int j) {
int ii, jj;
cambio(i, j, ii, jj);
todos.insert(pair<int, int>(ii, jj));
colmenos[jj][ii];
colmas[jj][ii];
filmenos[ii][jj];
filmas[ii][jj];
}
int primero = 1 << 19;
const int tope = 1 << 20;
int cuantos[tope];
void insertar(int pos, int val) {
pos += primero;
cuantos[pos] = val;
while (pos > 1) {
pos /= 2;
cuantos[pos] = cuantos[2 * pos] + cuantos[2 * pos + 1];
}
}
int cuantosentre(int inf, int sup) {
inf += primero;
sup += primero;
if (inf > sup) return 0;
if (inf == sup) return cuantos[inf];
int c = cuantos[inf] + cuantos[sup];
while (inf + 1 < sup) {
if (inf % 2 == 0) c += cuantos[inf + 1];
inf /= 2;
if (sup % 2 == 1) c += cuantos[sup - 1];
sup /= 2;
}
return c;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i <= n + 1; i++) {
insert(i, 0);
insert(i, m + 1);
}
for (int j = 0; j <= m + 1; j++) {
insert(0, j);
insert(n + 1, j);
}
for (int d = 0; d < k; d++) {
int i, j;
cin >> i >> j;
insert(i, j);
}
int ii, jj;
string dir;
cin >> ii >> jj >> dir;
int i, j;
cambio(ii, jj, i, j);
if (dir == "NE" or dir == "SW") {
simular(i, j, 0);
simular(i, j, 2);
} else {
simular(i, j, 1);
simular(i, j, 3);
}
long long int sol =
cuenta(filmas, n + 1 + m + 1 + 1) + cuenta(colmas, n + 1 + m + 1 + 1);
map<int, vector<int> > poner, quitar;
for (int j = 0; j < n + 1 + m + 1 + 1; j++) {
map<int, int> &mapa = colmas[j];
map<int, int>::iterator it = mapa.begin();
if (it != mapa.end()) {
int pos = it->first;
it++;
while (it != mapa.end()) {
int nextpos = it->first;
if (it->second) {
poner[pos + 2].push_back(j);
quitar[nextpos - 2].push_back(j);
}
pos = nextpos;
it++;
}
}
}
for (int i = 0; i < n + 1 + m + 1 + 1; i++) {
vector<int> &po = poner[i];
for (int jj = 0; jj < int(po.size()); jj++) insertar(po[jj], 1);
map<int, int> &mapa = filmas[i];
map<int, int>::iterator it = mapa.begin();
if (it != mapa.end()) {
int pos = it->first;
it++;
while (it != mapa.end()) {
int nextpos = it->first;
if (it->second) sol -= cuantosentre(pos + 2, nextpos - 2);
pos = nextpos;
it++;
}
}
vector<int> &qi = poner[i];
for (int jj = 0; jj < int(qi.size()); jj++) insertar(qi[jj], 0);
}
cout << sol << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<int> lcs(vector<int> &seq) {
int m = seq.size();
vector<int> ret(m);
vector<int> a;
for (int i = 0; i < m; ++i) {
if (a.size() == 0) {
a.push_back(seq[i]);
ret[i] = 1;
} else {
if (seq[i] >= a.back()) {
a.push_back(seq[i]);
ret[i] = a.size();
} else {
int index = upper_bound(a.begin(), a.end(), seq[i]) - a.begin();
a[index] = seq[i];
ret[i] = index;
};
};
};
return ret;
}
int main() {
int n, m;
cin >> n >> m;
vector<pair<int, int>> events;
for (int i = 0; i < m; ++i) {
events.push_back(make_pair(i, 1));
};
for (int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
l--;
r--;
events.push_back(make_pair(l, 0));
events.push_back(make_pair(r, 2));
};
sort(events.begin(), events.end());
vector<int> count(m);
int temp = 0;
for (auto p : events) {
if (p.second == 0) {
temp++;
} else if (p.second == 1) {
count[p.first] = temp;
} else {
temp--;
};
};
auto p = lcs(count);
reverse(count.begin(), count.end());
auto q = lcs(count);
reverse(q.begin(), q.end());
int ans = 0;
for (int i = 0; i < m; ++i) {
int val = p[i] + q[i] - 1;
ans = max(ans, val);
};
cout << ans << endl;
};
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int cas = 1; cas <= t; cas++) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int start = (n - 1) / 2;
int end = n / 2;
while (start >= 0 && end < n) {
if (start == end) {
cout << a[start] << " ";
} else {
cout << a[start] << " " << a[end] << " ";
}
start--;
end++;
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-7;
pair<int, int> v[2022];
int t[2022];
vector<int> a;
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (n); i++) {
scanf("%d", &v[i].first);
v[i].second = i + 1;
}
sort(v, v + n);
for (int i = 1; i < (n); i++) {
if (v[i].first == v[i - 1].first) {
a.push_back(i);
}
}
if (a.size() < 2)
printf("NO\n");
else {
printf("YES\n");
for (int i = 0; i < (n); i++) printf("%d ", v[i].second);
puts("");
swap(v[a[0]], v[a[0] - 1]);
for (int i = 0; i < (n); i++) printf("%d ", v[i].second);
puts("");
swap(v[a[1]], v[a[1] - 1]);
for (int i = 0; i < (n); i++) printf("%d ", v[i].second);
puts("");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct fast_ios {
fast_ios() {
cin.tie(nullptr), ios::sync_with_stdio(false),
cout << fixed << setprecision(20);
};
} fast_ios_;
template <class T>
auto add = [](T a, T b) -> T { return a + b; };
template <class T>
auto f_max = [](T a, T b) -> T { return max(a, b); };
template <class T>
auto f_min = [](T a, T b) -> T { return min(a, b); };
template <class T>
using V = vector<T>;
using Vl = V<long long int>;
using VVl = V<Vl>;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < (int)v.size(); i++)
os << v[i] << (i + 1 != v.size() ? " " : "");
return os;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (T& in : v) is >> in;
return is;
}
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T& a, const T& b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
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 ceil(long long int a, long long int b) { return (a + b - 1) / b; }
long long int digit(long long int a) { return (long long int)log10(a); }
long long int dist(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return abs(a.first - b.first) * abs(a.first - b.first) +
abs(a.second - b.second) * abs(a.second - b.second);
}
long long int m_dist(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
void Worshall_Floyd(VVl& g) {
for (long long int k = (0), k_end_ = (((long long int)(g).size()));
k < k_end_; ++k)
for (long long int i = (0), i_end_ = (((long long int)(g).size()));
i < i_end_; ++i)
for (long long int j = (0), j_end_ = (((long long int)(g).size()));
j < j_end_; ++j)
chmin(g[i][j], g[i][k] + g[k][j]);
}
const long long int MOD = 1e9 + 7, INF = 1e18;
long long int dx[8] = {1, 0, -1, 0, 1, -1, 1, -1},
dy[8] = {0, 1, 0, -1, -1, -1, 1, 1};
bool YN(bool flag) {
cout << (flag ? "YES" : "NO") << '\n';
return flag;
}
bool yn(bool flag) {
cout << (flag ? "Yes" : "No") << '\n';
return flag;
}
struct Edge {
long long int from, to;
long long int cost;
Edge(long long int u, long long int v, long long int c) {
cost = c;
from = u;
to = v;
}
bool operator<(const Edge& e) const { return cost < e.cost; }
};
struct WeightedEdge {
long long int to;
long long int cost;
WeightedEdge(long long int v, long long int c = 1) {
to = v;
cost = c;
}
bool operator<(const WeightedEdge& e) const { return cost < e.cost; }
};
using WeightedGraph = V<V<WeightedEdge>>;
struct UnionFind {
public:
UnionFind() : _n(0) {}
UnionFind(int n) : _n(n), parent_or_size(n, -1) {}
int merge(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
int x = leader(a), y = leader(b);
if (x == y) return x;
if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y);
if (used_count) {
if (count_in_set[x].size() < count_in_set[y].size()) {
std::swap(count_in_set[x], count_in_set[y]);
}
for (auto p : count_in_set[y]) {
count_in_set[x][p.first] += p.second;
}
}
if (set_operate) {
root_values[x] = f(root_values[y], root_values[x]);
}
parent_or_size[x] += parent_or_size[y];
parent_or_size[y] = x;
return x;
}
bool same(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
return leader(a) == leader(b);
}
int leader(int a) {
assert(0 <= a && a < _n);
if (parent_or_size[a] < 0) return a;
return parent_or_size[a] = leader(parent_or_size[a]);
}
int size(int a) {
assert(0 <= a && a < _n);
return -parent_or_size[leader(a)];
}
std::vector<std::vector<int>> groups() {
std::vector<int> leader_buf(_n), group_size(_n);
for (int i = 0; i < _n; i++) {
leader_buf[i] = leader(i);
group_size[leader_buf[i]]++;
}
std::vector<std::vector<int>> result(_n);
for (int i = 0; i < _n; i++) {
result[i].reserve(group_size[i]);
}
for (int i = 0; i < _n; i++) {
result[leader_buf[i]].push_back(i);
}
result.erase(
std::remove_if(result.begin(), result.end(),
[&](const std::vector<int>& v) { return v.empty(); }),
result.end());
return result;
}
void set_operate_and_value(
std::vector<long long int> array,
function<long long int(long long int, long long int)> _f) {
f = _f;
root_values = array;
set_operate = true;
}
long long int get_set_value(int a) { return root_values[leader(a)]; }
void regist_count(int a, int label) {
if (!used_count) {
used_count = true;
count_in_set.assign(_n, std::map<int, int>());
}
count_in_set[leader(a)][label]++;
}
int get_count(int a, int label) {
if (!used_count) return -1;
return count_in_set[leader(a)][label];
}
private:
int _n;
std::vector<int> parent_or_size;
std::vector<std::map<int, int>> count_in_set;
bool used_count = false;
std::vector<long long int> root_values;
function<long long int(long long int, long long int)> f;
bool set_operate = false;
};
long long int N, l, r;
int main() {
cin >> N;
V<pair<long long int, long long int>> arr(N);
for (long long int i = (0), i_end_ = (N); i < i_end_; ++i) {
cin >> l >> r;
l--;
r--;
arr[i] = {l, r};
}
sort((arr).begin(), (arr).end());
UnionFind tree(N * 2);
set<pair<long long int, long long int>> st;
VVl to(N, Vl());
long long int cnt = 0;
for (long long int i = (0), i_end_ = (N); i < i_end_; ++i) {
while (!st.empty() && (*st.begin()).first < arr[i].first) {
st.erase(st.begin());
}
for (pair<long long int, long long int> v : st) {
if (v.first > arr[i].second) break;
to[i].push_back(v.second);
to[v.second].push_back(i);
cnt++;
}
if (cnt >= N) break;
st.insert({arr[i].second, i});
}
for (long long int i = (0), i_end_ = (N); i < i_end_; ++i) {
for (long long int v : to[i]) tree.merge(i, v);
}
YN(cnt == N - 1 && tree.size(0) == N);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long v[1000], f[1000], n, vis[10000], anss, i, o;
struct node {
long long a[10];
} ans[100000];
long long calc(long long l, long long r) {
long long tmp = 0, p = 1;
for (long long i = r; i >= l; i--) {
tmp += v[i] * p;
p = p * 10;
}
return tmp;
}
bool pan(long long l, long long r) {
if (l == r && v[l] == 0) return true;
if (v[l] == 0) return false;
long long tmp = 0, p = 1;
for (long long i = r; i >= l; i--) {
tmp += v[i] * p;
p = p * 10;
}
if (tmp < 256) return true;
return false;
}
void check(long long y) {
for (long long i = 1; i <= y / 2; i++) v[y - i + 1] = v[i];
for (long long i = 0; i <= 10; i++) vis[i] = 0;
if (v[1] == 0 && v[2] == 1 && v[3] == 8 && v[4] == 9) v[1] = v[1];
long long cnt = 0;
for (long long i = 1; i <= y / 2 + 1; i++)
if (vis[v[i]] == 0) vis[v[i]] = 1, cnt++;
if (cnt != n) return;
for (long long a = 1; a <= y - 3; a++) {
if (!pan(1, a)) continue;
for (long long b = a + 1; b <= y - 2; b++) {
if (!pan(a + 1, b)) continue;
for (long long c = b + 1; c <= y - 1; c++) {
if (!pan(b + 1, c)) continue;
if (!pan(c + 1, y)) continue;
anss++;
ans[anss].a[1] = calc(1, a);
ans[anss].a[2] = calc(a + 1, b);
ans[anss].a[3] = calc(b + 1, c);
ans[anss].a[4] = calc(c + 1, y);
if (ans[anss].a[1] == 0 && ans[anss].a[2] == 18 && ans[anss].a[3] == 98)
n = n;
}
}
}
}
void dfs(long long x, long long y) {
if (x == y / 2 + 2) {
check(y);
return;
}
for (long long k = 0; k <= 10; k++) {
if (f[k]) v[x] = k, dfs(x + 1, y);
}
}
bool cmp(node x, node y) {
if (x.a[1] == y.a[1]) {
if (x.a[2] == y.a[2]) {
if (x.a[3] == y.a[3]) {
return x.a[4] < y.a[4];
}
return x.a[3] < y.a[3];
}
return x.a[2] < y.a[2];
}
return x.a[1] < y.a[1];
}
int main() {
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &o), f[o] = 1;
}
for (i = 4; i <= 12; i++) {
dfs(1, i);
}
sort(ans + 1, ans + anss + 1, cmp);
int t = 0;
ans[0].a[1] = -1;
for (i = 1; i <= anss; i++)
if (ans[i].a[1] != ans[i - 1].a[1] || ans[i].a[2] != ans[i - 1].a[2] ||
ans[i].a[3] != ans[i - 1].a[3] || ans[i].a[4] != ans[i - 1].a[4])
t++;
cout << t << endl;
for (i = 1; i <= anss; i++)
if (ans[i].a[1] != ans[i - 1].a[1] || ans[i].a[2] != ans[i - 1].a[2] ||
ans[i].a[3] != ans[i - 1].a[3] || ans[i].a[4] != ans[i - 1].a[4])
printf("%I64d.%I64d.%I64d.%I64d\n", ans[i].a[1], ans[i].a[2], ans[i].a[3],
ans[i].a[4]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<char> data;
string s;
string ans = "";
bool ddddd = false;
int main() {
int n;
cin >> n;
cin >> s;
data.insert('a');
data.insert('y');
data.insert('i');
data.insert('o');
data.insert('u');
data.insert('e');
for (int i = 0; i < s.size(); i++) {
if (data.find(s[i]) == data.end()) {
ddddd = false;
ans = ans + s[i];
} else {
if (!ddddd) {
ddddd = true;
ans = ans + s[i];
}
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n + 1];
map<long long int, vector<long long int>> m;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
m[a[i]].push_back(i);
}
long long int ans[n + 1];
for (long long int i = 1; i <= n; i++) ans[i] = 1000000;
for (auto it = m.begin(); it != m.end(); it++) {
long long int e = it->first;
vector<long long int> v = it->second;
long long int maxgap = v[0];
long long int si = v.size();
for (long long int i = 1; i < si; i++)
maxgap = max(maxgap, v[i] - v[i - 1]);
maxgap = max(maxgap, n + 1 - v[si - 1]);
ans[maxgap] = min(ans[maxgap], e);
}
long long int ele = ans[1];
for (long long int i = 1; i <= n; i++) {
ans[i] = min(ele, ans[i]);
ele = ans[i];
if (ans[i] == 1000000)
cout << -1 << " ";
else
cout << ans[i] << " ";
}
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gi() {
char cc = getchar();
long long 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 long long N = 1e6 + 5;
const long long inf = 1e18 + 7;
long long n, m, p, a[N], S;
struct Tr {
long long sum, len;
vector<long long> f;
} tr[N << 2];
void pushup(long long x) {
vector<long long> l = tr[(x << 1)].f, r = tr[(x << 1 | 1)].f;
vector<long long> c;
c.resize(tr[x].len + 1);
for (register long long i = (0); i <= (tr[x].len); ++i) c[i] = inf;
long long j = 0;
for (long long i = 0; i < l.size(); ++i) {
long long d = i * p - tr[(x << 1)].sum;
if (j) --j;
for (; j < r.size(); ++j) {
long long res = max(l[i], r[j] + d);
c[i + j] = min(c[i + j], res);
if (i != (l.size() - 1)) {
long long mx = l[i + 1] - d;
if (mx <= r[j]) {
if (j) --j;
break;
}
}
}
}
tr[x].f = c, tr[x].sum = tr[(x << 1)].sum + tr[(x << 1 | 1)].sum;
}
void build(long long x, long long l, long long r) {
tr[x].len = r - l + 1;
if (l == r) {
tr[x].sum = a[l], tr[x].f.push_back(-inf), tr[x].f.push_back(p - a[l]);
return;
}
long long mid = (l + r) >> 1;
build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r), pushup(x);
}
void query(long long x, long long l, long long r, long long ql, long long qr) {
if (ql <= l && r <= qr) {
long long res =
upper_bound(tr[x].f.begin(), tr[x].f.end(), S) - tr[x].f.begin() - 1;
S = S + tr[x].sum - res * p;
return;
}
if (qr < l || ql > r) return;
long long mid = (l + r) >> 1;
query((x << 1), l, mid, ql, qr), query((x << 1 | 1), mid + 1, r, ql, qr);
}
void Q(long long l, long long r) {
S = 0, query(1, 1, n, l, r), printf("%lld\n", S);
}
signed main() {
n = gi(), m = gi(), p = gi();
for (register long long i = (1); i <= (n); ++i) a[i] = gi();
build(1, 1, n);
long long l, r;
while (m--) l = gi(), r = gi(), Q(l, r);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int OO = (int)1e8;
double arr[200001];
int t;
bool isok(double x) {
double pos = 0;
int tot = 0;
while (1) {
int idx = upper_bound(arr, arr + t, pos) - arr;
if (idx >= t) break;
tot++;
pos = arr[idx] + 2 * x;
}
return tot <= 3;
}
void build(double x) {
double pos = 0;
int tot = 0;
while (1) {
int idx = upper_bound(arr, arr + t, pos) - arr;
if (idx >= t) break;
if (tot) printf(" ");
printf("%.6lf", arr[idx] + x);
tot++;
pos = arr[idx] + 2 * x;
}
while (tot < 3) {
tot++;
printf(" %.6lf", pos);
}
}
int main() {
scanf("%d", &t);
double end = 0;
for (int i = 0; i < t; ++i) {
scanf("%lf", arr + i);
end += arr[i];
}
sort(arr, arr + t);
double st = 0, sz = end / 2, ret;
while (sz > 1e-7) {
double mid = st + sz;
if (isok(mid)) {
ret = mid;
} else
st = mid;
sz *= 0.5;
}
ret *= 1000000;
ret = round(ret);
ret /= 1000000;
if (ret < 1e-7)
printf("0\n");
else
printf("%.6lf\n", ret);
build(ret);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5010;
const int MAXM = 3e5 + 10;
const int INF = 1e9 + 7;
int a[MAXN];
int b[MAXN];
int c[MAXN];
vector<pair<int, int> > portals[MAXN];
vector<pair<int, int> > real_portals[MAXN];
int reachable_by[MAXN];
int dp[MAXN][MAXN];
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
portals[u].push_back(make_pair(-c[v], v));
}
for (int u = 1; u <= n; u++) {
portals[u].push_back(make_pair(-c[u], u));
sort(portals[u].begin(), portals[u].end());
for (int i = 0; i < portals[u].size(); i++) {
int v = portals[u][i].second;
reachable_by[v] = u;
}
}
for (int u = 1; u <= n; u++) {
for (int i = 0; i < portals[u].size(); i++) {
int v = portals[u][i].second;
if (reachable_by[v] == u) {
real_portals[u].push_back(make_pair(-c[v], v));
}
}
}
memset(dp, -1, sizeof(dp));
dp[0][k] = 0;
for (int i = 1; i <= n; i++) {
for (int j = a[i]; j < MAXN; j++) {
if (dp[i - 1][j] == -1) {
continue;
}
int newj = j + b[i];
int extra_score = 0;
for (int k = 0; k <= real_portals[i].size(); k++) {
if (newj - k < 0) {
continue;
}
if (k > 0) {
extra_score += (-1 * real_portals[i][k - 1].first);
}
dp[i][newj - k] = max(dp[i][newj - k], dp[i - 1][j] + extra_score);
}
}
}
int ans = -INF;
for (int i = 0; i < MAXN; i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long inf = 1e8;
const int MAXM = 1e5 + 5;
const int MAXN = 1e6 + 4;
long long pre[MAXM], a[MAXM];
int main() {
int n, m, i, j, k;
scanf("%d", &n);
scanf("%d", &m);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
}
long long Ans1 = -1, Ans2 = -1;
for (i = 1; i <= n; i++) {
int lo = 0, hi = i;
while (lo <= hi) {
long long mid = lo + (hi - lo + 1) / 2;
long long Ans = pre[i] - pre[mid];
long long ne = i - mid;
if (1LL * ne * a[i] <= Ans + m) {
hi = mid - 1;
if (Ans1 < ne) {
Ans1 = ne;
Ans2 = a[i];
}
} else {
lo = mid + 1;
}
}
}
cout << Ans1 << " " << Ans2 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<long long int, long long int> > > roads(1005);
vector<vector<pair<long long int, long long int> > > drivers(1005);
long long int dis[1005][1005], v[1005], st, n, en, fl;
void dfs(long long int stra, long long int rem, long long int cos) {
long long int dist[1005];
for (long long int i = 1; i <= n; i++) {
dist[i] = 1e14 + 54;
}
dist[stra] = 0;
multiset<pair<long long int, long long int> > s;
s.insert(make_pair(0, stra));
while (!s.empty()) {
pair<long long int, long long int> p = *s.begin();
s.erase(s.begin());
long long int w = p.first, x = p.second;
if (v[x]) {
continue;
}
v[x] = 1;
for (long long int i = 0; i < roads[x].size(); i++) {
long long int y = roads[x][i].first, wei = roads[x][i].second;
if (dist[x] + wei < dist[y]) {
dist[y] = dist[x] + wei;
s.insert(make_pair(dist[y], y));
}
}
}
for (long long int i = 1; i <= n; i++) {
if (dist[i] <= rem) {
dis[stra][i] = min(dis[stra][i], cos);
}
}
}
void dijs() {
long long int dist[1005];
for (long long int i = 1; i <= n; i++) {
v[i] = 0;
dist[i] = 1e14 + 54;
}
dist[st] = 0;
multiset<pair<long long int, long long int> > s;
s.insert(make_pair(0, st));
while (!s.empty()) {
pair<long long int, long long int> p = *s.begin();
s.erase(s.begin());
long long int w = p.first, x = p.second;
if (v[x]) {
continue;
}
v[x] = 1;
for (long long int i = 0; i < drivers[x].size(); i++) {
long long int y = drivers[x][i].first, wei = drivers[x][i].second;
if (dist[x] + wei < dist[y]) {
dist[y] = dist[x] + wei;
s.insert(make_pair(dist[y], y));
}
}
}
if (dist[en] == 1e14 + 54) {
fl = -1;
} else {
fl = dist[en];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int m, i, j, x, y, w;
cin >> n >> m >> st >> en;
while (m--) {
cin >> x >> y >> w;
roads[x].push_back(make_pair(y, w));
roads[y].push_back(make_pair(x, w));
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
dis[i][j] = 1e14 + 54;
}
}
for (i = 1; i <= n; i++) {
cin >> x >> w;
for (j = 1; j <= n; j++) {
v[j] = 0;
}
dfs(i, x, w);
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
drivers[i].push_back(make_pair(j, dis[i][j]));
}
}
dijs();
if (fl < 0) {
cout << -1;
} else {
cout << fl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace FGF {
int n, m;
const int N = 1e5 + 5;
char s[N], a[10], b[10];
int mp[500005], id, pos[8][N], h[N], cnt, f[510][N], len[N];
vector<int> g[N];
int getnum(char *s, int l) {
int num = 0;
for (int i = 0; i < l; i++) num = num * 26 + s[i] - 'a' + 1;
return num;
}
void work() {
scanf("%s%d", s + 1, &m);
n = strlen(s + 1);
for (int l = 1; l < 5; l++) {
for (int i = 1; i <= n - l + 1; i++) {
int num = getnum(s + i, l);
if (!mp[num]) mp[num] = ++id, len[id] = l;
pos[l][i] = mp[num];
g[mp[num]].push_back(i);
}
}
memset(f, 0x3f, sizeof(f));
for (int i = 1; i <= id; i++) {
int siz = g[i].size();
if (siz >= 500) {
h[i] = ++cnt;
for (int j = 1; j < siz; j++) {
int x = g[i][j - 1], y = g[i][j];
for (int k = x; k <= y; k++)
for (int l = 1; l <= 4; l++)
f[cnt][pos[l][k]] = min(
f[cnt][pos[l][k]],
min(max(x + len[i], k + l) - x, max(y + len[i], k + l) - k));
}
for (int k = g[i][siz - 1], x = k; k <= n; k++)
for (int l = 1; l <= 4; l++)
f[cnt][pos[l][k]] =
min(f[cnt][pos[l][k]], max(x + len[i], k + l) - x);
for (int k = 1, x = g[i][0]; k < g[i][0]; k++)
for (int l = 1; l <= 4; l++)
f[cnt][pos[l][k]] =
min(f[cnt][pos[l][k]], max(x + len[i], k + l) - k);
}
}
while (m--) {
scanf("%s%s", a + 1, b + 1);
int x = mp[getnum(a + 1, strlen(a + 1))],
y = mp[getnum(b + 1, strlen(b + 1))];
if (!x || !y)
puts("-1");
else if (h[x])
printf("%d\n", f[h[x]][y]);
else if (h[y])
printf("%d\n", f[h[y]][x]);
else {
int siz1 = g[x].size(), siz2 = g[y].size(), k = 0, ans = 0x3f3f3f3f;
for (int i = 0; i < siz1; i++) {
while (k < siz2 - 1 && g[x][i] > g[y][k]) k++;
ans = min(ans, max(g[x][i] + len[x], g[y][k] + len[y]) -
min(g[x][i], g[y][k]));
if (k)
ans = min(ans, max(g[x][i] + len[x], g[y][k - 1] + len[y]) -
min(g[x][i], g[y][k - 1]));
}
printf("%d\n", ans);
}
}
}
} // namespace FGF
int main() {
FGF::work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str, b;
cin >> str;
for (int i = 0; i < str.size(); ++i)
if ((str[i] == '[') || (str[i] == ']') || (str[i] == ':') ||
(str[i] == '|'))
b += str[i];
int i = 0, j = 0, k = 0, m;
int max_len = -1;
int cur_len = 0;
int str_len = b.length();
if (str_len < 4) {
cout << -1 << '\n';
return 0;
}
while (i < str_len) {
while (i < str_len && b[i] != '[') i++;
if (i < str_len)
cur_len++;
else
break;
while (i < str_len && b[i] != ':') i++;
if (i < str_len)
cur_len++;
else
break;
j = str_len - 1;
while (j > i && b[j] != ']') j--;
if (j > i)
cur_len++;
else
break;
while (j > i && b[j] != ':') j--;
if (j > i)
cur_len++;
else
break;
while (i < j) {
if (b[i] == '|') cur_len++;
i++;
}
if (cur_len >= 4) max_len = cur_len;
}
cout << max_len << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
int tr[10005][2], fa[10005], dp[2][10005][105], minn;
int p, m;
void dfs(int id) {
if (!tr[id][0]) return;
int l = tr[id][0], r = tr[id][1];
dfs(l);
dfs(r);
for (int i = 0; i <= minn; i++) {
for (int j = 0; j + i <= minn; j++) {
dp[0][id][i + j + (p < m)] =
max(dp[0][id][i + j + (p < m)], dp[0][l][i] + dp[0][r][j]);
dp[0][id][i + j + (p >= m)] =
max(dp[0][id][i + j + (p >= m)], dp[0][l][i] - dp[1][r][j]);
dp[1][id][i + j + (p < m)] =
min(dp[1][id][i + j + (p < m)], dp[1][l][i] + dp[1][r][j]);
dp[1][id][i + j + (p >= m)] =
min(dp[1][id][i + j + (p >= m)], dp[1][l][i] - dp[0][r][j]);
}
}
}
int main() {
ios::sync_with_stdio(false);
char s[10005];
cin >> s + 1;
cin >> p >> m;
memset(dp[0], -63, sizeof(dp[0]));
memset(dp[1], 63, sizeof(dp[1]));
minn = min(p, m);
int size = 1, pre = size;
for (int i = 1; i <= strlen(s + 1); i++) {
if (s[i] == '(' || s[i] == '?') {
tr[pre][tr[pre][0] ? 1 : 0] = ++size;
fa[size] = pre;
pre = size;
} else if (s[i] == ')')
pre = fa[pre];
else
dp[0][size][0] = dp[1][size][0] = s[i] - '0', pre = fa[pre];
}
dfs(1);
cout << dp[0][1][minn] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
int t, ii, i, j, n, flag;
string s;
cin >> t;
for (ii = 0; ii < t; ii++) {
flag = 0;
cin >> n >> s;
i = 0;
j = s.length() - 1;
while (i < j) {
if (s[i] == s[j] || abs(s[i] - s[j]) == 2) {
i++;
j--;
continue;
} else {
flag = 1;
cout << "NO\n";
break;
}
}
if (flag == 0) cout << "YES\n";
}
return (0);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char _;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
string val;
cin >> val;
if (val.length() < 3) {
cout << "0\n";
continue;
}
vector<int> prefix;
prefix.push_back(0);
for (int i = 0; i < val.length(); i++) {
if (val[i] == '1') {
prefix.push_back(prefix[i] + 1);
} else {
prefix.push_back(prefix[i]);
}
}
int best = min(prefix[(int)val.length()],
(int)val.length() - prefix[(int)val.length()]);
for (int i = 0; i < val.length(); i++) {
int z = prefix[i + 1] + ((int)val.length() - (i + 1)) -
(prefix[(int)val.length()] - prefix[i + 1]);
int o = (i + 1) - prefix[i + 1] + prefix[val.length()] - prefix[i + 1];
best = min(best, min(z, o));
}
cout << best << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int mod = 1e9 + 7;
int n, k, l, r, mid, pos;
long long w;
bool f[N], vis[N];
vector<int> ans;
long long check(int mid) {
long long res = 0;
for (int i = (1); i < (mid + 1); i++) res += mid / i - 1;
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
l = 1;
r = n;
pos = -1;
while (l <= r) {
mid = l + r >> 1;
long long tmp = check(mid);
if (tmp >= k) {
pos = mid;
w = tmp;
r = mid - 1;
} else
l = mid + 1;
}
if (pos == -1)
cout << "No";
else {
for (int i = (2); i < (pos + 1); i++)
if (!f[i])
for (int j = i + i; j <= pos; j += i) f[j] = 1;
for (int i = (2); i < (pos + 1); i++)
if (!f[i] && w - k >= pos / i) {
w -= pos / i;
vis[i] = 1;
}
for (int i = (1); i < (pos + 1); i++)
if (!vis[i]) ans.push_back(i);
cout << "Yes\n" << (int)ans.size() << "\n";
for (int i = (0); i < ((int)ans.size()); i++) cout << ans[i] << " ";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
long long modpow(long long a, long long n, long long mod = MOD) {
long long res = 1;
while (n > 0) {
if (n & 1) (res *= a) %= mod;
(a *= a) %= mod;
n >>= 1;
}
return res;
}
long long sum_power(long long r, long long n, long long mod = MOD) {
if (n == 0) return 0;
if (n & 1) return (sum_power(r, n - 1) + modpow(r, n - 1)) % mod;
return (1 + modpow(r, n >> 1)) * sum_power(r, n >> 1) % mod;
}
int main() {
string s;
cin >> s;
int n = s.length();
int k;
cin >> k;
long long sum = 0;
for (int i = 0; i < n; i++)
if (s[i] == '0' || s[i] == '5') {
(sum += modpow(2, i)) %= MOD;
}
cout << sum * sum_power(modpow(2, n), k) % MOD << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t, n, c0, c1, h;
string s;
cin >> t;
while (t--) {
cin >> n >> c0 >> c1 >> h;
cin >> s;
int cant1 = 0, cant0 = 0;
for (int i = 0; i < n; ++i) {
cant1 += (s[i] == '1');
cant0 += (s[i] == '0');
}
int ans = cant1 * c1 + cant0 * c0;
for (int i = 0; i <= n; ++i) {
int aux = i * c0 + (n - i) * c1;
aux += abs(i - cant0) * h;
ans = min(ans, aux);
}
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, cnt, maxn, minn;
int a[1010], dl[1010];
map<long long, int> Q;
int main() {
scanf("%d", &n);
maxn = -1000000000;
minn = 1000000000;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (!Q.count(a[i]))
Q[a[i]] = 1;
else
Q[a[i]]++;
maxn = max(a[i], maxn);
minn = min(a[i], minn);
}
ans = 2;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j) {
Q[a[i]]--;
Q[a[j]]--;
cnt = 0;
dl[++cnt] = a[i];
dl[++cnt] = a[j];
while (dl[cnt] + dl[cnt - 1] <= maxn && dl[cnt] + dl[cnt - 1] >= minn &&
Q.count(dl[cnt] + dl[cnt - 1]) && Q[dl[cnt] + dl[cnt - 1]] > 0) {
cnt++;
dl[cnt] = dl[cnt - 1] + dl[cnt - 2];
Q[dl[cnt - 1] + dl[cnt - 2]]--;
if (!dl[cnt] && !dl[cnt - 1]) {
ans = max(ans, cnt + Q[0]);
break;
}
}
ans = max(ans, cnt);
while (cnt) Q[dl[cnt--]]++;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long dx[4] = {-1, 1, 0, 0};
const long long dy[4] = {0, 0, -1, 1};
const long long MAX = 3e5;
const long long oo = 1e16;
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long n, m, k, Q, l, x, y, ans;
string second;
long long a[MAX];
typedef struct Vehicule {
int from;
int to;
long long cons;
int refuel;
};
Vehicule v[MAX];
long long dp[500][500];
vector<vector<int> > st;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
st.clear();
st.resize(n + 1);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < m; ++i) {
cin >> v[i].from >> v[i].to >> v[i].cons >> v[i].refuel;
v[i].from--;
v[i].to--;
st[v[i].from].push_back(i);
}
ans = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) dp[i][j] = oo;
for (int l = 0; l < n; ++l) {
for (int r = l; r < n; ++r) dp[r][1] = a[r] - a[l];
for (int r = l + 1; r < n; ++r)
for (int k = 2; k < n + 5; ++k) {
long long best = oo;
int j = r;
while (j >= l && max(dp[j][k - 1], a[r] - a[j]) <= best)
best = max(dp[j][k - 1], a[r] - a[j]), --j;
dp[r][k] = best;
}
for (auto u : st[l])
ans = max(ans, dp[v[u].to][v[u].refuel + 1] * 1LL * v[u].cons);
}
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void seif() { std::ios_base::sync_with_stdio(0); }
int fmp[30], smp[30];
int main() {
seif();
string s1, s2;
cin >> s1 >> s2;
if (s1.length() != s2.length()) return cout << "NO", 0;
for (int i = 0; i < s1.length(); i++) {
fmp[s1[i] - 'a']++;
smp[s2[i] - 'a']++;
}
for (int i = 0; i < 30; i++) {
if (fmp[i] != smp[i]) return cout << "NO", 0;
}
int ans = 0;
for (int i = 0; i < s1.length(); i++) {
if (s1[i] != s2[i]) ans++;
}
if (ans == 2)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const unsigned M1 = 100007;
const unsigned M2 = 100021;
const unsigned P = 101;
long long fast_pow(long long b, long long e, long long m) {
if (e == 0) return 1;
if (e == 1) return b;
if (e % 2 == 0) {
return fast_pow((b * b) % m, e / 2, m) % m;
}
return b * fast_pow((b * b) % m, e / 2, m) % m;
}
int main() {
int n, m;
cin >> n >> m;
string p;
cin >> p;
if (m == 0) {
cout << fast_pow(26, n, 1000000007) << '\n';
return 0;
}
vector<int> pos(m);
for (int i = 0; i < m; ++i) {
cin >> pos[i];
}
int free_s = pos[0] - 1;
vector<bool> matches(p.size() + 1, true);
for (int i = 1; i < p.size(); ++i) {
for (int j = 0; j + i < p.size(); ++i) {
if (p[j] != p[j + i]) {
matches[i] = false;
break;
}
}
}
for (int i = 1; i < m; ++i) {
if (pos[i] - (int)p.size() > pos[i - 1]) {
free_s += pos[i] - pos[i - 1] - p.size();
} else {
int diff = pos[i] - pos[i - 1];
if (matches[diff] == false) {
cout << "0\n";
return 0;
}
}
}
free_s += max(0, (int)(n - pos[m - 1] - p.size() + 1));
cout << fast_pow(26, free_s, 1000000007ll) << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
string a;
string s;
int n;
int m;
int dp[5001][5001];
int main() {
cin >> a;
cin >> s;
n = a.size();
m = s.size();
memset(dp, 0, sizeof(dp));
for (int i = n - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) {
dp[i][j] = dp[i][j + 1];
if (a[i] == s[j]) dp[i][j] += dp[i + 1][j + 1] + 1;
dp[i][j] %= mod;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans += dp[i][0];
ans %= mod;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int a[1111], v[1111];
char hash[1111];
int main() {
int i, j, n, m, x, y, z, o = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &z);
a[x] = y;
hash[y] = 1;
v[x] = z;
}
for (i = 1; i <= n; i++) o += (!hash[i] && a[i]);
printf("%d\n", o);
for (i = 1; i <= n; i++)
if (!hash[i] && a[i]) {
m = 1000000000;
for (j = i; a[j]; j = a[j]) m = ((m) < (v[j]) ? (m) : (v[j]));
printf("%d %d %d\n", i, j, m);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int data[110][4];
bool outdated[110];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 4; j++) {
scanf("%d", &data[i][j]);
}
outdated[i] = false;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n && !outdated[i]; j++) {
if (i == j) continue;
if (data[i][0] < data[j][0] && data[i][1] < data[j][1] &&
data[i][2] < data[j][2])
outdated[i] = true;
}
}
int min = -1;
for (int i = 0; i < n; i++) {
if (!outdated[i]) {
if (min == -1 || data[i][3] < data[min][3]) min = i;
}
}
printf("%d\n", min + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline bool happy(int x) {
while (x) {
int cnt = x % 10;
if (cnt != 4 && cnt != 7) return 0;
x /= 10;
}
return 1;
}
int main() {
int n;
while (scanf("%d", &n) >= 1) {
vector<int> a(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
vector<int> b;
vector<bool> h;
for (int i = 0; i < n;) {
int cnt = 0;
while (i < n && !happy(a[i])) cnt++, i++;
if (cnt) {
b.push_back(cnt);
h.push_back(0);
}
if (i < n) {
b.push_back(a[i]);
h.push_back(1);
i++;
}
}
int m = b.size();
vector<int> pr(m + 2, 0);
for (int i = 1; i <= m; i++) pr[i] = pr[i - 1] + (h[i - 1] ? 1 : b[i - 1]);
pr[m + 1] = pr[m];
vector<int> next(m, m);
for (int i = m - 1; i >= 0; i--) {
if (!h[i]) continue;
for (int j = i + 1; j < m; j++)
if (h[j] && b[i] == b[j]) {
next[i] = j;
break;
}
}
long long ans = 0;
set<int> s;
vector<bool> taken;
for (int l = 0; l < m; l++) {
taken = vector<bool>(m, 0);
s.clear();
s.insert(m);
s.insert(l - 1);
long long now = ((long long)(pr[m] - pr[l])) * (pr[m] - pr[l] + 1) / 2;
long long ansp = 0;
for (int r = l; r < m; r++) {
if (!taken[r]) {
for (int v = r; v < m; v = next[v]) {
assert(!taken[v]);
taken[v] = 1;
set<int>::iterator iter = s.lower_bound(v);
assert(iter != s.begin());
int right = (*iter);
iter--;
int left = (*iter);
now -= ((long long)(pr[right] - pr[left + 1])) *
(pr[right] - pr[left + 1] + 1) / 2;
now += ((long long)(pr[right] - pr[v + 1])) *
(pr[right] - pr[v + 1] + 1) / 2;
now += ((long long)(pr[v] - pr[left + 1])) *
(pr[v] - pr[left + 1] + 1) / 2;
s.insert(v);
}
}
assert(now >= 0ll);
if (l == r)
ans += now * (h[l] ? 1 : (((long long)b[l]) * (b[l] + 1) / 2));
else
ansp += now * (h[r] ? 1 : b[r]);
if (!h[r]) {
int number = b[r];
set<int>::iterator iter = s.lower_bound(r + 1);
int right = (*iter);
int over = pr[right] - pr[r + 1];
if (l == r) {
long long cnt =
((((long long)number) * (number - 1) * (number - 2)) / 6);
if (cnt & 1)
cnt *= ((number - 3) / 4);
else {
if (cnt & 2) {
cnt /= 2;
cnt *= (number - 3) / 2;
} else
cnt /= 4, cnt *= number - 3;
}
ans += cnt;
cnt = ((((long long)number) * (number - 1) * (number - 2)) / 6);
ans += cnt * (over + 2);
ans += (((long long)number) * (number - 1) / 2) * (1 + over);
} else {
ansp += (((long long)number) * (number - 1) * (number - 2)) / 6;
ansp += (((long long)number) * (number - 1) / 2);
ansp += (((long long)number) * (number - 1) / 2) * over;
}
}
}
ans += ansp * (h[l] ? 1 : b[l]);
}
printf("%I64d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned n, m;
cin >> n >> m;
vector<unsigned> a(n + 1, 0);
vector<unsigned> b(n + 1, 0);
for (auto i = 0; i < n; ++i) {
unsigned aa, bb;
cin >> aa >> bb;
a[i] = aa;
b[i] = bb;
}
if (a[0] != 0) {
cout << "NO" << endl;
return 0;
}
unsigned maxb = 0;
for (auto i = 0; i < n; ++i) {
if (b[i] >= maxb) {
maxb = b[i];
}
if (maxb >= m) {
cout << "YES" << endl;
return 0;
}
if (i < n - 1 && maxb >= a[i + 1]) {
continue;
}
cout << "NO" << endl;
break;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int size = 110;
const int inf = 0x3f3f3f3f;
int n, a;
int dp[size][size];
int var[size], x[size], y[size];
bool vis[size];
int dist[size];
int Abs(int x) { return x > 0 ? x : -x; }
void work() {
for (int i = 1; i <= n; i++) {
dp[i][i] = inf;
for (int j = i + 1; j <= n; j++) {
dp[i][j] = dp[j][i] = (Abs(x[j] - x[i]) + Abs(y[j] - y[i])) * a;
}
}
}
void spfa() {
queue<int> q;
q.push(1);
memset(vis, false, sizeof(vis));
vis[1] = true;
for (int i = 1; i <= n; i++) {
dist[i] = (i == 1 ? 0 : dp[1][i]);
}
while (!q.empty()) {
int now = q.front();
q.pop();
vis[now] = false;
for (int i = 1; i <= n; i++) {
if (i == now) continue;
if (dist[now] + dp[now][i] - var[i] < dist[i]) {
dist[i] = dist[now] + dp[now][i] - var[i];
if (!vis[i]) {
q.push(i);
vis[i] = true;
}
}
}
}
}
int main() {
cin >> n >> a;
var[1] = var[n] = 0;
for (int i = 2; i <= n - 1; i++) {
cin >> var[i];
}
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
}
work();
spfa();
cout << dist[n] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a, b, cnt[5005], n1, n2, n3, ans1[5005], ans2[5005],
ccnt = 0, dp[5005][5005], vis[5005], d = 1, va[5005], ud[5005], pr[5005],
hi;
vector<long long> v[5005];
map<long long, long long> m1;
void dfs1(int x) {
if (vis[x] == 0) {
vis[x] = 1;
if (va[x] == 0) {
pr[x] = 2;
} else {
if (n1 > 0) {
pr[x] = 1;
n1--;
} else {
pr[x] = 3;
}
}
for (int kk = 0; kk < cnt[x]; kk++) {
dfs1(v[x][kk]);
}
}
}
void dfs2(int x) {
if (vis[x] == 0) {
vis[x] = 1;
if (va[x] == 1) {
pr[x] = 2;
} else {
if (n1 > 0) {
pr[x] = 1;
n1--;
} else {
pr[x] = 3;
}
}
for (int tt = 0; tt < cnt[x]; tt++) {
dfs2(v[x][tt]);
}
}
}
void dfs(int x) {
if (va[x] == -1) {
if (m1[x] % 2 == 0) {
va[x] = 0;
ans1[ccnt]++;
} else {
va[x] = 1;
ans2[ccnt]++;
}
} else {
if (va[x] != m1[x] % 2) {
d = 0;
}
}
if (vis[x] == 0) {
vis[x] = 1;
for (int jj = 0; jj < cnt[x]; jj++) {
m1[v[x][jj]] = m1[x] + 1;
dfs(v[x][jj]);
}
}
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
for (int i = 0; i < 5002; i++) {
cnt[i] = 0;
ans1[i] = 0;
ans2[i] = 0;
va[i] = -1;
}
for (int i = 0; i <= 5001; i++) {
for (int j = 0; j <= 5001; j++) {
dp[i][j] = 0;
}
}
cin >> n >> m;
cin >> n1 >> n2 >> n3;
for (int i = 0; i < m; i++) {
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
cnt[a]++;
cnt[b]++;
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
m1[i] = 0;
dfs(i);
ccnt++;
}
}
if (d == 0) {
cout << "NO" << '\n';
} else {
dp[0][ans1[0]] = 1;
dp[0][ans2[0]] = 1;
for (int i = 1; i < ccnt; i++) {
for (int j = 0; j <= n2; j++) {
if (j >= ans1[i]) {
if (dp[i - 1][j - ans1[i]]) {
dp[i][j] = 1;
}
}
if (j >= ans2[i]) {
if (dp[i - 1][j - ans2[i]]) {
dp[i][j] = 1;
}
}
}
}
if (dp[ccnt - 1][n2] == 0) {
cout << "NO" << '\n';
} else {
cout << "YES" << '\n';
a = n2;
for (int i = ccnt - 1; i > 0; i--) {
if (a >= ans1[i] && dp[i - 1][a - ans1[i]]) {
ud[i] = 1;
a = a - ans1[i];
} else {
ud[i] = 2;
a = a - ans2[i];
}
}
if (a == ans1[0]) {
ud[0] = 1;
} else {
ud[0] = 2;
}
for (int i = 1; i <= n; i++) {
vis[i] = 0;
}
hi = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
if (ud[hi] == 1) {
dfs1(i);
} else {
dfs2(i);
}
hi++;
}
}
for (int i = 1; i <= n; i++) {
cout << pr[i];
}
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
set<int> s;
const int maxn = 150005;
int t[maxn];
int main(void) {
int n, k, q;
cin >> n >> k >> q;
for (int i = 1; i <= n; i++) {
cin >> t[i];
}
int type, a;
for (int i = 0; i < q; i++) {
cin >> type >> a;
if (type == 1) {
s.insert(t[a]);
if (s.size() > k) s.erase(s.begin());
} else {
if (!s.count(t[a]))
cout << "NO" << endl;
else
cout << "YES" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int mat[5][5];
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) cin >> mat[i][j];
}
int a[5] = {0, 1, 2, 3, 4};
int sum, mx = -1;
do {
sum = 0;
for (int j = 0; j < 3; j += 2)
sum += (mat[a[j]][a[j + 1]] + mat[a[j + 1]][a[j]]);
for (int j = 1; j < 4; j += 2)
sum += (mat[a[j]][a[j + 1]] + mat[a[j + 1]][a[j]]);
for (int j = 2; j < 4; j += 2)
sum += (mat[a[j]][a[j + 1]] + mat[a[j + 1]][a[j]]);
for (int j = 3; j < 4; j += 2)
sum += (mat[a[j]][a[j + 1]] + mat[a[j + 1]][a[j]]);
if (sum > mx) mx = sum;
} while (next_permutation(a, a + 5));
cout << mx << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
template <class T, class U>
inline void add_self(T &a, U b) {
a += b;
if (a >= mod) a -= mod;
if (a < 0) a += mod;
}
template <class T, class U>
inline void min_self(T &x, U y) {
if (y < x) x = y;
}
template <class T, class U>
inline void max_self(T &x, U y) {
if (y > x) x = y;
}
template <typename T>
void print(T v, bool show_index = false) {
int w = 2;
if (show_index) {
for (int i = 0; i < v.size(); i++) cout << setw(w) << i << " ";
cout << endl;
}
for (auto i = v.begin(); i != v.end(); i++) cout << setw(w) << *i << " ";
cout << endl;
}
template <typename T>
void print_vv(T v) {
if (v.size() == 0) {
cout << "Empty" << endl;
return;
}
int w = 3;
cout << setw(w) << " ";
for (int j = 0; j < v[0].size(); j++) cout << setw(w) << j << " ";
cout << endl;
for (auto i = 0; i < v.size(); i++) {
cout << i << " {";
for (auto j = 0; j != v[i].size(); j++) {
cout << setw(w) << v[i][j] << ",";
}
cout << "}," << endl;
}
cout << endl;
}
template <class T, class U>
void print_m(map<T, U> m, int w = 3) {
if (m.empty()) {
cout << "Empty" << endl;
return;
}
for (auto x : m) cout << "(" << x.first << ": " << x.second << ")," << endl;
cout << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long q, n, m, h;
cin >> q;
while (q--) {
cin >> n >> m;
vector<int> t(n), l(n), h(n);
for (int i = 0; i < int(n); i++) cin >> t[i] >> l[i] >> h[i];
bool valid = true;
int prev = 0;
int mn = m, mx = m;
for (int i = 0; i < int(n); i++) {
mx += t[i] - prev;
mn -= t[i] - prev;
if (mx < l[i] || mn > h[i]) {
valid = false;
break;
}
mx = min(mx, h[i]);
mn = max(mn, l[i]);
prev = t[i];
}
string out = valid ? "YES" : "NO";
cout << out << endl;
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.