solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
short L[5005][5005], R[5005][5005], U[5005][5005], D[5005][5005];
char q[5005][5005];
int n, m, av, aw, sp;
void gao(int x, int y) {
if (x < 1 || y < 1 || x > m || y > n) return;
++sp;
L[x][R[x][y]] = L[x][y];
R[x][L[x][y]] = R[x][y];
U[D[x][y]][y] = U[x][y];
D[U[x][y]][y] = D[x][y];
if (q[x][y] == 'L') gao(x, L[x][y]);
if (q[x][y] == 'R') gao(x, R[x][y]);
if (q[x][y] == 'U') gao(U[x][y], y);
if (q[x][y] == 'D') gao(D[x][y], y);
L[x][R[x][y]] = y;
R[x][L[x][y]] = y;
U[D[x][y]][y] = x;
D[U[x][y]][y] = x;
}
int main() {
scanf("%d%d", &m, &n);
for (int i = 1; i <= m; i++) scanf("%s", q[i] + 1);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++)
L[i][j] = q[i][j - 1] != '.' ? j - 1 : L[i][j - 1];
for (int j = n; j > 0; j--)
R[i][j] = q[i][j + 1] != '.' ? j + 1 : R[i][j + 1];
}
for (int j = 1; j <= n; j++) {
for (int i = 1; i <= m; i++)
U[i][j] = q[i - 1][j] != '.' ? i - 1 : U[i - 1][j];
for (int i = m; i > 0; i--)
D[i][j] = q[i + 1][j] != '.' ? i + 1 : D[i + 1][j];
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++)
if (q[i][j] != '.') {
sp = 0;
gao(i, j);
if (sp == av)
++aw;
else if (sp > av)
av = sp, aw = 1;
}
printf("%d %d\n", av, aw);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n;
const int N = 1000005;
int type[N], q[N], f[N];
int top, nd, id[N];
long long ans[N];
vector<int> e[N];
int getflow(int x) {
f[x] = 0;
if (type[x] == 0) f[x] = 1;
if (type[x] == 1) {
f[x] = 1ll << 30;
for (int i = (int)(0); i <= (int)(e[x].size() - 1); i++)
f[x] = min(f[x], getflow(e[x][i]));
}
if (type[x] == 2) {
f[x] = 0;
for (int i = (int)(0); i <= (int)(e[x].size() - 1); i++)
f[x] += getflow(e[x][i]);
}
return f[x];
}
void updans(int x, long long val) {
if (type[x] == 0) ans[id[x]] = val;
if (type[x] == 1)
for (int i = (int)(0); i <= (int)(e[x].size() - 1); i++)
if (f[e[x][i]] == f[x]) return updans(e[x][i], val);
if (type[x] == 2)
for (int i = (int)(0); i <= (int)(e[x].size() - 1); i++)
updans(e[x][i], val);
}
void solve() {
*id = 0;
long long n;
cin >> n;
string tmp;
getline(cin, tmp);
int top = 0, len = tmp.length();
for (; nd; type[nd] = 0, e[nd].clear(), nd--)
;
q[++top] = nd = 1;
for (int i = (int)(0); i <= (int)(len - 1); i++) {
if (tmp[i] == '(') q[++top] = ++nd;
if (tmp[i] == ')') {
e[q[top - 1]].push_back(q[top]);
--top;
}
if (tmp[i] == '*') e[q[top]].push_back(++nd), id[nd] = ++*id;
if (tmp[i] == 'S') type[q[top]] = 1;
if (tmp[i] == 'P') type[q[top]] = 2;
}
type[1] = 1;
for (int i = (int)(1); i <= (int)(*id); i++) ans[i] = 0;
n *= getflow(1);
updans(1, n);
printf("REVOLTING");
for (int i = (int)(1); i <= (int)(*id); i++) printf(" %lld", ans[i]);
puts("");
}
int main() {
int T;
scanf("%d", &T);
while (T--) solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
int c[maxn] = {0};
int main() {
ios::sync_with_stdio(false);
int n, m, x, a = 0, b = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
a += x;
c[a]++;
}
for (int i = 0; i < m; i++) {
cin >> x;
b += x;
c[b]++;
}
int res = 0;
for (int i = 0; i < maxn; i++)
if (c[i] == 2) res++;
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int l = 1, h = a * c, mid, ans;
while (l <= h) {
mid = l + (h - l) / 2;
int temp = mid / b;
if (temp * b + (b * c) < a * c)
l = mid + 1;
else {
ans = temp;
h = mid - 1;
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int p[maxn], h[maxn], n1[maxn], ee = 0, Q, n;
int anc[maxn][17], d[maxn] = {0}, root;
struct que {
int op, a, b, k, v;
} q[maxn];
int val[maxn];
void ae(int x, int y) {
p[ee] = y;
n1[ee] = h[x];
h[x] = ee++;
}
void dfs(int u) {
for (int i = h[u]; ~i; i = n1[i]) d[p[i]] = d[u] + 1, dfs(p[i]);
}
int lca(int x, int y) {
if (d[x] > d[y]) swap(x, y);
int k = d[y] - d[x], j = 0;
while (k) {
if (k & 1) y = anc[y][j];
k >>= 1;
j++;
}
if (x == y) return x;
for (int i = 16; ~i; i--)
if (anc[x][i] != anc[y][i]) x = anc[x][i], y = anc[y][i];
return anc[x][0];
}
const int maxt = 5000000;
struct segnode {
int l, r, sz;
} t[maxt];
int T[maxn] = {0}, TOT = 0;
void modify(int &x, int p, int v, int l, int r) {
t[x = ++TOT] = (segnode){t[p].l, t[p].r, t[p].sz + 1};
if (l == r) return;
int mid = (l + r) >> 1;
if (v <= mid)
modify(t[x].l, t[p].l, v, l, mid);
else
modify(t[x].r, t[p].r, v, mid + 1, r);
}
int ask(int x, int ql, int qr, int l, int r) {
if (ql <= l && r <= qr) return t[x].sz;
int mid = (l + r) >> 1, ret = 0;
if (ql <= mid) ret += ask(t[x].l, ql, qr, l, mid);
if (mid < qr) ret += ask(t[x].r, ql, qr, mid + 1, r);
return ret;
}
void dfs2(int u) {
for (int i = h[u]; ~i; i = n1[i]) {
modify(T[p[i]], T[u], val[p[i]], 0, Q);
dfs2(p[i]);
}
}
int upk(int x, int k) {
int j = 0;
while (k) {
if (k & 1) x = anc[x][j];
k >>= 1;
j++;
}
return x;
}
inline int trk(int x, int y, int lc, int k) {
if (k <= d[x] - d[lc])
return upk(x, k);
else
return upk(y, d[x] + d[y] - 2 * d[lc] - k);
}
inline int query(int x, int y, int ql, int qr) {
int lc = lca(x, y);
return ask(T[x], ql, qr, 0, Q) + ask(T[y], ql, qr, 0, Q) -
2 * ask(T[lc], ql, qr, 0, Q) + (ql <= val[lc] && val[lc] <= qr);
}
int getans(int cur) {
int x = q[cur].a, y = q[cur].b, lc = lca(x, y),
cc = d[x] + d[y] - 2 * d[lc] - 1;
if (cc - query(trk(x, y, lc, 1), trk(x, y, lc, cc), q[cur].v + 1, cur) <
q[cur].k)
return -1;
int l = 1, r = cc, mid, u, c, x1 = trk(x, y, lc, 1);
while (l <= r) {
mid = (l + r) >> 1;
u = trk(x, y, lc, mid);
c = d[u] + d[x1] - d[lca(u, x1)] * 2 + 1;
if (c - query(x1, u, q[cur].v + 1, cur) < q[cur].k)
l = mid + 1;
else
r = mid - 1;
}
return trk(x, y, lc, l);
}
int main() {
scanf("%d", &n);
memset(h, -1, sizeof(h));
for (int i = 1; i <= n; i++) {
scanf("%d", &anc[i][0]);
if (!anc[i][0])
root = i;
else
ae(anc[i][0], i);
}
for (int j = 1; j <= 16; j++)
for (int i = 1; i <= n; i++) anc[i][j] = anc[anc[i][j - 1]][j - 1];
dfs(root);
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d", &q[i].op);
if (q[i].op == 1)
scanf("%d", &q[i].a), val[q[i].a] = i;
else
scanf("%d%d%d%d", &q[i].a, &q[i].b, &q[i].k, &q[i].v);
}
modify(T[root], 0, val[root], 0, Q);
dfs2(root);
for (int i = 1; i <= Q; i++)
if (q[i].op == 2) printf("%d\n", getans(i));
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
long long t = 1, n, m, i, j, k, l, u, to;
while (t--) {
long long x, y;
cin >> x >> y >> m;
if (x <= 0 && y <= 0 && max(x, y) < m) {
cout << -1;
return 0;
}
if (max(x, y) >= m) {
cout << 0;
return 0;
}
if (x > y) {
swap(x, y);
}
long long ans = 0;
if (x < 0) {
ans = (-x + y - 1) / y;
_dbg("ans", ans);
x = (x % y + y) % y;
}
while (y < m) {
x += y;
if (x > y) swap(x, y);
ans++;
}
cout << ans;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> p;
int dp[100 * 1000 + 10];
int mp[100 * 1000 + 10];
int lf(int i) {
if (dp[i] != -1) return dp[i];
if (mp[p[i] + 1] > i)
return dp[i] = 1 + lf(mp[p[i] + 1]);
else
return dp[i] = 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
memset(dp, -1, sizeof(dp));
cin >> n;
p.resize(n);
for (int& it : p) cin >> it;
for (int i = 0; i < n; i++) mp[p[i]] = i;
int l = lf(0);
for (int i = 1; i < n; i++) {
l = max(l, lf(i));
}
cout << (n - l) << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x7f7f7f7f7f7f;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
const long long N = 5050;
long long dp[N][N];
long long a[N], b[N], c[N], d[N], x[N];
long long n, s, e;
inline void init() {
for (long long i = 0; i <= n + 1; i++)
for (long long j = 0; j <= n + 1; j++) dp[i][j] = inf;
}
inline void chmax(long long &x, long long y) {
if (x < y) x = y;
}
inline void chmin(long long &x, long long y) {
if (x > y) x = y;
}
signed main() {
n = read(), s = read(), e = read();
init();
for (long long i = 1; i <= n; i++) x[i] = read();
for (long long i = 1; i <= n; i++) a[i] = read();
for (long long i = 1; i <= n; i++) b[i] = read();
for (long long i = 1; i <= n; i++) c[i] = read();
for (long long i = 1; i <= n; i++) d[i] = read();
dp[1][1] = 0;
if (s != 1) dp[1][1] += (b[1] - x[1]);
if (e != 1) dp[1][1] += (d[1] - x[1]);
for (long long i = 2; i <= n - 1; i++) {
if (i != s && i != e) {
long long j = 1;
if (i > s && i > e) j++;
for (; j <= i; j++) {
if (i <= s || j != 1) chmin(dp[i][j], dp[i - 1][j] + c[i] + b[i]);
if (i <= e || j != 1) chmin(dp[i][j], dp[i - 1][j] + a[i] + d[i]);
chmin(dp[i][j + 1], dp[i - 1][j] + b[i] - x[i] + d[i] - x[i]);
if (j != 1) chmin(dp[i][j - 1], dp[i - 1][j] + a[i] + c[i] + 2 * x[i]);
}
} else if (i == s) {
for (long long j = 1; j <= i; j++) {
chmin(dp[i][j], dp[i - 1][j] + c[i] + x[i]);
chmin(dp[i][j + 1], dp[i - 1][j] + d[i] - x[i]);
}
} else if (i == e) {
for (long long j = 1; j <= i; j++) {
chmin(dp[i][j], dp[i - 1][j] + a[i] + x[i]);
chmin(dp[i][j + 1], dp[i - 1][j] + b[i] - x[i]);
}
}
}
long long res = 0, cur = 1;
if (s != n && e != n) cur++;
if (s != n) res += a[n] + x[n];
if (e != n) res += c[n] + x[n];
printf("%lld\n", dp[n - 1][cur] + res);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-6;
const int INF = (int)(INT_MAX - 100);
const long long mod = (int)(1e+9 + 7);
const int N = (int)(1e5);
map<int, int> V, C;
int main() {
int n, s;
cin >> n >> s;
int p, k;
char d;
for (int i = 0; i < n; i++) {
cin >> d >> p >> k;
if (d == 'B')
C[p] += k;
else
V[p] += k;
}
k = 0;
vector<pair<int, int> > ans;
for (auto it = V.begin(); it != V.end(); it++, k++) {
if (k == s) break;
ans.push_back({(*it).first, (*it).second});
}
reverse(ans.begin(), ans.end());
for (auto x : ans) cout << "S " << x.first << " " << x.second << '\n';
k = 0;
for (auto it = C.rbegin(); it != C.rend(); it++, k++) {
if (k == s) break;
cout << "B " << (*it).first << " " << (*it).second << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool isprime(long long p) {
if (p < 2) return false;
if (p == 2) return true;
if (p % 2 == 0) return false;
double limit = sqrt(p);
for (long long i = 3; i <= limit; i += 2) {
if ((p % i) == 0) return false;
}
return true;
}
long long fac(long long n) {
long long an = 1;
while (n > 1) {
an *= n;
n--;
}
return an;
}
long long kor(long long n, long long st) {
long long nn = n;
if (st == 0) return 1;
while (st > 1) {
n = (n * nn);
st--;
}
return n;
}
vector<vector<int> > g(1001, vector<int>());
map<int, bool> ma;
map<int, bool>::iterator it;
set<int> per;
set<int>::iterator iter;
priority_queue<int> pq;
bool used[1001];
void dfs(int v) {
used[v] = true;
for (vector<int>::iterator ii = g[v].begin(); ii != g[v].end(); ++ii)
if (!used[*ii]) dfs(*ii);
}
int main() {
ios::sync_with_stdio(false);
long long n, m, ans = 0;
cin >> n >> m;
string s;
for (int i = 0; i < n; ++i) {
cin >> s;
}
bool f = 0;
for (int i = 0; i < m; ++i) {
if (s[i] == 'B') {
if (!f) ans++;
f = 1;
} else
f = 0;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, l, n, m, s, an, K, X, tot = 1, h, oo, sum, c1, c2, A, ans,
am;
const long long N = 1100010;
long long g[N], b[N];
class arr {
public:
long long x, num;
} a[N];
bool com(const arr &o, const arr &p) { return o.x < p.x; }
int main() {
scanf("%I64d%I64d%I64d%I64d%I64d", &n, &A, &c1, &c2, &m);
for (long long i = 1; i <= n; i++) scanf("%I64d", &a[i].x), a[i].num = i;
sort(&a[1], &a[n + 1], com);
for (long long i = 1; i <= n; i++) g[i] = g[i - 1] + a[i].x;
an = 0;
a[n + 1].x = A;
for (long long i = n + 1; i >= 1; i--) {
m -= (A - a[i].x);
if (m < 0) break;
long long l = 1;
long long r = i;
while (l < r - 1) {
long long mid = (l + r) / 2;
if (mid * a[mid].x - g[mid] <= m)
l = mid;
else
r = mid;
}
long long s = m - (l * a[l].x - g[l]);
long long v = (a[l].x + (s / l));
if (v > A) v = A;
if (i == 1) v = A;
if ((n + 1 - i) * c1 + v * c2 > an) {
an = (n + 1 - i) * c1 + v * c2;
ans = i;
am = m;
}
}
printf("%I64d\n", an);
if (an)
for (long long i = ans; i <= ans; i++) {
m = am;
long long l = 1;
long long r = i;
while (l < r - 1) {
long long mid = (l + r) / 2;
if (mid * a[mid].x - g[mid] <= m)
l = mid;
else
r = mid;
}
long long s = m - (l * a[l].x - g[l]);
long long v = (a[l].x + (s / l));
if (v > A) v = A;
if (i == 1) v = A;
for (long long j = 1; j <= l; j++) a[j].x = v;
for (long long j = i; j <= n; j++) a[j].x = A;
}
for (long long i = 1; i <= n; i++) b[a[i].num] = a[i].x;
for (long long i = 1; i <= n; i++) printf("%I64d ", b[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 0; i < 10; i++) cout << "??" << i << ">>" << i << "??" << '\n';
cout << "??>>?\n";
cout << "9?>>?0\n";
for (int i = 0; i < 9; i++) cout << i << "?<>" << i + 1 << '\n';
cout << "?<>1\n";
cout << ">>??\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long l, swp;
short st;
string s;
int main() {
cin >> s;
l = s.size() - 1, swp = -1, st = 0;
for (long long i = l - 1; i >= 0; i--) {
if (((s[i] - '0') % 2) == 0) {
if (swp == -1) {
if ((s[i] - '0') < (s[l] - '0')) {
st = 1;
swp = i;
} else if ((s[i] - '0') > (s[l] - '0')) {
st = -1;
swp = i;
} else {
st = 0;
swp = i;
}
} else if ((s[i] - '0') == (s[l] - '0') && st < 1) {
st = 0;
swp = i;
} else if ((s[i] - '0') < (s[l] - '0')) {
st = 1;
swp = i;
}
}
}
if (swp != -1) {
swap(s[swp], s[l]);
cout << s;
} else {
cout << "-1";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string tos(int a) {
ostringstream os("");
os << a;
return os.str();
}
int n, m, A[101];
int main() {
while (cin >> n >> m) {
int prev = n + 1;
for (int j = (int)0; j < (int)m; ++j) {
int t;
cin >> t;
if (t < prev) {
for (int i = (int)t; i < (int)prev; ++i) A[i] = t;
prev = t;
}
}
for (int i = (int)1; i < (int)n + 1; ++i) cout << A[i] << ' ';
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000 /HEAP:10000000")
using namespace std;
pair<int, int> num(string s) {
int n = s.size();
if (n >= 4 && s.substr(n - 4, 4) == "lios") return make_pair(0, 1);
if (n >= 5 && s.substr(n - 5, 5) == "liala") return make_pair(0, 0);
if (n >= 3 && s.substr(n - 3, 3) == "etr") return make_pair(1, 1);
if (n >= 4 && s.substr(n - 4, 4) == "etra") return make_pair(1, 0);
if (n >= 6 && s.substr(n - 6, 6) == "initis") return make_pair(2, 1);
if (n >= 6 && s.substr(n - 6, 6) == "inites") return make_pair(2, 0);
return make_pair(-1, -1);
}
int main() {
vector<pair<int, int> > v;
string s;
while (cin >> s) v.push_back(num(s));
int i, n = v.size(), pos = -1;
if (v[0].first == -1) {
cout << "NO";
return 0;
}
if (n == 1) {
cout << "YES";
return 0;
}
for (i = 1; i < n; i++)
if (v[i].second != v[i - 1].second) {
cout << "NO";
return 0;
}
i = 0;
while (v[i].first == 0 && i < n) i++;
pos = i - 1;
while (v[i].first == 1 && i < n) i++;
if (i - 1 - pos != 1) {
cout << "NO";
return 0;
}
pos = i - 1;
while (v[i].first == 2 && i < n) i++;
if (i != n)
cout << "NO";
else
cout << "YES";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void sci(T& t) {
cin >> t;
}
template <typename T, typename... Ts>
void sci(T& t, Ts&... ts) {
sci(t);
sci(ts...);
}
template <typename T, typename Cmp = std::greater<T>>
using heap = priority_queue<T, std::vector<T>, Cmp>;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
multiset<char> s;
string ts;
sci(ts);
int n = ts.length();
for (char c : ts) {
s.insert(c);
}
vector<char> t, u;
int i = 0;
while (!s.empty() || !t.empty()) {
if (t.empty() || (!s.empty() && *s.begin() < t.back())) {
t.push_back(ts[i]);
s.erase(s.find(ts[i]));
i++;
} else {
u.push_back(t.back());
t.pop_back();
}
}
for (char c : u) {
cout << c;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int b[n];
for (int i = 0; i < n; i++) cin >> b[i];
long long int a[n];
a[0] = b[0];
long long int m = 0;
for (int i = 1; i < n; i++) {
a[i] = b[i] + max(m, a[i - 1]);
if (m < a[i - 1]) m = a[i - 1];
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long f[60][120][2];
long long n, L, R;
long long now;
long long dfs(long long ws, long long res, bool jw) {
if (res < 0) return 0;
if (~f[ws][res][jw]) return f[ws][res][jw];
long long& t = f[ws][res][jw];
t = 0;
if ((1ll << ws) > now) {
if (res == 0 && jw == 0) t = 1;
return t;
}
if ((1ll << ws) & now) {
if (jw) {
t = dfs(ws + 1, res, 0);
if (ws < L && ws < R) t += dfs(ws + 1, res - 2, 1);
} else {
if (ws < L) t += dfs(ws + 1, res - 1, 0);
if (ws < R) t += dfs(ws + 1, res - 1, 0);
}
} else {
if (jw) {
if (ws < L) t += dfs(ws + 1, res - 1, 1);
if (ws < R) t += dfs(ws + 1, res - 1, 1);
} else {
t = dfs(ws + 1, res, 0);
if (ws < L && ws < R) t += dfs(ws + 1, res - 2, 1);
}
}
return t;
}
long long ans;
int main() {
cin >> n;
for (long long a = 0; (1ll << a) <= n; a++) {
for (long long b = 0; (1ll << b) <= n; b++) {
long long lca =
(n - (1ll << b) + 1) / ((1ll << a + 1) + (1ll << b + 1) - 3);
if (lca == 0) continue;
long long nn =
n - lca * ((1ll << a + 1) + (1ll << b + 1) - 3) + 1 - (1ll << b);
for (int i = 0; i <= a + b; i++) {
memset(f, -1, sizeof(f));
L = a - 1;
R = b - 1;
now = nn + i;
if (now & 1) continue;
now /= 2;
ans += dfs(0, i, 0);
}
}
}
printf("%lld\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
char in[1010];
int out[1010];
int main() {
int n, i, j;
scanf("%d", &n);
scanf("%s", in);
for (i = 0; i < n; i++) {
if (i) printf(" ");
int c1 = 0, c2 = 0;
for (j = i - 1; j >= 0; j--) {
if (in[j] == 'R')
c1++;
else if (in[j] == 'L')
break;
}
for (j = i + 1; j < n; j++) {
if (in[j - 1] == 'L')
c2++;
else if (in[j - 1] == 'R')
break;
}
printf("%d", 1 + (c1 > c2 ? c1 : c2));
}
puts("");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
std::vector<int> ans, g[300005];
int tot = 0;
int sub[300005], id[300005];
void dfs(int u) {
id[u] = tot++;
sub[u] = 1;
sort(g[u].begin(), g[u].end());
ans.push_back(u);
for (auto v : g[u]) {
dfs(v);
sub[u] += sub[v];
}
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 2; i <= n; i++) {
int u;
cin >> u;
g[u].push_back(i);
}
dfs(1);
while (q--) {
int u, k;
cin >> u >> k;
int idx = id[u];
if (k <= sub[u]) {
idx = idx + k - 1;
cout << ans[idx] << endl;
} else
cout << -1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <class T>
typename T::value_type arr_sum(const T& v, int n) {
typename T::value_type sum = 0;
for (int i = (0); i < (n); ++i) sum += v[i];
return sum;
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
vector<int> res;
vector<multiset<int>> g;
void euler_path(int t) {
stack<int> st;
st.push(t);
while (!st.empty()) {
int p = st.top();
if (g[p].empty()) {
res.push_back(p);
st.pop();
} else {
int s = *g[p].begin();
auto it = g[p].find(s);
if (it != g[p].end()) {
g[p].erase(it);
}
it = g[s].find(p);
if (it != g[s].end()) {
g[s].erase(it);
}
st.push(s);
}
}
}
int main() {
int n, m;
cin >> n >> m;
g.resize(n);
vector<int> deg(n);
for (int i = (0); i < (m); ++i) {
int a, b;
cin >> a >> b;
--a, --b;
g[a].insert(b);
g[b].insert(a);
++deg[a];
++deg[b];
}
int t = -1;
for (int i = (0); i < (n); ++i) {
if (deg[i] % 2) {
if (t == -1) {
t = i;
} else {
g[t].insert(i);
g[i].insert(t);
++deg[t];
++deg[i];
t = -1;
}
}
}
if (accumulate(deg.begin(), deg.end(), 0) % 4) {
g[0].insert(0);
g[0].insert(0);
}
euler_path(0);
cout << res.size() - 1 << "\n";
for (int i = (0); i < (res.size() - 1); ++i) {
int a = i;
int b = i + 1;
if (a % 2 == 0) {
swap(a, b);
}
cout << res[a] + 1 << " " << res[b] + 1 << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void printv(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) cout << v[i] << ' ';
cout << '\n';
}
long long bem(long long m, long long n, long long mod) {
long long res = 1;
while (n) {
if (n % 2 != 0) {
res *= m;
res %= mod;
}
m *= m;
m %= mod;
n /= 2;
}
return res;
}
long long be(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2 != 0) res *= a;
a *= a;
b /= 2;
}
return res;
}
void sieve(long long n, vector<bool> &prime) {
prime[0] = false;
prime[1] = false;
for (long long i = 2; i * i <= n; i++) {
if (prime[i] == true) {
for (long long j = i * i; j <= n; j += i) prime[j] = false;
}
}
}
long long fun(vector<long long> v, long long i) {
long long z = v[i];
long long x = z / 14;
long long r = z % 14;
v[i] -= z;
for (long long j = (long long)1; j <= (long long)14; j++) v[j] += x;
i++;
if (i == 15) i = 1;
while (r--) {
v[i]++;
i++;
if (i == 15) i = 1;
}
long long sum = 0;
for (long long i = (long long)1; i <= (long long)14; i++)
if (v[i] % 2 == 0) sum += v[i];
return sum;
}
void solve() {
vector<long long> v(15);
for (long long i = (long long)1; i <= (long long)14; i++) cin >> v[i];
long long ans = INT_MIN;
for (long long i = (long long)1; i <= (long long)14; i++) {
if (v[i] > 0) ans = max(ans, fun(v, i));
}
cout << ans << '\n';
}
int32_t main() {
long long t = 1;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
int n, k, a[500 + 10];
template <class T>
void Read(T &x) {
char c;
bool f = 0;
while (c = getchar(), c != EOF)
if (c == '-')
f = 1;
else if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
ungetc(c, stdin);
if (f) x = -x;
return;
}
}
void read() {
Read(n), Read(k);
for (int i = 1; i <= n; i++) Read(a[i]);
}
void solve() {
int ans = 0;
for (int i = 2; i <= n; i++)
if (a[i] + a[i - 1] < k) {
ans += k - (a[i] + a[i - 1]);
a[i] += k - (a[i] + a[i - 1]);
}
printf("%d\n", ans);
for (int i = 1; i < n; i++) printf("%d ", a[i]);
printf("%d\n", a[n]);
}
int main() {
read();
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void pvp(T a, T b) {
for (T i = a; i != b; ++i)
cout << "(" << i->first << ", " << i->second << ") ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in_c() {
int c;
for (; (c = getchar()) <= ' ';) {
if (!~c) throw ~0;
}
return c;
}
int in() {
int x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
long long In() {
long long x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -In();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
int N, Q;
map<int, int> R;
set<int> S;
set<pair<int, int>, greater<pair<int, int> > > P;
int typ[100010], A[100010], B[100010];
int aslen, as[200010];
int bitn;
int bit[200010];
void bit_add(int x, int val) {
for (; x <= bitn; x += x & -x) bit[x] += val;
}
int bit_cal(int x) {
int ret = 0;
for (; x > 0; x &= x - 1) ret += bit[x];
return ret;
}
int main() {
int i;
int x, a, b;
for (; ~scanf("%d%d", &N, &Q);) {
S.clear();
P.clear();
S.insert(0);
S.insert(N + 1);
P.insert(make_pair(N, N));
for (i = 0; i < Q; ++i) {
x = in();
if (x) {
if (R.count(x)) {
typ[i] = -1;
A[i] = B[i] = R[x];
set<int>::iterator it = S.find(R[x]), ita, itb;
ita = it;
--ita;
itb = it;
++itb;
P.erase(make_pair(*it - *ita - 1, *it - 1));
P.erase(make_pair(*itb - *it - 1, *itb - 1));
P.insert(make_pair(*itb - *ita - 1, *itb - 1));
S.erase(R[x]);
R.erase(x);
} else {
set<pair<int, int> >::iterator pit = P.begin();
R[x] = pit->second - (pit->first - 1) / 2;
S.insert(R[x]);
set<int>::iterator it = S.find(R[x]), ita, itb;
ita = it;
--ita;
itb = it;
++itb;
P.erase(make_pair(*itb - *ita - 1, *itb - 1));
P.insert(make_pair(*it - *ita - 1, *it - 1));
P.insert(make_pair(*itb - *it - 1, *itb - 1));
typ[i] = +1;
A[i] = B[i] = R[x];
}
} else {
a = in();
b = in();
if (a > b) swap(a, b);
typ[i] = 0;
A[i] = a;
B[i] = b;
}
}
aslen = 0;
for (i = 0; i < Q; ++i) {
as[aslen++] = A[i];
as[aslen++] = B[i];
}
sort(as, as + aslen);
aslen = unique(as, as + aslen) - as;
for (i = 0; i < Q; ++i) {
A[i] = lower_bound(as, as + aslen, A[i]) - as + 1;
B[i] = lower_bound(as, as + aslen, B[i]) - as + 1;
}
bitn = aslen + 5;
memset(bit, 0, sizeof(bit));
for (i = 0; i < Q; ++i) {
if (typ[i]) {
bit_add(A[i], typ[i]);
} else {
int res = bit_cal(B[i]) - bit_cal(A[i] - 1);
printf("%d\n", res);
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
char s[N], t[N];
int sum[N << 1];
vector<int> calPos(int l, int r) {
vector<int> ans;
int cnt = 0;
for (int i = l; i <= r; i++) {
if (t[i] == '(')
cnt++;
else
cnt--;
if (cnt == 0) ans.push_back(i);
}
return ans;
}
void calAns(vector<int> vec, int& ans, pair<int, int>& pos, int sz, int pre) {
for (auto i : vec) {
int t = (int)calPos(pre + 2, i - 1).size() + 1 + sz;
if (t > ans) ans = t, pos = pair<int, int>(pre + 1, i);
pre = i;
}
}
void solve() {
int n;
scanf("%d%s", &n, s + 1);
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == '(')
cnt++, sum[i] = 1;
else
sum[i] = -1;
sum[i + n] = sum[i];
}
if (n % 2 == 0 && cnt == n / 2) {
sum[0] = 0;
for (int i = 1; i <= 2 * n; i++) sum[i] += sum[i - 1];
multiset<int> st;
for (int i = 1; i <= n; i++) st.insert(sum[i]);
for (int i = 1; i <= n; i++) {
int v = *st.begin() - sum[i - 1];
st.erase(st.lower_bound(sum[i]));
st.insert(sum[i + n]);
if (v == 0) {
int m = 0;
for (int j = i; j <= n; j++) t[++m] = s[j];
for (int j = 1; j < i; j++) t[++m] = s[j];
vector<int> vec = calPos(1, n);
int ans = (int)vec.size();
pair<int, int> pos = pair<int, int>(1, 1);
int pre = 0;
for (auto j : vec) {
vector<int> tvec = calPos(pre + 2, j - 1);
if ((int)tvec.size() + 1 > ans) {
ans = (int)tvec.size() + 1;
pos = pair<int, int>(pre + 1, j);
}
calAns(tvec, ans, pos, (int)vec.size(), pre + 1);
pre = j;
}
pos.first += i - 1;
pos.second += i - 1;
if (pos.first > n) pos.first -= n;
if (pos.second > n) pos.second -= n;
printf("%d\n%d %d\n", ans, pos.first, pos.second);
break;
}
}
} else {
printf("0\n1 1\n");
}
}
int main() {
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int const mod = 1000000007;
int const maxN = 1e5 + 5;
long long INF = 1e18;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long fpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod, b >>= 1;
}
return res;
}
long long ExtEuclidean(long long a, long long b, long long& x, long long& y) {
if (!b) {
x = 1, y = 0;
return a;
}
long long x1, y1;
long long _gcd = ExtEuclidean(b, a % b, x1, y1);
x = y1, y = x1 - (a / b) * y1;
return _gcd;
}
class DSU {
public:
int *par, *rank;
DSU(int n) {
par = new int[n], rank = new int[n];
for (int i = 0; i < n; i++) par[i] = -1, rank[i] = 1;
}
int find(int x) {
if (par[x] == -1) return x;
return par[x] = find(par[x]);
}
void unite(int a, int b) {
int p1 = find(a), p2 = find(b);
if (p1 != p2) {
if (rank[p1] < rank[p2])
par[p2] = p1, rank[p1] += rank[p2];
else
par[p1] = p2, rank[p2] += rank[p1];
}
}
};
void solve() {
long long n;
cin >> n;
vector<long long> arr(n);
for (int i = int(0); i < int(n); ++i) cin >> arr[i];
string s;
cin >> s;
vector<pair<long long, long long>> like, un;
for (int i = 0; i < ((int)s.size()); i++)
if (s[i] == '1') like.push_back({arr[i], i});
for (int i = 0; i < ((int)s.size()); i++)
if (s[i] == '0') un.push_back({arr[i], i});
sort(like.begin(), like.end(), greater<pair<long long, long long>>());
sort(un.begin(), un.end(), greater<pair<long long, long long>>());
long long k = n;
vector<long long> v(n);
for (int i = int(0); i < int(((int)like.size())); ++i) {
v[like[i].second] = k--;
}
for (int i = int(0); i < int(((int)un.size())); ++i) {
v[un[i].second] = k--;
}
for (int i = int(0); i < int(n); ++i) cout << v[i] << " ";
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
;
int t = 1;
cin >> t;
for (int tt = 1; tt <= t; tt++) {
solve();
cout << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
long long cnt;
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<vector<char>> a(n, vector<char>(m));
map<char, list<pair<long long, long long>>> make_pair;
map<pair<long long, long long>, long long> c;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
make_pair[(a[i][j])].push_back({i, j});
}
}
for (auto x : make_pair) {
long long i = 0;
long long c_fs, c_sc;
for (auto nbr : x.second) {
c_fs = nbr.first;
c_sc = nbr.second;
i++;
for (auto nb : make_pair[x.first]) {
if (((nb.first == c_fs) or (nb.second == c_sc)) and
!((c_fs == nb.first) and (c_sc == nb.second))) {
if (i == 1) {
c[{c_fs, c_sc}] = 1;
i++;
}
c[{nb.first, nb.second}] = 1;
}
}
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (!c[{i, j}]) {
cout << a[i][j];
}
}
}
}
void init() {}
int main() {
init();
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x1[100], x2[100], y1[100], y2[100], sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
sum += (x2[i] - x1[i] + 1) * (y2[i] - y1[i] + 1);
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 0;
char a[100];
scanf("%s", &a);
int l = strlen(a);
for (int i = 0; i < l; i++) {
if (a[i] >= '5') {
a[i] = '9' - a[i] + '0';
}
}
for (int i = 0; i < l; i++) {
if (a[i] == '0' && t == 0) {
printf("9");
t++;
} else {
t++;
printf("%c", a[i]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y, k, m, ans;
char c;
int check(int u, int v) {
if (v > u) return 1;
if (v == u) return 0;
if (v < u) return 2;
}
int main() {
x = 0;
y = 0;
ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c;
if (c == 'U')
y++;
else
x++;
m = check(x, y);
if (i == 1) {
k = m;
continue;
}
if (k != m && m != 0) {
ans++;
k = m;
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
char ch[200005 << 1];
long long ans, fac[200005 << 1], inv[200005 << 1];
int n, sum1[200005 << 1], sum2[200005 << 1];
long long ksm(long long x, int p) {
long long sum = 1;
for (; p; p >>= 1, x = x * x % mod)
if (p & 1) sum = sum * x % mod;
return sum % mod;
}
long long C(int n, int m) { return fac[n] * inv[m] % mod * inv[n - m] % mod; }
int main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n; i++)
if (ch[i] == '(')
sum1[i] = sum1[i - 1] + 1;
else
sum1[i] = sum1[i - 1];
for (int i = n; i >= 1; i--)
if (ch[i] == ')')
sum2[i] = sum2[i + 1] + 1;
else
sum2[i] = sum2[i + 1];
inv[0] = fac[0] = 1;
for (int i = 1; i <= 200000 << 1; i++) fac[i] = fac[i - 1] * i % mod;
inv[200000 << 1] = ksm(fac[200000 << 1], mod - 2);
for (int i = 200000 << 1; i >= 1; i--) inv[i - 1] = inv[i] * i % mod;
int last = 0;
for (int i = 1; i <= n; i++)
if (ch[i] == '(') {
ans = ((ans + C(sum1[i] + sum2[i], min(sum1[i], sum2[i])) -
C(last + sum2[i], min(last, sum2[i])) + mod) %
mod) %
mod;
last = sum1[i];
}
cout << ans % mod;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct cc {
long long int num, id;
} a[200005];
long long int s[200005];
long long int ans[200005];
bool cmp(cc x, cc y) { return x.num < y.num; }
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i].num, a[i].id = i;
int fl = 0;
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + a[i].num;
for (int i = 1; i <= n && !fl; ++i)
if (s[i] >= (m + 1) / 2) {
if (s[i] <= m) {
cout << i << '\n';
for (int j = 1; j <= i; ++j) ans[j] = a[j].id;
sort(ans + 1, ans + i + 1);
for (int j = 1; j <= i; ++j) cout << ans[j] << ' ';
cout << '\n';
} else {
if (a[i].num <= m) {
cout << 1 << '\n';
cout << a[i].id << '\n';
} else
puts("-1");
}
fl = 1;
break;
}
if (!fl) puts("-1");
for (int i = 1; i <= n; ++i) a[i].num = s[i] = ans[i] = 0;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, u, v, c;
vector<long long> G[100007];
long long wolny[100007];
long long wspol[100007];
long long ojciec[100007];
long long deg[100007];
bitset<100007> vis;
long long fpow(long long a, long long w) {
long long res = 1;
for (long long i = 0; i < 31; ++i) {
if (w & (1 << i)) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
}
return res;
}
long long inv(long long a) { return fpow(a, 1000000007 - 2); }
void dfs(long long v) {
vis[v] = 1;
for (auto it : G[v]) {
if (!vis[it]) {
ojciec[it] = v;
dfs(it);
}
}
}
queue<long long> Q;
void elim(long long v) {
long long ile = (inv(wspol[v]) * inv(G[ojciec[v]].size())) % 1000000007;
wolny[ojciec[v]] = (wolny[ojciec[v]] + ile * wolny[v]) % 1000000007;
if (G[v].size() > 1)
wspol[ojciec[v]] = (wspol[ojciec[v]] +
ile * ((1000000007 - inv(G[v].size())) % 1000000007)) %
1000000007;
if (--deg[ojciec[v]] == 1 && ojciec[v]) Q.push(ojciec[v]);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (long long i = 1; i < n; ++i) {
cin >> u >> v >> c;
G[v].push_back(u);
G[u].push_back(v);
wolny[u] += c;
wolny[v] += c;
}
dfs(0);
for (long long i = 0; i < n; ++i) {
if (G[i].size() == 1) {
wspol[i] = 1;
wolny[i] = 0;
Q.push(i);
} else {
wspol[i] = 1;
wolny[i] = (wolny[i] * inv(G[i].size())) % 1000000007;
}
deg[i] = G[i].size();
}
while (!Q.empty()) {
elim(Q.front());
Q.pop();
}
cout << (wolny[0] * inv(wspol[0])) % 1000000007;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<ll>;
using vvi = vector<vi>;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, l, r;
cin >> n >> l >> r;
ll s = 0, t = 0, a = 1, b = 1;
for (int i = 1; i <= n; i++) {
s += a, t += b;
if (i < l)
a *= 2;
else
a = 1;
if (i < r) b *= 2;
}
cout << s << " " << t << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, res, flag[100005], tag[100005], check[100005], sum[100005];
int k, la[100005], ff[500005], c[100005], tot, p[100005], pre[100005],
pos[100005];
struct node {
int a, b;
} e[500005];
void add(int a, int b) {
e[++k] = (node){a, b};
ff[k] = la[a];
la[a] = k;
}
void dfs1(int x) {
if (tot || check[x]) return;
c[x] = -1;
for (int a = la[x]; a && !tot; a = ff[a]) {
if (check[e[a].b]) continue;
if (c[e[a].b] == -1) {
while (x != e[a].b) p[++tot] = x, x = pre[x];
p[++tot] = e[a].b;
return;
}
if (!c[e[a].b]) pre[e[a].b] = x, dfs1(e[a].b);
}
c[x] = 1;
}
void dfs2(int S, int x) {
if (check[x]) return;
flag[x] = 1;
for (int a = la[x]; a; a = ff[a]) {
if (check[e[a].b]) continue;
if (tag[e[a].b]) {
if (tag[x] && tag[e[a].b]) continue;
if (pos[S] >= pos[e[a].b]) continue;
int y = e[a].b;
res++;
sum[1]++;
sum[pos[S] + 1]--;
sum[pos[y]]++;
sum[tot + 1]--;
} else if (!flag[e[a].b])
dfs2(S, e[a].b);
}
}
void dfs3(int S, int x) {
if (check[x]) return;
flag[x] = 1;
for (int a = la[x]; a; a = ff[a]) {
if (check[e[a].b]) continue;
if (tag[e[a].b]) {
if (tag[x] && tag[e[a].b]) continue;
if (pos[S] < pos[e[a].b]) continue;
int y = e[a].b;
res++;
sum[pos[y]]++;
sum[pos[S] + 1]--;
} else if (!flag[e[a].b])
dfs3(S, e[a].b);
}
}
int solve() {
int po = 0;
res = 0;
tot = 0;
memset(c, 0, sizeof(c));
for (int i = 1; i <= n && !tot; i++)
if (!c[i]) dfs1(i);
if (!tot) return 0;
reverse(p + 1, p + tot + 1);
memset(tag, 0, sizeof(tag));
memset(pos, 0, sizeof(pos));
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= tot; i++) tag[p[i]] = 1, pos[p[i]] = i;
memset(flag, 0, sizeof(flag));
for (int i = 1; i <= tot; i++) dfs2(p[i], p[i]);
memset(flag, 0, sizeof(flag));
for (int i = tot; i; i--) dfs3(p[i], p[i]);
for (int i = 1; i <= tot; i++) {
sum[i] += sum[i - 1];
if (sum[i] == res) {
po = p[i];
break;
}
}
check[po] = 1;
return po;
}
int main() {
int a, b;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &a, &b), add(a, b);
ans = solve();
if (!ans) {
printf("-1\n");
return 0;
}
if (!solve())
printf("%d\n", ans);
else
printf("-1\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rd(time(0));
template <typename T>
T gcd(T a, T b) {
return (b == 0) ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <typename T>
T max(T a, T b, T c, T d) {
return max(a, max(b, c, d));
}
template <typename T>
T i_rand(T l, T r) {
assert(l <= r);
return uniform_int_distribution<T>(l, r)(rd);
}
template <typename T>
T r_rand(T l, T r) {
return uniform_real_distribution<T>(l, r)(rd);
}
template <typename T>
void sfe(T a[], int l, int r) {
shuffle(a + l, a + 1 + r, rd);
}
template <typename T>
void sfe(vector<T> a) {
shuffle(a.begin(), a.end(), rd);
}
int n;
const long long _INF = -1e10;
const long long INF_ = 1e10;
map<long long, long long> d;
map<long long, long long> root;
signed main() {
clock_t _, __;
_ = clock();
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
set<long long> s;
cin >> n;
long long a;
cin >> a;
s.insert(_INF);
d[_INF] = a - 1;
root[_INF] = a;
s.insert(a);
d[a] = INF_;
root[a] = a;
for (int i = 2; i <= n; ++i) {
cin >> a;
long long l = *--s.upper_bound(a);
long long r = d[l];
cout << root[l] << ' ';
root[l] = a;
root[a] = a;
s.insert(l);
d[l] = a - 1;
s.insert(a);
d[a] = r;
}
__ = clock();
double ___ = double(__ - _) / (double)CLOCKS_PER_SEC;
cerr << "\nTime executed: " << setprecision(5) << fixed << ___ << " sec\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int M = 1000010;
const int N = 6666;
struct Edge {
int v, next, c, f;
} edge[M];
struct Dinic {
int head[N], cur[N], tol;
void init() {
tol = 0;
memset(head, -1, sizeof(head));
}
void AddEdge(int u, int v, int w, int rw = 0) {
edge[tol].v = v;
edge[tol].c = w;
edge[tol].f = 0;
edge[tol].next = head[u];
head[u] = tol++;
edge[tol].v = u;
edge[tol].c = rw;
edge[tol].f = 0;
edge[tol].next = head[v];
head[v] = tol++;
}
int Q[N];
int dep[N], sta[N];
bool bfs(int s, int t) {
int front = 0, tail = 0;
memset(dep, -1, sizeof(dep));
dep[s] = 0;
Q[tail++] = s;
while (front < tail) {
int u = Q[front++];
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (edge[i].c > edge[i].f && dep[v] == -1) {
dep[v] = dep[u] + 1;
if (v == t) return 1;
Q[tail++] = v;
}
}
}
return 0;
}
int dinic(int s, int t, int n) {
int maxflow = 0;
while (bfs(s, t)) {
int u = s, tail = 0;
for (int i = 0; i <= n; ++i) cur[i] = head[i];
while (~cur[s]) {
if (u == t) {
int tp = INF;
for (int i = tail - 1; i >= 0; --i)
tp = min(tp, edge[sta[i]].c - edge[sta[i]].f);
maxflow += tp;
for (int i = tail - 1; i >= 0; --i) {
edge[sta[i]].f += tp;
edge[sta[i] ^ 1].f -= tp;
if (edge[sta[i]].c - edge[sta[i]].f == 0) tail = i;
}
u = edge[sta[tail] ^ 1].v;
} else if (cur[u] != -1 && edge[cur[u]].c > edge[cur[u]].f &&
dep[u] + 1 == dep[edge[cur[u]].v]) {
sta[tail++] = cur[u];
u = edge[cur[u]].v;
} else {
while (u != s && cur[u] == -1) u = edge[sta[--tail] ^ 1].v;
cur[u] = edge[cur[u]].next;
}
}
}
return maxflow;
}
} solver;
vector<int> prime;
bool a[100000 + 10] = {0};
int id[N][33], tot;
vector<int> pri[111];
void init() {
for (int i = 2; i * i < 100000; i++)
for (int j = i * i; j < 100000; j += i) a[j] = 1;
for (int i = 2; i < 100000; i++)
if (!a[i]) prime.push_back(i);
}
void splite(int i, int x) {
int cnt = 0;
for (int j = 0; j < prime.size() && x >= prime[j]; j++) {
while (x % prime[j] == 0) {
pri[i].push_back(prime[j]);
id[i][cnt++] = ++tot;
x /= prime[j];
}
}
if (x > 1) {
pri[i].push_back(x);
id[i][cnt++] = ++tot;
}
}
int main() {
init();
int n, m;
tot = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
splite(i, x);
}
int s = 0, t = tot * 2 + 1;
solver.init();
for (int i = 1; i <= tot; i++) {
solver.AddEdge(s, i, 1);
solver.AddEdge(i + tot, t, 1);
}
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
for (int i = 0; i < pri[x].size(); i++) {
for (int j = 0; j < pri[y].size(); j++)
if (pri[x][i] == pri[y][j]) {
solver.AddEdge(id[x][i], id[y][j] + tot, 1);
solver.AddEdge(id[y][j], id[x][i] + tot, 1);
}
}
}
cout << solver.dinic(s, t, t + 1) / 2 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return (a * (b / gcd(a, b))); }
bool getbit(int num, int idx) { return (num >> idx & 1) == 1; }
int setbit(int num, int idx, bool val) {
if (val == true) return (num | (1 << idx));
return num & ~(1 << idx);
}
int flipbit(int num, int idx) { return num ^ (1 << idx); }
int cntbits(int mask) {
int res = 0;
while (mask) mask &= (mask - 1), res++;
return res;
}
int arr[100000 + 100], decrease[100000 + 100];
int main() {
int n, m;
vector<int> IncZero;
cin >> n >> m;
for (int i = 0; i < int(n); ++i) scanf("%d", &arr[i]);
for (int i = int(1); i < int(n); ++i) {
if (arr[i] < arr[i - 1]) IncZero.push_back(i - 1);
if (arr[n - i] <= arr[n - 1 - i]) decrease[n - i - 1] = decrease[n - i] + 1;
}
for (int i = 0; i < int(m); ++i) {
int r, l, x1, x2;
scanf("%d%d", &r, &l);
r--, l--;
vector<int>::iterator it = lower_bound(IncZero.begin(), IncZero.end(), r);
if (it != IncZero.end()) {
if (decrease[*it] - decrease[l] == l - *it ||
(*it < n - 1 && decrease[*it + 1] - decrease[l] == l - (*it + 1)) ||
*it > l)
cout << "Yes" << endl;
else
cout << "No" << endl;
} else
cout << "Yes" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
string s;
for (int i = 0; i < 10; i++) {
cout << i << endl;
getline(cin, s);
if (s != "no")
return cout << ((s == "great" || s == "cool" || s == "not bad" ||
s == "don't think so" || s == "don't touch me")
? "normal"
: "grumpy")
<< endl,
0;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void print_d(int n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 10;
char output_buffer[10];
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 10);
}
void print_ld(long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 11;
char output_buffer[11];
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 11);
}
void print_lld(long long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 21;
char output_buffer[21];
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 21);
}
void print_llu(long long unsigned n) {
int i = 21;
char output_buffer[21];
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 21);
}
void println_d(int n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 10;
char output_buffer[11];
output_buffer[10] = '\n';
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 11);
}
void println_ld(long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 11;
char output_buffer[12];
output_buffer[11] = '\n';
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 12);
}
void println_lld(long long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 21;
char output_buffer[22];
output_buffer[21] = '\n';
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 22);
}
void println_llu(long long unsigned n) {
int i = 21;
char output_buffer[22];
output_buffer[21] = '\n';
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 22);
}
char sp;
void printsp_d(int n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 10;
char output_buffer[11];
output_buffer[10] = sp;
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 11);
}
void printsp_ld(long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 11;
char output_buffer[12];
output_buffer[11] = sp;
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 12);
}
void printsp_lld(long long n) {
if (n < 0) {
n = -n;
putchar('-');
}
int i = 21;
char output_buffer[22];
output_buffer[21] = sp;
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 22);
}
void printsp_llu(long long unsigned n) {
int i = 21;
char output_buffer[22];
output_buffer[21] = sp;
do {
output_buffer[--i] = (n % 10) + '0';
n /= 10;
} while (n);
do {
putchar(output_buffer[i]);
} while (++i < 22);
}
int ans[1000001];
int main() {
int n, q;
scanf("%d%d", &n, &q);
int x = 0, y = 0, p = 0, a, b;
for (int i = 0; i < q; i++) {
scanf("%d", &a);
if (a == 1) {
scanf("%d", &b);
x += b;
y += b;
p += b;
x = (x + 2 * n) % n;
y = (y + 2 * n) % n;
p = (p + 2 * n) % n;
p = p % 2;
} else {
if (p == 0)
p = 1, ++x, --y;
else if (p == 1)
p = 0, --x, ++y;
x = (x + 2 * n) % n;
y = (y + 2 * n) % n;
}
}
for (int i = 1; i < n + 1; i++) {
if (i % 2 == 1)
ans[((i + x - 1) % n + 1)] = i;
else if (i % 2 == 0)
ans[((i + y - 1) % n + 1)] = i;
}
for (int i = 1; i < n; i++) printf("%d ", ans[i]);
printf("%d\n", ans[n]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int arr[105][105];
int a[10005];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> arr[i][j];
for (int i = 0; i < n; i++) {
int ans = 10000000000;
for (int j = 0; j < m; j++) ans = min(ans, arr[i][j]);
a[i] = ans;
}
sort(a, a + n);
cout << a[n - 1];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j;
double pos;
scanf("%d %d", &n, &m);
vector<int> type;
for (i = 0; i < n; ++i) {
scanf("%d %lf", &j, &pos);
type.push_back(j);
}
int lis[n];
lis[0] = 1;
for (i = 1; i < n; i++) {
lis[i] = 1;
for (j = 0; j < i; j++) {
if (type[i] >= type[j] && lis[i] < lis[j] + 1) {
lis[i] = lis[j] + 1;
}
}
}
int ans = 0;
for (i = 0; i < n; ++i) {
ans = ans < lis[i] ? lis[i] : ans;
}
printf("%d", n - ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long p = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, s;
cin >> n >> s;
vector<long long> a(n);
vector<pair<long long, long long>> b;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
b.push_back(make_pair(a[0], 1));
for (long long i = 1; i < n; i++) {
if (a[i] == b[b.size() - 1].first) {
b[b.size() - 1].second++;
} else {
b.push_back(make_pair(a[i], 1));
}
}
long long m = b.size();
long long pre[m], suf[m];
pre[0] = b[0].second;
suf[m - 1] = b[m - 1].second;
for (long long i = 1; i < m; i++) {
pre[i] = pre[i - 1] + b[i].second;
}
for (long long i = m - 2; i >= 0; i--) {
suf[i] = suf[i + 1] + b[i].second;
}
long long ans;
long long x = (n * ceil(log2(m)));
if (x <= 8 * s) {
ans = 0;
} else {
long long k = (long long)pow(2, (8 * s) / n);
ans = min(suf[k], pre[m - k - 1]);
for (long long i = 1; i <= m - k - 1; i++) {
ans = min(ans, pre[i - 1] + suf[i + k]);
}
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<string> vec_splitter(string s) {
for (char& c : s) c = c == ',' ? ' ' : c;
stringstream ss;
ss << s;
vector<string> res;
for (string z; ss >> z; res.push_back(z))
;
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, Head H, Tail... T) {
if (idx > 0) cerr << ", ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, T...);
}
const double PI = acos(-1);
void solve() {
long long n;
cin >> n;
;
vector<long long> d(5);
d[0] = n / 10000;
d[1] = (n % 10000) / 1000;
d[2] = (n % 1000) / 100;
d[3] = (n % 100) / 10;
d[4] = (n % 10);
long long nn = d[0] * 10000 + d[2] * 1000 + d[4] * 100 + d[3] * 10 + d[1];
long long ans = nn;
for (long long i = 0; i < 4; i++) ans = (ans * nn) % 100000;
if (ans < 10)
cout << "0000";
else if (ans < 100)
cout << "000";
else if (ans < 1000)
cout << "00";
else if (ans < 10000)
cout << "0";
cout << ans << endl;
}
signed main() {
cin.tie(nullptr);
std::ios::sync_with_stdio(false);
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char q[1058576];
int main() {
int flag = 0;
int now = 0;
while (gets(q)) {
int num = strlen(q);
flag = 0;
for (int i = 0; i < num; i++) {
if (q[i] == '#') {
if (now == -1) {
cout << endl;
now = 0;
}
flag = 1;
printf("%s\n", q);
now += 1;
break;
} else if (q[i] == ' ') {
continue;
} else
break;
}
if (flag == 0) {
for (int i = 0; i < num; i++) {
if (q[i] == ' ') {
continue;
} else {
printf("%c", q[i]);
}
}
now = -1;
}
}
if (now == -1) cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x;
long long int tmul = 1, ans = 0;
scanf("%d %d %d", &n, &k, &x);
long long int a[n], left[n], right[n];
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
for (int i = 0; i < k; i++) tmul *= x;
left[0] = a[0], right[n - 1] = a[n - 1];
for (int i = 1; i < n; i++) left[i] = left[i - 1] | a[i];
for (int i = n - 2; i >= 0; i--) right[i] = right[i + 1] | a[i];
for (int i = 1; i < n - 1; i++) {
ans = max(ans, (left[i - 1]) | right[i + 1] | (a[i] * tmul));
}
if (n == 1)
ans = max(ans, (0 | 0 | (a[0] * tmul)));
else {
ans = max(ans, (0 | right[1] | (a[0] * tmul)));
ans = max(ans, (left[n - 2]) | 0 | (a[n - 1] * tmul));
}
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <class T>
typename T::value_type arr_sum(const T& v, int n) {
typename T::value_type sum = 0;
for (int i = (0); i < (n); ++i) sum += v[i];
return sum;
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
int main() {
int n, k;
cin >> n >> k;
vector<pair<int, int>> g(n - 1);
for (int i = (0); i < (n - 1); ++i) {
cin >> g[i].first >> g[i].second;
--g[i].first;
--g[i].second;
}
vector<vector<long long>> dp(k + 1, vector<long long>(n));
vector<vector<long long>> dp2(k + 1, vector<long long>(n));
for (int i = (0); i < (n); ++i) {
dp2[0][i] = dp[0][i] = 1;
}
for (auto i : g) {
++dp[1][i.first];
++dp[1][i.second];
++dp2[1][i.first];
++dp2[1][i.second];
}
for (int i = (2); i < (k + 1); ++i) {
for (auto j : g) {
dp[i][j.second] += dp2[i - 1][j.first];
dp[i][j.second] -= dp2[i - 2][j.second];
dp[i][j.first] += dp2[i - 1][j.second];
dp[i][j.first] -= dp2[i - 2][j.first];
}
for (int j = (0); j < (n); ++j) {
dp2[i][j] = dp[i][j] + dp2[i - 2][j];
}
}
cout << accumulate(dp[k].begin(), dp[k].end(), 0LL) / 2;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int c = 0;
int m = 0;
for (int i = 0; i < n; i++) {
c = 0;
for (int j = 0; j < n; j++) {
if (v[i] == v[j]) c++;
}
if (c > m) m = c;
}
cout << m << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define pb push_back
#define mp make_pair
#define vi vector<int>
#define pii pair<int, int>
#define vpii vector<pair<int, int>>
#define mod 1000000007 //(10power9)+7
#define MAXN 1000005
#define inf 100000000000000000
#define N 1000005
int spf[MAXN];
// vector<int> graph[1000000];
vector<int> moreprimes;
vector<int> smallest_factor;
vector<bool> prime;
vector<int> primes;
void sieve(int maximum)
{
maximum = max(maximum, 1ll);
smallest_factor.assign(maximum + 1, 0);
prime.assign(maximum + 1, true);
prime[0] = prime[1] = false;
primes = {};
for (int p = 2; p <= maximum; p++)
if (prime[p])
{
smallest_factor[p] = p;
primes.push_back(p);
for (int64_t i = int64_t(p) * p; i <= maximum; i += p)
if (prime[i])
{
prime[i] = false;
smallest_factor[i] = p;
}
}
}
const int P_MAX = int64_t(1e5) + 5;
const int64_t INF64 = int64_t(2e18) + 5;
void moreprimesneeded()
{
bitset<10000005> b;
b.set(); // al 1,1,1,1,1,1,..
b[0] = b[1] = 0;
for (int i = 2; i <= 10000000; i++)
{
if (b[i] == 1)
{
moreprimes.push_back(i);
for (int j = i * i; j <= 10000000; j += i)
{
b[j] = 0;
}
}
}
}
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
// void SecondSieve(int arr[])
void niceSieve(int *primes)
{
// prime is 1.
// non primes are 0.
primes[0] = primes[1] = 0;
// mark all as prime first.
for (int i = 2; i < N; i++)
{
primes[i] = 1;
}
for (int i = 2; i < N; i++)
{
if (primes[i] == 1)
{
for (int j = i * i; j < N; j += i)
{
primes[j] = 0;
}
}
}
}
//calculate direct prime factors example >>>>24=2*2*2*3 in o(sqrt(n)) for an input no. n
// This worked for 5000 test cases and sigma (n)<= (10power10)
vector<int> primeFactors(int n)
{
// Print the number of 2s that divide n
vector<int> v;
while (n % 2 == 0)
{
// cout << 2 << " ";
v.push_back(2);
n = n / 2;
}
// n must be odd at this point. So we can skip
// one element (Note i = i +2)
for (int i = 3; i <= sqrt(n); i = i + 2)
{
// While i divides n, print i and divide n
while (n % i == 0)
{
// cout << i << " ";
v.push_back(i);
n = n / i;
}
}
// This condition is to handle the case when n
// is a prime number greater than 2
if (n > 2)
// cout << n << " ";
v.push_back(n);
return v;
}
// calculate sieve ...in lowest time possible...
// SPF[ ] :>>>>> stores smallest prime factor for every number
// Calculating SPF (Smallest Prime Factor) for every
// number till MAXN.
// Time Complexity : O(nloglogn)
void sieveapni()
{
spf[1] = 1;
for (int i = 2; i < MAXN; i++)
// marking smallest prime factor for every
// number to be itself.
spf[i] = i;
// separately marking spf for every even
// number as 2
for (int i = 4; i < MAXN; i += 2)
spf[i] = 2;
for (int i = 3; i * i < MAXN; i++)
{
// checking if i is prime
if (spf[i] == i)
{
// marking SPF for all numbers divisible by i
for (int j = i * i; j < MAXN; j += i)
// marking spf[j] if it is not
// previously marked
if (spf[j] == j)
spf[j] = i;
}
}
}
vector<pair<int, int>> getFactorizationinPairs(int x)
{
vector<pair<int, int>> ret;
while (x != 1)
{
if (ret.size() == 0)
{
ret.push_back(make_pair(spf[x], 1));
}
else if (ret.back().first == spf[x])
{
ret.back().second++;
}
else if (ret.back().first != spf[x])
{
ret.push_back(make_pair(spf[x], 1));
}
// ret.push_back(spf[x]);
x = x / spf[x];
}
return ret;
}
//below code uses sieve to return primes of a no in log(n) times
//ONLY GOOD FOR UPTO X=POWER(10,6)
// A O(log n) function returning primefactorization
//EXAMPLE 24=2*2*2*3 SO RETURNED VECTOR CONTAIN 2,2,2,3
// by dividing by smallest prime factor at every step
vector<int> getFactorization(int x)
{
vector<int> ret;
while (x != 1)
{
ret.push_back(spf[x]);
x = x / spf[x];
}
return ret;
}
/* Iterative Function to calculate (x^y)%p
in O(log y) */
unsigned long long power(unsigned long long x, int y, int p)
{
unsigned long long res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
res = (res * x) % p;
// y must be even now
y = y >> 1; // y = y/2
x = (x * x) % p;
}
return res;
}
// Returns n^(-1) mod p
unsigned long long modInverse(unsigned long long n, int p)
{
return power(n, p - 2, p);
}
// Returns nCr % p using Fermat's little
// theorem.
unsigned long long nCrModPFermat(unsigned long long n, int r, int p)
{
// If n<r, then nCr should return 0
if (n < r)
return 0;
// Base case
if (r == 0)
return 1;
// Fill factorial array so that we
// can find all factorial of r, n
// and n-r
unsigned long long fac[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) % p;
}
//calculate ncr directly without any mod with a prime number...
int ncr(int n, int r)
{
int ans = 1;
int x = 1;
while (x <= r)
{
ans = ans * n / x;
x++;
n--;
}
return ans;
}
//calculate direct factorial...
int fact(int n)
{
int ans = 1;
while (n >= 1)
{
ans = ans * n;
n--;
}
return ans;
}
// calculate a power to b (a^^b) very fast along with mod
int fastApowB(int base, int exp)
{
base %= mod;
int result = 1;
while (exp > 0)
{
if (exp & 1)
result = (result * base) % mod;
base = (base * base) % mod;
exp >>= 1;
}
return result;
}
// // Takes graph inputs...
// void graphInput(int a[], int b[])
// {
// // int u, v;
// // int i = 0;
// // // while (m--)
// // {
// // // cin >> u >> v;
// // graph[u].pb(v);
// // graph[v].pb(u);
// // }
// }
// make a depth first search...
// void dfs(int u, int par)
// {
// for (int v : graph[u])
// {
// if (v == par)
// continue;
// dfs(v, u);
// }
// }
// Calculates all possible divisors of the given number...
vector<int> divisors(int n)
{
vector<int> ans;
for (int i = 1; i * i <= n; i++)
{
if (n % i == 0)
{
if (n / i == i)
ans.push_back(i);
else
{
ans.push_back(i);
ans.push_back(n / i);
}
}
}
return ans;
}
vector<int> graph[200005];
// Our Driver Code
int32_t main()
{
IOS
int t;
cin >> t;
while (t--)
{
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
sort(a, a + n);
vector<pair<int, int>> v;
for (int i = 0; i < n; i++)
{
if (v.size() == 0 || a[i] != v.back().first)
{
v.push_back(make_pair(a[i], 1));
}
else if (a[i] == v.back().first)
{
v.back().second++;
}
}
int s = v.size();
// int suffixsums[s]={0};
int keep = 0;
int p = s;
while (keep < k)
{
p--;
keep += v[p].second;
}
if (keep == k)
{
cout << "1\n";
}
else if (keep > k)
{
int Nn = v[p].second;
int r = k-(keep-v[p].second);
cout << nCrModPFermat(Nn, r, mod) << "\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int NN = 303030;
char s[NN];
char ans[NN];
int main() {
int T;
cin >> T;
while (T--) {
int n, k;
cin >> n >> k;
scanf("%s", s + 1);
int flag = 1;
for (int i = 1; i <= n; i++) {
if (i <= k)
ans[i] = s[i];
else {
int u = (i - 1) % k + 1;
if (ans[u] != '?' and s[i] != '?' and ans[u] != s[i]) {
flag = 0;
} else if (s[i] != '?') {
ans[u] = s[i];
}
}
}
int a = 0, b = 0;
for (int i = 1; i <= k; i++) {
if (ans[i] == '0')
a++;
else if (ans[i] == '1')
b++;
}
if (max(a, b) * 2 > k) flag = 0;
if (flag)
puts("YES");
else
puts("NO");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[51111];
long long dp[51111][511];
bool b[51111];
long long ans;
long long n, k;
void DFS(long long x) {
vector<long long> must;
b[x] = 1;
for (auto i : adj[x]) {
if (!b[i]) {
DFS(i);
must.push_back(i);
}
}
for (auto i : must) {
for (long long j = 0; j < k; j++) {
dp[x][j + 1] += dp[i][j];
}
}
ans += dp[x][k];
long long tren = 0;
for (auto i : must) {
for (long long j = 1; j < k; j++) {
tren += dp[i][j - 1] * (dp[x][k - j] - dp[i][k - j - 1]);
}
}
ans += tren / 2;
dp[x][0] = 1;
}
int main() {
ans = 0;
scanf("%lld%lld", &n, &k);
for (long long i = 0; i < n - 1; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
DFS(1);
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 1e5 + 5;
long long dp[2 * maxn];
int main() {
int n, k;
cin >> n >> k;
char s[maxn];
scanf("%s", s + 1);
memset(dp, 0, sizeof dp);
deque<int> d;
d.push_back(0);
for (int i = 1; i <= n + k; i++) {
dp[i] = dp[i - 1] + i;
if (i - k > 0 && s[i - k] == '1') {
while (!d.empty() && d.front() < i - 2 * k - 1) d.pop_front();
dp[i] = min(dp[i], dp[d.front()] + i - k);
}
while (!d.empty() && dp[d.back()] >= dp[i]) d.pop_back();
d.push_back(i);
}
long long m = 0x3f3f3f3f3f3f3f3f;
for (int i = n; i <= n + k; i++) {
m = min(dp[i], m);
}
cout << m;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char alt(char c) {
if (c == 'r')
return 'b';
else
return 'r';
}
int main() {
ios_base::sync_with_stdio(false);
long long n, t, i, j, k, m, ans = 0, an;
string a, b, c;
cin >> n;
cin >> a;
b = a;
char cc = 'r';
n = m = 0;
k = j = 0;
for (i = 0; i < a.size(); i += 2) {
if (a[i] != cc) n++;
if (a[i] != alt(cc)) m++;
}
cc = alt(cc);
for (i = 1; i < a.size(); i += 2) {
if (a[i] != cc) k++;
if (a[i] != alt(cc)) j++;
}
an = min(max(n, k), max(m, j));
cout << an << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
struct node {
int t = INT_MAX, idx = 0, c = 0;
};
using namespace std;
int main() {
ios ::sync_with_stdio(false);
map<int, deque<node> > mappy;
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int l, r, t, c;
cin >> l >> r >> t >> c;
node obj;
obj.t = t;
obj.idx = i;
obj.c = c;
for (int j = l; j <= r; j++) mappy[j].push_back(obj);
}
long long int ans = 0;
for (int i = 1; i <= n; i++) {
node curr;
while (!mappy[i].empty()) {
node obj = mappy[i].front();
if (obj.t < curr.t)
curr = obj;
else if (obj.t == curr.t && obj.idx < curr.idx)
curr = obj;
mappy[i].pop_front();
}
ans += curr.c;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
vector<pair<int, int> > G[maxn];
vector<int> lef[maxn];
vector<vector<int> > op;
int pr[maxn], root;
bool vis[maxn];
void dfs1(int s) {
vis[s] = 1;
for (auto it : G[s])
if (!vis[it.first]) {
pr[it.first] = s;
dfs1(it.first);
lef[s].push_back(lef[it.first][0]);
}
if (lef[s].size() == 0) lef[s].push_back(s);
}
void add_path(int v, int x) {
if (lef[v].size() == 1) {
op.push_back({root, v, x});
return;
}
op.push_back({root, lef[v][0], x / 2});
op.push_back({root, lef[v][1], x / 2});
op.push_back({lef[v][0], lef[v][1], -x / 2});
}
void add_edge(int v, int x) {
if (pr[v] == root) {
add_path(v, x);
return;
}
add_path(v, x);
add_path(pr[v], -x);
}
void dfs2(int s) {
vis[s] = 1;
for (auto it : G[s])
if (!vis[it.first]) {
add_edge(it.first, it.second);
dfs2(it.first);
}
}
int main() {
int n, u, v, x;
cin >> n;
if (n == 1) {
puts("YES");
puts("1");
scanf("%d%d%d", &u, &v, &x);
printf("%d %d %d", u, v, x);
return 0;
}
for (int i = 0; i < n - 1; i++) {
scanf("%d%d%d", &u, &v, &x);
G[u].push_back(make_pair(v, x));
G[v].push_back(make_pair(u, x));
}
for (int i = 1; i <= n; i++)
if (G[i].size() == 2) {
cout << "NO";
return 0;
}
root = 1;
puts("YES");
while (G[root].size() != 1) root++;
dfs1(root);
memset(vis, 0, sizeof(vis));
dfs2(root);
printf("%d\n", op.size());
for (auto it : op) printf("%d %d %d\n", it[0], it[1], it[2]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return (!b) ? a : gcd(b, a % b);
}
int n, p;
void solve() {
cin >> n >> p;
int k = __builtin_popcount(n);
for (int k = 0; k <= 35; k++) {
long long int num = n - k * p;
if (k < __builtin_popcount(num) || k > num) continue;
cout << k;
return;
}
cout << -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
int a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, ans = 1e9;
cin >> n;
string s;
cin >> s;
for (int i = 0; i + 3 < s.size(); i++) {
int cnt = 0;
for (int j = 0; j < 4; j++) {
if (j == 0) cnt += min(abs(s[i + j] - 'A'), 26 - abs(s[i + j] - 'A'));
if (j == 1) cnt += min(abs(s[i + j] - 'C'), 26 - abs(s[i + j] - 'C'));
if (j == 2) cnt += min(abs(s[i + j] - 'T'), 26 - abs(s[i + j] - 'T'));
if (j == 3) cnt += min(abs(s[i + j] - 'G'), 26 - abs(s[i + j] - 'G'));
}
ans = min(ans, cnt);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5;
int n, k;
int a[MAXN];
int b[MAXN];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
if (k == 1) {
int ans = a[0];
for (int i = 0; i < n; i++) ans = min(ans, a[i]);
cout << ans << endl;
} else if (k == 2) {
b[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
b[i] = min(a[i], b[i + 1]);
}
int pref = a[0];
int ans = max(pref, b[1]);
for (int i = 1; i < n - 1; i++) {
pref = min(pref, a[i]);
ans = max(ans, max(b[i + 1], pref));
}
cout << ans << endl;
} else {
int ans = a[0];
for (int i = 0; i < n; i++) {
ans = max(ans, a[i]);
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
std ::ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
string s;
cin >> s;
long long a[2] = {0};
for (long long i = 0; i < n; i++) a[s[i] - 48]++;
if (a[0] == a[1]) {
cout << "2\n" << s[0] << " ";
for (long long i = 1; i < n; i++) cout << s[i];
} else {
cout << "1\n" << s;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 10;
const int INF = 2 * 1000 * 1000 * 1000 + 10;
const long long INF64 = 1e18;
int a, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<int> dx = {1, 0, -1, 0};
vector<int> dy = {0, 1, 0, -1};
cin >> a >> b;
int cx = 0, cy = 0;
int cnt = 0;
int cur = 1;
int dir = 0;
if ((a == 1 || a == 0) && b == 0) {
cout << 0;
return 0;
}
while (true) {
for (int t = 0; t < 2; ++t) {
for (int i = 0; i < cur; ++i) {
cx += dx[dir];
cy += dy[dir];
if (cx == a && cy == b) {
cout << cnt << '\n';
return 0;
}
}
dir = (dir + 1) % 4;
cnt++;
}
cur++;
}
cout << cnt;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n_d(int n) {
int res = 0;
while (n > 0) {
res += (n % 10);
n = n / 10;
}
return res;
}
int main() {
int n;
cin >> n;
while (n_d(n) % 4 != 0) {
n++;
}
cout << n << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
if (k == 0)
cout << s << endl;
else if (n == 1 && k > 0)
cout << "0" << endl;
else if (k >= n && n > 1) {
cout << 1;
for (int i = 1; i < n; i++) cout << 0;
cout << endl;
} else if (k < n && n > 1) {
if (s[0] == '1') {
int j = 1, i = 1;
while (j <= k && i < n) {
if (s[i] - '0' != 0) {
s[i] = '0';
j++;
}
i++;
}
cout << s << endl;
} else {
s[0] = '1';
int j = 1, i = 1;
while (i < n && j < k) {
if (s[i] - '0' != 0) {
s[i] = '0';
j++;
}
i++;
}
cout << s << endl;
}
}
}
| 1 |
#include<bits/stdc++.h>
#define int long long
#define mem(x,y) memset(x,y,sizeof(x))
#define mod 998244353
using namespace std;
int read(){
int s = 0,w = 1;
char ch = getchar();
while(ch < '0' || ch > '9'){if(ch == '-')w = -1;ch = getchar();}
while(ch >= '0' && ch <= '9')s = s * 10 + ch - '0',ch = getchar();
return s * w;
}
int n,m;
int a[200010];
int f[200010];
int dp[500010];
int s;
int ans;
int poww(int x,int y){
if(x == 1 || y == 0)return 1;
if(x == 0)return 0;
if(y == 1)return x;
int res = poww(x,y / 2);
res = (res * res) % mod;
if(y % 2 == 1)res = (res * x) % mod;
return res;
}
int get(int x,int y){dp[0] = 1;for(int i = 1;i <= x;i ++)dp[i] = (dp[i - 1] * i) % mod;int res = dp[x];return res * poww(dp[x - y],998244351) % mod * poww(dp[y],998244351) % mod;}
signed main(){
for(int i = 1;i <= 1;i ++){
int rp;
rp ++;
}
for(int i = 1;i <= 1;i ++){
int rp;
rp ++;
}
for(int i = 1;i <= 1;i ++){
int rp;
rp ++;
}
for(int i = 1;i <= 1;i ++){
int rp;
rp ++;
}
for(int i = 1;i <= 1;i ++){
int rp;
rp ++;
}
for(int i = 1;i <= 1;i ++){
int rp;
rp ++;
}
for(int i = 1;i <= 1;i ++){
int rp;
rp ++;
}
for(int i = 1;i <= 1;i ++){
int rp;
rp ++;
}
cin>>n>>m;
for(int i = 1;i <= n;i ++)f[a[i] = read()] = i;
for(int i = 1;i <= n - 1;i ++)if(f[a[i] + 1] > f[a[i + 1] + 1])s ++;
cout<<get(n + m - s - 1,n);
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long ba = 131;
long long qk(long long x, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x;
y >>= 1;
x = x * x;
}
return ans;
}
const int dx[8] = {0, -1, 0, 1, -1, -1, 1, 1},
dy[8] = {-1, 0, 1, 0, -1, 1, -1, 1};
const int dxx[8] = {2, 1, -1, -2, -2, -1, 1, 2},
dyy[8] = {1, 2, 2, 1, -1, -2, -2, -1};
long long sum[1000005], a[1000005];
unordered_map<long long, int> mp1;
struct node {
int l, r, id;
} e[1000005];
bool cmp(node x, node y) { return x.r < y.r; }
long long tree[1000005], ans[1000005];
int n, m;
void add(int x, long long va) {
for (int i = x; i <= n; i += i & -i) {
tree[i] ^= va;
}
}
long long query(int x) {
long long ans = 0;
for (int i = x; i > 0; i -= i & -i) {
ans ^= tree[i];
}
return ans;
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] ^ a[i];
}
cin >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
e[i].l = x, e[i].r = y;
e[i].id = i;
}
sort(e + 1, e + 1 + m, cmp);
int j = 1;
for (int i = 1; i <= m; i++) {
while (j <= n && j <= e[i].r) {
if (mp1[a[j]]) add(mp1[a[j]], a[j]);
add(j, a[j]);
mp1[a[j]] = j;
j++;
}
ans[e[i].id] =
sum[e[i].r] ^ sum[e[i].l - 1] ^ query(e[i].r) ^ query(e[i].l - 1);
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << '\n';
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
;
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, k, sum;
long long s1, s2;
cin >> n >> k;
s1 = 0;
s2 = 0;
sum = n / 2;
k++;
s1 = sum / k;
k--;
s2 = s1 * k;
cout << s1 << " " << s2 << " " << n - s1 - s2;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 2;
const int M = 1e5 + 2;
const int mod = 1e9 + 7;
const int inf = 1e9;
const long long INF = 1e16;
void data() {}
template <typename T>
void scerr(T nums) {
for (auto it : nums) cerr << it << " | ";
cerr << "\n";
}
string s;
int n;
long long ans = -1, dp[100][20], a[100], num;
long long rec(int k, int last) {
if (k == n - 1) return 1;
if (dp[k][last]) return dp[k][last];
long long cnt = 0;
if ((last + a[k + 1]) % 2 == 1) {
cnt += rec(k + 1, (last + a[k + 1]) / 2);
cnt += rec(k + 1, (last + a[k + 1]) / 2 + 1);
} else
cnt += rec(k + 1, (last + a[k + 1]) / 2);
dp[k][last] = cnt;
return cnt;
}
int main() {
data();
cin >> s;
n = (int)s.size();
for (int i = 0; i < n; ++i) {
a[i] = s[i] - '0';
if (i)
if (abs(a[i - 1] - a[i]) > 1) ans = 0;
}
for (int i = 0; i < 10; ++i) {
ans += rec(0, i);
}
printf("%lld", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int nth_bit(int64_t num, int n) { return (num >> n) & 1; }
int main() {
int N;
cin >> N;
vector<char> C(N);
vector<int> A(N);
for (int i = 0; i < N; i++) cin >> C[i] >> A[i];
vector<int> num(2);
for (int k = 0; k < 2; k++) {
int x = k * 1023;
for (int i = 0; i < N; i++) {
if (C[i] == '|') {
x |= A[i];
} else if (C[i] == '&') {
x &= A[i];
} else {
x ^= A[i];
}
}
num[k] = x;
}
int And = 1023, Xor = 0, Or = 0;
for (int k = 0; k < 10; k++) {
int b0 = nth_bit(num[0], k);
int b1 = nth_bit(num[1], k);
if (b0 && b1) {
Or |= 1 << k;
} else if (!b0 && !b1) {
And ^= 1 << k;
} else if (b0 && !b1) {
Xor |= 1 << k;
}
}
cout << 3 << endl;
cout << "& " << And << endl;
cout << "^ " << Xor << endl;
cout << "| " << Or << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string st;
long q, calc;
long ways[1200000];
long long ans;
long tways;
long n;
long er;
bool let(char c) { return (c >= 'a' && c <= 'z'); }
bool dig(char c) { return (c >= '0' && c <= '9'); }
bool pref(char c) {
if (c == '_') return true;
return (dig(c) || let(c));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> st;
n = st.size();
for (int i = 0; i < st.size(); i++) {
if (st[i] == '@') {
q = i - 1;
calc = 0;
while (q >= 0 && pref(st[q])) {
if (let(st[q])) ++calc;
--q;
}
ways[i] = calc;
}
if (st[i] == '.') {
q = i - 1;
er = 0;
tways = 0;
while (true) {
if (q < 0) {
er = 1;
break;
}
if (st[q] == '@') {
if (q == i - 1) er = 1;
break;
}
if (!dig(st[q]))
if (!let(st[q])) {
er = 1;
break;
}
--q;
}
if (er == 0) tways = ways[q];
q = i + 1;
while (true) {
if (q >= n) break;
if (let(st[q]))
ans += tways;
else
break;
++q;
}
}
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110000;
int n, m, a[maxn], c[maxn], b[maxn], d[maxn];
struct node {
int x, y, z;
} k[maxn];
int solve(int mid) {
memset(a, 0, sizeof(a));
queue<int> q;
vector<int> ha[101000];
for (int i = 0; i < m; i++) {
if (k[i].z > mid) {
a[k[i].y]++;
ha[k[i].x].push_back(k[i].y);
}
}
for (int i = 1; i <= n; i++) {
if (a[i] == 0) q.push(i);
}
int ans = 0, flag = 0;
while (!q.empty()) {
int p = q.front();
b[p] = ans++;
q.pop();
for (int i = 0; i < ha[p].size(); i++) {
a[ha[p][i]]--;
if (a[ha[p][i]] == 0) q.push(ha[p][i]);
}
}
for (int i = 1; i <= n; i++) {
if (a[i] != 0) return 0;
}
return 1;
}
int main() {
int maxx = -0x3f3f3f3f;
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &k[i].x, &k[i].y, &k[i].z);
maxx = max(k[i].z, maxx);
}
int l = 0, r = maxx, mid, sum;
while (l <= r) {
mid = (l + r) / 2;
if (solve(mid)) {
r = mid - 1;
sum = mid;
for (int i = 1; i <= n; i++) {
d[i] = b[i];
}
} else
l = mid + 1;
}
int s = 0;
for (int i = 0; i < m; i++) {
if (k[i].z <= sum) {
if (d[k[i].x] > d[k[i].y]) c[s++] = i + 1;
}
}
printf("%d %d\n", sum, s);
for (int i = 0; i < s; i++) printf("%d ", c[i]);
printf("\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x = n / 7, y = n % 7, z = -1;
for (int i = 0; i <= x; i++) {
if ((7 * i + y) % 4 == 0) {
z = (7 * i + y) / 4;
x -= i;
break;
}
}
if (z == -1) {
cout << -1;
return 0;
}
for (int i = 0; i < z; i++) cout << 4;
for (int i = 0; i < x; i++) cout << 7;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, taxi = 0, pizza = 0, girl = 0;
vector<int> taxi_id, pizza_id, girl_id;
string s[101];
cin >> n;
for (int i = 0; i < n; ++i) {
int k, ltaxi = 0, lpizza = 0, lgirl = 0;
cin >> k >> s[i];
for (int j = 0; j < k; j++) {
string t;
int temp, p = 0, l = 0;
cin >> t;
temp = t[0];
for (int q = 1; q < 8; ++q)
if (t[q] != '-') {
if (t[q] == temp) ++p;
if (t[q] < temp) {
++l;
temp = t[q];
}
}
if (p == 5)
ltaxi++;
else if (l == 5)
lpizza++;
else
lgirl++;
}
if (ltaxi >= taxi) {
if (ltaxi == taxi)
taxi_id.push_back(i);
else {
taxi_id.clear();
taxi_id.push_back(i);
}
taxi = ltaxi;
}
if (lpizza >= pizza) {
if (lpizza == pizza)
pizza_id.push_back(i);
else {
pizza_id.clear();
pizza_id.push_back(i);
}
pizza = lpizza;
}
if (lgirl >= girl) {
if (lgirl == girl)
girl_id.push_back(i);
else {
girl_id.clear();
girl_id.push_back(i);
}
girl = lgirl;
}
}
cout << "If you want to call a taxi, you should call: ";
for (int i = 0; i < taxi_id.size() - 1; ++i) cout << s[taxi_id[i]] << ", ";
cout << s[taxi_id[taxi_id.size() - 1]] << "." << endl;
cout << "If you want to order a pizza, you should call: ";
for (int i = 0; i < pizza_id.size() - 1; ++i) cout << s[pizza_id[i]] << ", ";
cout << s[pizza_id[pizza_id.size() - 1]] << "." << endl;
cout
<< "If you want to go to a cafe with a wonderful girl, you should call: ";
for (int i = 0; i < girl_id.size() - 1; ++i) cout << s[girl_id[i]] << ", ";
cout << s[girl_id[girl_id.size() - 1]] << "." << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, j, i;
cin >> n >> k;
int a[n + 1];
for (i = 0; i < n; i++) cin >> a[i];
j = 0;
for (i = 0; i < k; i++) {
if (a[j] < 0)
a[j] = a[j] * -1;
else
break;
j++;
}
if ((k - i) % 2 == 0 || i > k) {
int sum = 0;
for (i = 0; i < n; i++) sum += a[i];
cout << sum;
} else {
int sum = 0, min = INT_MAX;
for (i = 0; i < n; i++) {
if (a[i] < min) min = a[i];
sum += a[i];
}
cout << sum - 2 * min;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long maxi = -1, mini = 9999, swp, n = 4, sum;
vector<long long> A;
long long mass[n];
A.reserve(n);
for (auto i = 0; i < n; i++) {
cin >> swp;
if (maxi < swp) maxi = swp;
if (mini > swp) mini = swp;
A.push_back(swp);
}
A.resize(n);
std::sort(A.begin(), A.end());
mass[0] = A[0];
for (auto i = 1; i < n; i++) {
mass[i] = mass[i - 1] + A[i];
}
sum = maxi + mini;
if (sum == (mass[3] - sum) or maxi == mass[2])
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MIF = 1e9 + 7;
const double PI = 4 * atan(1);
inline long long in() {
long long x = 0;
int n = 1;
char c = getchar();
while (!isdigit(c)) {
n = (c == '-') ? -1 : 1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * n;
}
inline char inc() {
char c = getchar();
while (!isalnum(c)) c = getchar();
return c;
}
inline string ins() {
string s = "";
char c = getchar();
while (!isalnum(c)) c = getchar();
while (isalnum(c)) s = s + c, c = getchar();
return s;
}
inline void out(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) out(x / 10);
putchar(x % 10 + '0');
}
void fre() {
ofstream fre("42.inp");
{
fre << R"(
6 7
0 1 2
4 2 4
2 0 1
3 0 9
2 5 7
)";
}
fre.close();
freopen(
"42"
".inp",
"r", stdin);
}
const int N = 100005;
typedef long long ar_N[N];
ar_N wei, dep, di, ve, bac10;
long long PHI, res;
int n, M;
vector<pair<int, int> > g[N];
bool ct[N];
map<long long, int> mp, mp2, null;
void DFS_WEI(int first, int last) {
wei[first] = 1;
for (auto& i : g[first])
if (!ct[i.first] && i.first != last) {
DFS_WEI(i.first, first);
wei[first] += wei[i.first];
}
}
int CT_FIND(int first) {
int halfwei = wei[first] / 2;
while (1) {
int last = first;
for (auto& i : g[first])
if (!ct[i.first] && halfwei < wei[i.first] && wei[i.first] < wei[first]) {
first = i.first;
break;
}
if (first == last) return first;
}
}
long long POW(int first, long long second) {
long long res = 1, xx = first;
while (second > 0) {
if (second & 1) res = (res * xx) % M;
second >>= 1;
xx = (xx * xx) % M;
}
return res;
}
void GET(long long Di, long long Dep) {
Di = -Di;
while (Di < 0) Di += M;
Dep = POW(PHI, Dep);
res += mp[(Di * Dep) % M] - mp2[(Di * Dep) % M];
}
void CT_CAL(int first, int last) {
for (auto& i : g[first])
if (!ct[i.first] && i.first != last) {
dep[i.first] = dep[first] + 1;
ve[i.first] = ((i.second * bac10[dep[first]]) % M + ve[first]) % M;
di[i.first] = (di[first] * 10 + i.second) % M;
if (di[i.first] == 0) res++;
if (ve[i.first] == 0) res++;
mp[ve[i.first]]++;
CT_CAL(i.first, first);
}
}
void CT_GET(int first, int last) {
GET(di[first], dep[first]);
for (auto& i : g[first])
if (!ct[i.first] && i.first != last) CT_GET(i.first, first);
}
void CT_UPDATE(int first, int last) {
mp2[ve[first]]++;
for (auto& i : g[first])
if (!ct[i.first] && i.first != last) CT_UPDATE(i.first, first);
}
void CT_SOLVE(int first) {
mp = null;
DFS_WEI(first, first);
first = CT_FIND(first);
dep[first] = ve[first] = di[first] = 0;
CT_CAL(first, first);
for (auto& i : g[first])
if (!ct[i.first]) {
mp2 = null;
CT_UPDATE(i.first, first);
CT_GET(i.first, first);
}
ct[first] = true;
for (auto& i : g[first])
if (!ct[i.first]) CT_SOLVE(i.first);
}
void MAKE_PHI() {
long long m = M;
PHI = m;
for (int i = 2; i * i <= m; i++)
if (m % i == 0) {
PHI = ((PHI / i) * (i - 1));
while (m % i == 0) m /= i;
}
if (m > 1) PHI = ((PHI / m) * (m - 1));
PHI--;
PHI = POW(10, PHI);
}
int main() {
n = in(), M = in();
bac10[0] = 1;
for (int i = 1; i <= 100000; i++) bac10[i] = (bac10[i - 1] * 10) % M;
MAKE_PHI();
for (int i_ = 1; i_ <= n - 1; i_++) {
int first = in(), second = in(), z = in();
g[first].emplace_back(second, z);
g[second].emplace_back(first, z);
}
CT_SOLVE(1);
out(res);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int count = 0;
for (int i = 0; i <= max(n, m); i++) {
for (int j = 0; j <= max(n, m); j++) {
if (i * i + j == n && j * j + i == m) count++;
}
}
cout << count;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k,
mas[100001] = {
0,
};
void fun(int a, int b, int sum) {
if (b < 2) {
cout << sum << ' ';
return;
}
if (mas[a] == 0) {
sum += 1 + 2 * k - max(0, (a + k - b + 1)) - max(0, 1 - a + k);
cout << sum << " ";
} else
fun(mas[a], a - k,
sum += 1 + 2 * k - max(0, (a + k - b + 1)) - max(0, 1 - a + k));
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> mas[i];
for (int i = 1; i <= n; i++) {
fun(i, n + 1, 0);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, s = 0;
scanf("%d", &n);
scanf("%d%d", &a, &b);
n -= 2;
while (n--) {
scanf("%d", &c);
if (a + c == 2 && !b) {
c = 0;
s++;
}
a = b;
b = c;
}
printf("%d", s);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1e6 + 3;
long long n, k, tot;
int mol, den, tmp;
long long mul(long long x, long long y) {
long long ret = 1;
x %= mo;
while (y) {
if (y % 2) ret = 1LL * ret * x % mo;
y /= 2;
x = 1LL * x * x % mo;
}
return ret;
}
int main() {
scanf("%I64d%I64d", &n, &k);
if (n < 63) {
long long a = 1;
for (int i = 1; i <= n; i++) a *= 2;
if (a < k) {
printf("1 1\n");
return 0;
}
}
long long kk = k - 1;
tot = n;
while (kk > 1) tot += (kk /= 2);
mol = den = mul(2, (1LL * (n % (mo - 1)) * (k % (mo - 1)) % (mo - 1) -
tot % (mo - 1) + mo - 1) %
(mo - 1));
int l = (mul(2, n % (mo - 1)) - k + 1 + mo) % mo;
tmp = 1;
for (long long i = 1; i <= k; i++) {
tmp = 1LL * tmp * l % mo;
if (!tmp) break;
l = (l + 1) % mo;
}
tmp = 1LL * tmp * mul(mul(2, tot % (mo - 1)), mo - 2) % mo;
mol = (mol - tmp + mo) % mo;
printf("%d %d\n", mol, den);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 * 1000 + 10;
int n, a[N], ans;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
ans = n;
int minn = INT_MAX;
for (int i = n - 1; i >= 0; i--) {
if (i >= minn) ans--;
minn = min(minn, i - a[i]);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int n, rt, s[MAXN], num[MAXN];
int main() {
scanf("%d%d", &n, &rt);
int ans = 0, r = n;
for (int i = 1; i <= n; i++) {
scanf("%d", &s[i]);
if (i == rt && s[i] != 0) ans++, s[i] = 0;
num[s[i]]++;
}
sort(s + 1, s + n + 1);
for (int i = 0; i <= n; i++) {
if (!num[i]) {
if (i >= s[r]) break;
if (num[0] > 1)
num[0]--;
else
r--;
ans++;
}
}
ans += num[0] - 1;
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
short nums[100005] = {0};
vector<int> c;
int temp;
bool ok = true;
for (int i = 0; i < n; i++) {
temp = (i + ((i + 1) % n)) % n;
if (nums[temp] == 0 && temp < n) {
c.push_back(temp);
nums[temp] = 1;
} else {
ok = false;
break;
}
}
if (ok) {
for (int i = 0; i < n; i++) {
if (i) cout << " ";
cout << i;
}
cout << "\n";
for (int i = 0; i < n; i++) {
if (i) cout << " ";
cout << (i + 1) % n;
}
cout << "\n";
for (int i = 0; i < n; i++) {
if (i) cout << " ";
cout << c[i];
}
cout << "\n";
} else {
cout << "-1";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct pr {
int x, y, w;
} a[200001];
int now[200001], fa[200001];
bool vis[200001];
bool cmp(pr xx, pr yy) { return xx.w > yy.w; }
int findfa(int x) { return fa[x] == x ? x : fa[x] = findfa(fa[x]); }
int main() {
int n, m;
cin >> n >> m;
for (register int i = 1; i <= m; i++) cin >> a[i].x >> a[i].y >> a[i].w;
sort(a + 1, a + m + 1, cmp);
for (register int i = 1; i <= n; i++) fa[i] = i;
int ans = 0;
for (register int i = 1; i <= m; i++) {
int x = findfa(a[i].x), y = findfa(a[i].y);
if (vis[x] && vis[y])
continue;
else if (vis[x])
vis[y] = true, ans += a[i].w;
else if (vis[y])
vis[x] = true, ans += a[i].w;
else if (x == y)
vis[x] = true, ans += a[i].w;
else
ans += a[i].w, fa[y] = x;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long sum = 0, i = 0, num = 0;
bool kop = false;
while (i < s.length()) {
while (((s[i] >= '0' && s[i] <= '9') || s[i] == '.') && i < s.length()) {
if (s[i] == '.' &&
!((s[i + 3] <= '9' && s[i + 3] >= '0') || s[i + 3] == '.')) {
kop = true;
} else if (s[i] != '.')
num = num * 10 + (s[i] - '0');
i++;
}
if (!kop) num *= 100;
sum += num;
if (s[i] >= 'a' && s[i] <= 'z') {
num = 0;
kop = false;
}
i++;
}
string ans = to_string(sum);
if (sum < 10)
ans = "00" + ans;
else if (sum < 100)
ans = '0' + ans;
for (int i = ans.length() - 2; i > 0; i -= 3)
ans = ans.substr(0, i) + '.' + ans.substr(i);
if (ans.substr(ans.length() - 2) == "00")
ans = ans.substr(0, ans.length() - 3);
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 50010;
int B[MXN], rk[MXN], w[MXN * 2], n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", B + i);
B[n] = B[0];
for (int i = 0; i < n; i++) w[B[i] + B[i + 1]]++;
for (int i = 0; i < n + n; i++) w[i + 1] += w[i];
for (int i = n - 1; i >= 0; i--) rk[i] = --w[B[i] + B[i + 1]];
for (int i = 0; i < n; i++) printf("%d%c", rk[i], i < n - 1 ? ' ' : '\n');
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
long long readint() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, tot, rt;
long long k, mina, maxa;
int v[200005], nxt[200005], h[100005], dep[100005], f[100005], siz[100005],
son[100005];
bool leaf[100005], vis[100005];
vector<int> vec[100005];
set<pair<int, int> > pt[100005], s;
vector<pair<int, int> > ans;
void addedge(int x, int y) {
v[++tot] = y;
nxt[tot] = h[x];
h[x] = tot;
v[++tot] = x;
nxt[tot] = h[y];
h[y] = tot;
}
void dfs1(int u, int fa) {
siz[u] = 1;
int mx = 0;
for (int p = h[u]; p; p = nxt[p]) {
if (v[p] == fa) continue;
dfs1(v[p], u);
siz[u] += siz[v[p]];
chkmax(mx, siz[v[p]]);
}
if (max(mx, n - siz[u]) <= n / 2) rt = u;
}
void dfs2(int u, int fa, int t) {
siz[u] = 1;
for (int p = h[u]; p; p = nxt[p]) {
if (v[p] == fa) continue;
f[v[p]] = u, dep[v[p]] = dep[u] + 1;
dfs2(v[p], u, t < 0 ? v[p] : t);
siz[u] += siz[v[p]], son[u]++;
if (leaf[v[p]]) vec[u].push_back(v[p]);
mina += siz[v[p]] & 1;
maxa += siz[v[p]];
}
if (son[u] == 0) leaf[u] = 1;
if (t >= 0 && son[u] > 0) pt[t].insert(make_pair(dep[u], u));
}
void dfs3(int u, int fa, int t) {
for (int p = h[u]; p; p = nxt[p]) {
if (v[p] == fa) continue;
dfs3(v[p], u, t < 0 ? v[p] : t);
}
if (t >= 0 && !vis[u]) pt[t].insert(make_pair(u, 0));
}
int main() {
n = readint();
k = readint();
for (int i = 1; i < n; i++) addedge(readint(), readint());
dfs1(1, -1);
dfs2(rt, -1, -1);
if (k % 2 != mina % 2 || k < mina || k > maxa) return printf("NO\n"), 0;
printf("YES\n");
for (int p = h[rt]; p; p = nxt[p]) s.insert(make_pair(siz[v[p]], v[p]));
long long rem = (maxa - k) / 2;
while (rem) {
auto it = --s.end();
pair<int, int> tmp = *it;
s.erase(it);
if (tmp.first - 2 > 0) s.insert(make_pair(tmp.first - 2, tmp.second));
auto pl = pt[tmp.second].lower_bound(make_pair(rem, 0));
if (pl == pt[tmp.second].end()) pl--;
int u = pl->second;
rem -= dep[u];
if (vec[u].size() >= 2) {
ans.push_back(
make_pair(vec[u][vec[u].size() - 1], vec[u][vec[u].size() - 2]));
vis[vec[u][vec[u].size() - 1]] = vis[vec[u][vec[u].size() - 2]] = 1;
vec[u].pop_back(), vec[u].pop_back();
son[u] -= 2;
if (son[u] == 0) {
pt[tmp.second].erase(make_pair(dep[u], u));
if (f[u] != rt) vec[f[u]].push_back(u);
}
} else if (vec[u].size() == 1) {
ans.push_back(make_pair(vec[u][0], u));
vis[vec[u][0]] = vis[u] = 1;
pt[tmp.second].erase(make_pair(dep[u], u));
if (f[u] != rt) {
son[f[u]]--;
if (son[f[u]] == 0) {
pt[tmp.second].erase(make_pair(dep[f[u]], f[u]));
if (f[f[u]] != rt) vec[f[f[u]]].push_back(f[u]);
}
}
} else {
assert(rem == 0);
for (int p = h[u]; p; p = nxt[p]) {
if (!vis[v[p]] && v[p] != f[u]) {
vis[v[p]] = vis[u] = 1;
ans.push_back(make_pair(u, v[p]));
break;
}
}
}
}
for (int p = h[rt]; p; p = nxt[p]) pt[v[p]].clear();
dfs3(rt, -1, -1);
s.clear();
for (int p = h[rt]; p; p = nxt[p])
if (pt[v[p]].size()) s.insert(make_pair(pt[v[p]].size(), v[p]));
while (1) {
if (s.size() == 1) {
assert(pt[s.begin()->second].size() == 1);
ans.push_back(make_pair(pt[s.begin()->second].begin()->first, rt));
break;
}
auto it1 = --s.end(), it2 = it1;
it2--;
ans.push_back(make_pair(pt[it1->second].begin()->first,
pt[it2->second].begin()->first));
pt[it1->second].erase(pt[it1->second].begin());
pt[it2->second].erase(pt[it2->second].begin());
if (it1->first > 1) s.insert(make_pair(it1->first - 1, it1->second));
if (it2->first > 1) s.insert(make_pair(it2->first - 1, it2->second));
s.erase(it1), s.erase(it2);
}
for (auto r : ans) printf("%d %d\n", r.first, r.second);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int num[100000][2];
cin.sync_with_stdio(0);
int n, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[i][0] >> num[i][1];
}
for (int i = 1; i < n; i++) {
if (num[i - 1][1] < num[i][1]) num[i][1] = num[i - 1][1];
}
for (int i = 0; i < n; i++) sum += (num[i][0] * num[i][1]);
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxV = 3000 + 10, MaxE = 30000 + 10;
int head[MaxV], nxt[MaxE], to[MaxE], top, n, m, tot[MaxV];
long long ans;
void addedge(int fr, int tt) {
top++;
nxt[top] = head[fr];
to[top] = tt;
head[fr] = top;
}
void init() {
int tpa, tpb;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &tpa, &tpb);
addedge(tpa, tpb);
}
}
int main() {
scanf("%d%d", &n, &m);
init();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) tot[j] = 0;
for (int j = head[i]; j; j = nxt[j])
for (int k = head[to[j]]; k; k = nxt[k])
if (to[k] != i) tot[to[k]]++;
for (int j = 1; j <= n; j++)
ans += ((long long)tot[j] * (long long)(tot[j] - 1)) / 2ll;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char *student;
int *arr;
struct node {
int x;
int y;
int val;
};
std::vector<node> v;
std::vector<node> out;
struct edge {
int v;
edge *left;
edge *right;
};
edge *ed;
bool *flag;
bool comp(node &a, node &b) {
return (!(a.val < b.val || (a.val == b.val && a.x < b.x)));
}
void make_node(int x, int y) {
if (student[x] ^ student[y]) {
node temp;
temp.x = x;
temp.y = y;
temp.val = abs(arr[x] - arr[y]);
v.push_back(temp);
push_heap(v.begin(), v.end(), comp);
}
}
void print() {
for (std::vector<node>::iterator it = out.begin(); it != out.end(); ++it) {
node temp = *it;
cout << temp.x + 1 << " " << temp.y + 1 << endl;
}
}
void select() {
while (true) {
int l = -1, r = -1;
while (v.size() > 0) {
node temp = v.front();
pop_heap(v.begin(), v.end(), comp);
v.pop_back();
l = temp.x;
r = temp.y;
if (flag[l] || flag[r]) {
l = -1;
r = -1;
continue;
} else {
flag[l] = true;
flag[r] = true;
out.push_back(temp);
break;
}
}
if (l == -1) break;
edge *lt = ed[l].left;
edge *rt = ed[r].right;
if (lt != NULL) {
lt->right = rt;
}
if (rt != NULL) {
rt->left = lt;
}
if (lt != NULL && rt != NULL) make_node(lt->v, rt->v);
}
}
int main() {
std::cout << std::fixed << std::setprecision(10);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
student = new char[n];
arr = new int[n];
flag = new bool[n];
string s;
cin >> s;
for (int i = 0; i < n; i++) {
student[i] = s[i];
int x;
cin >> x;
arr[i] = x;
flag[i] = false;
}
for (int i = 0; i < n - 1; i++) {
make_node(i, i + 1);
}
ed = new edge[n];
for (int i = 0; i < n; i++) {
ed[i].v = i;
ed[i].left = i > 0 ? &ed[i - 1] : NULL;
ed[i].right = i < n - 1 ? &ed[i + 1] : NULL;
}
select();
cout << out.size() << endl;
print();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct vec {
long long l;
long long x;
long long y;
int in;
};
bool cmp(vec a, vec b) { return a.x * a.x < b.x * b.x; }
int main() {
vector<vec> v(100000);
int ans[100000];
long long n, xt = 0, yt = 0;
cin >> n;
for (int i(0); i < n; i++) {
cin >> v[i].x >> v[i].y;
v[i].in = i;
v[i].l = v[i].x * v[i].x + v[i].y * v[i].y;
}
sort(v.begin(), v.begin() + n, cmp);
for (int i(n - 1); i >= 0; i--) {
if ((xt + v[i].x) * (xt + v[i].x) + (yt + v[i].y) * (yt + v[i].y) <
(xt - v[i].x) * (xt - v[i].x) + (yt - v[i].y) * (yt - v[i].y)) {
ans[v[i].in] = 1;
xt += v[i].x;
yt += v[i].y;
} else {
ans[v[i].in] = -1;
xt -= v[i].x;
yt -= v[i].y;
}
}
for (int i(0); i < n; i++) cout << ans[i] << ' ';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a, b;
long long y[100005];
long long y2[100005], l[100006];
void Readinput() {
scanf("%I64d", &n);
scanf("%I64d", &m);
scanf("%I64d", &a);
scanf("%I64d", &b);
for (int i = 0; i < n; i++) scanf("%I64d", &y[i]);
for (int i = 0; i < m; i++) scanf("%I64d", &y2[i]);
for (int i = 0; i < m; i++) scanf("%I64d", &l[i]);
sort(y, y + n);
sort(y2, y2 + m);
}
int bin_search(int v, int l, int r) {
if (l >= r) return r;
int mid = int(floor((l + r) / 2.0));
if (y[mid] <= v)
return bin_search(v, mid + 1, r);
else
return bin_search(v, l, mid);
}
void solve() {
double c = 0;
double ans = 1000000007;
int s1, s2;
for (int i = 0; i < m; i++) {
c = (a * y2[i]) / (double)(b);
int k = bin_search(c, 0, n - 1);
double d1, d2 = 1000000007;
d1 = sqrt(a * a + y[k] * y[k]) +
sqrt(pow(b - a, 2) + pow(y2[i] - y[k], 2)) + l[i];
if (k != 0)
d2 = sqrt(a * a + y[k - 1] * y[k - 1]) +
sqrt(pow(b - a, 2) + pow(y2[i] - y[k - 1], 2)) + l[i];
if (i == 0 || d1 < ans) {
ans = d1;
s1 = k;
s2 = i;
}
if (k != 0 && d2 < ans) {
ans = d2;
s1 = k - 1;
s2 = i;
}
}
printf("%d %d\n", s1 + 1, s2 + 1);
}
int main() {
Readinput();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return (a * (b / gcd(a, b))); }
const int N = 1000001;
int f[2 * N], n;
string a, b, s;
void kmp() {
for (int i = 1, k = 0; i < s.length(); ++i) {
while (k > 0 && s[k] != s[i]) k = f[k - 1];
if (s[k] == s[i])
f[i] = ++k;
else
f[i] = k;
}
}
char op(char c) {
if (c == 'S') return 'N';
if (c == 'N') return 'S';
if (c == 'W') return 'E';
if (c == 'E') return 'W';
}
void solution() {
cin >> n;
n--;
cin >> a >> b;
reverse((a).begin(), (a).end());
for (int i = 0; i < int(n); i++) a[i] = op(a[i]);
s = a + "@" + b;
kmp();
if (f[2 * n] != 0)
cout << "NO";
else
cout << "YES";
}
int main() {
double beg = clock();
ios::sync_with_stdio(false);
solution();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool test(string& s, int r) {
int x = 0, y = s.size() - 1;
bool ok = false;
while (x <= y) {
if (s[(x + r) % s.size()] != s[x]) ok = 1;
if (s[(x + r) % s.size()] != s[(y + r) % s.size()]) return false;
++x;
--y;
}
return ok;
}
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
int c = 0;
for (int i = 1; i < s.size(); ++i) {
if (s[i] != s[0]) ++c;
}
if (c < 2) {
cout << "Impossible";
return 0;
}
int i = 1;
while (i <= s.size() / 2) {
if (test(s, i)) {
cout << 1;
return 0;
}
++i;
}
cout << 2;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
double x, y;
Point(double ix = 0, double iy = 0) {
x = ix;
y = iy;
}
};
inline Point operator+(Point a, Point b) { return Point(a.x + b.x, a.y + b.y); }
inline Point operator-(Point a, Point b) { return Point(a.x - b.x, a.y - b.y); }
inline double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
inline double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
const int N = 100004;
const double EPS = 1e-9;
const double PI = acos(-1.0);
double area[N];
int n, q, nxt[N];
Point center, p[N];
inline double getArea(Point a, Point b) {
return (b.x - a.x) * (a.y + b.y) / 2;
}
inline double getAreaRange(int l, int r) {
if (l == r) return 0.0;
if (l > r) r += n;
if (l == 0) return area[r - 1];
return area[r - 1] - area[l - 1];
}
inline bool getIntersection(Point a, Point b, Point dir, double &s, double &t) {
double a11 = b.x - a.x;
double a21 = b.y - a.y;
double a12 = -dir.x;
double a22 = -dir.y;
double det = a11 * a22 - a12 * a21;
if (abs(det) < EPS) return false;
s = ((center.x - a.x) * a22 - (center.y - a.y) * a12) / det;
t = ((center.y - a.y) * a11 - (center.x - a.x) * a21) / det;
return true;
}
inline void getPolygonRayIntersection(Point dir, int &ind, Point &u) {
double s, t, ss, tt;
bool flg = getIntersection(p[0], p[1], dir, s, t);
int lo = 0, hi = n - 1;
if (flg) {
if (s < 0 && t > 0) {
while (lo < hi) {
int mi = (lo + hi + 1) / 2;
bool tmp = getIntersection(p[mi], p[nxt[mi]], dir, ss, tt);
if (tmp) {
if (ss > 0 && tt < 0) {
lo = mi;
} else if (ss < 0 && tt < 0) {
lo = mi;
} else if (ss > 0 && tt > 0) {
lo = mi;
} else {
if (t < tt) {
lo = mi;
} else {
hi = mi - 1;
}
}
} else {
lo = mi;
}
}
} else if (s > 0 && t < 0) {
while (lo < hi) {
int mi = (lo + hi + 1) / 2;
bool tmp = getIntersection(p[mi], p[nxt[mi]], dir, ss, tt);
if (tmp) {
if (ss < 0 && tt < 0) {
lo = mi;
} else if (ss > 0 && tt > 0) {
lo = mi;
} else if (ss < 0 && tt > 0) {
hi = mi - 1;
} else {
if (t < tt) {
lo = mi;
} else {
hi = mi - 1;
}
}
} else {
if (dot(p[nxt[mi]] - p[mi], dir) > 0) {
lo = mi;
} else {
hi = mi - 1;
}
}
}
} else if (s < 0 && t < 0) {
while (lo < hi) {
int mi = (lo + hi + 1) / 2;
bool tmp = getIntersection(p[mi], p[nxt[mi]], dir, ss, tt);
if (tmp) {
if (ss > 0 && tt > 0) {
lo = mi;
} else if (ss < 0 && tt > 0) {
hi = mi - 1;
} else if (ss > 0 && tt < 0) {
hi = mi - 1;
} else {
if (t < tt) {
hi = mi - 1;
} else {
lo = mi;
}
}
} else {
if (dot(p[nxt[mi]] - p[mi], dir) > 0) {
lo = mi;
} else {
hi = mi - 1;
}
}
}
} else {
while (lo < hi) {
int mi = (lo + hi + 1) / 2;
bool tmp = getIntersection(p[mi], p[nxt[mi]], dir, ss, tt);
if (tmp) {
if (ss < 0 && tt > 0) {
hi = mi - 1;
} else if (ss > 0 && tt < 0) {
hi = mi - 1;
} else if (ss < 0 && tt < 0) {
hi = mi - 1;
} else {
if (t < tt) {
hi = mi - 1;
} else {
lo = mi;
}
}
} else {
hi = mi - 1;
}
}
}
} else if (dot(p[1] - p[0], dir) > 0) {
while (lo < hi) {
int mi = (lo + hi + 1) / 2;
bool tmp = getIntersection(p[mi], p[nxt[mi]], dir, ss, tt);
if (tmp) {
if (ss > 0 && tt > 0) {
lo = mi;
} else {
hi = mi - 1;
}
} else {
hi = mi - 1;
}
}
} else {
while (lo < hi) {
int mi = (lo + hi + 1) / 2;
bool tmp = getIntersection(p[mi], p[nxt[mi]], dir, ss, tt);
if (tmp) {
if (ss < 0 && tt > 0) {
hi = mi - 1;
} else {
lo = mi;
}
} else {
lo = mi;
}
}
}
ind = lo;
getIntersection(p[lo], p[nxt[lo]], dir, s, t);
u.x = center.x + dir.x * t;
u.y = center.y + dir.y * t;
}
inline double getAreaDiff(double ang) {
Point u, v;
int up, dw;
double cosang = cos(ang);
double sinang = sin(ang);
Point dir(cosang, sinang);
getPolygonRayIntersection(dir, up, u);
dir.x = -cosang;
dir.y = -sinang;
getPolygonRayIntersection(dir, dw, v);
double ret = getAreaRange(nxt[up], dw) + getArea(p[dw], v) + getArea(v, u) +
getArea(u, p[nxt[up]]);
ret = ret * 2 - area[n - 1];
return ret;
}
inline double query(double x, double y) {
double lo = 0, hi = PI;
center.x = x;
center.y = y;
double areadiffref = getAreaDiff(lo);
if (abs(areadiffref) < EPS) return lo;
for (int it = 0; it < 40; it++) {
double mi = (lo + hi) / 2;
double areadiffmi = getAreaDiff(mi);
if (abs(areadiffmi) < EPS) return mi;
if (areadiffref > 0) {
if (areadiffmi > 0) {
lo = mi;
} else {
hi = mi;
}
} else {
if (areadiffmi < 0) {
lo = mi;
} else {
hi = mi;
}
}
}
return lo;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> p[i].x >> p[i].y;
nxt[i] = (i + 1) % n;
}
reverse(p, p + n);
for (int i = 0; i < 2 * n; i++) {
area[i] = getArea(p[i % n], p[(i + 1) % n]);
if (i) area[i] += area[i - 1];
}
cout << setprecision(30);
while (q--) {
double x, y;
cin >> x >> y;
cout << query(x, y) << '\n';
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long fact[200001];
long long mod = 998244353;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
map<long long, long long> mp;
long long arr[n];
long long a, b;
for (long long i = 0; i < n; i++) {
cin >> arr[i];
a = arr[i] % k;
if (a != 0) mp[a]++;
}
long long ans = 0;
for (auto it = mp.begin(); it != mp.end(); it++) {
a = (*it).first, b = (*it).second;
b--;
b = b * k;
a = b + k - a;
ans = max(a, ans);
}
if (ans == 0)
cout << ans;
else
cout << ans + 1;
cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 15, oo = 1 << 30;
int N, a, b, Ans;
int H[maxn], G[maxn], F[maxn];
int calc(int h, int b) {
if (h <= 0) return 0;
return h / b + (h % b != 0);
}
void Done1() {
memcpy(G, H, sizeof(H));
for (int i = (2), _i = (N - 1); i <= _i; i++) {
F[i] = calc(H[i - 1], b);
H[i - 1] -= F[i] * b;
H[i] -= F[i] * a;
H[i + 1] -= F[i] * b;
}
F[N - 1] += calc(H[N], b);
Ans = 0;
for (int i = (2), _i = (N - 1); i <= _i; i++) Ans += F[i];
memcpy(H, G, sizeof(G));
memcpy(G, F, sizeof(F));
}
void change(int i, int g) {
H[i] -= g * a;
H[i - 1] -= g * b;
H[i + 1] -= g * b;
F[i] += g;
}
void Prepare() {
change(2, calc(H[1], b));
change(N - 1, calc(H[N], b));
}
bool check_no(int i, int ret) {
int sum = 0;
for (int j = (1), _j = (N); j <= _j; j++)
if (H[j] > 0) sum += H[j];
ret += calc(sum, a);
return ret >= Ans;
}
void dfs(int i, int ret) {
if (i == N) {
if (ret < Ans) {
Ans = ret;
memcpy(G, F, sizeof(F));
}
return;
}
int lo = calc(H[i - 1], b);
int hi = max(lo, calc(H[i], a));
for (int g = (lo), _g = (hi); g <= _g; g++) {
change(i, g);
dfs(i + 1, ret + g);
change(i, -g);
}
}
int main() {
for (; scanf("%d%d%d", &N, &a, &b) != EOF;) {
for (int i = (1), _i = (N); i <= _i; i++) scanf("%d", &H[i]);
for (int i = (1), _i = (N); i <= _i; i++) H[i]++;
Done1();
for (int i = (2), _i = (N - 1); i <= _i; i++) F[i] = 0;
Prepare();
dfs(2, F[2] + (N > 3 ? F[N - 1] : 0));
printf("%d\n", Ans);
for (int i = (1), _i = (N); i <= _i; i++) {
while (G[i]--) printf("%d ", i);
}
printf("\n");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<int, int> mp;
int cnt[200005];
int a[200005];
int num[200005];
int l, r, t;
int tot = 0;
int lz[200005];
int ans[200005];
int A, B;
int be[200005];
struct Query {
int l, r, id, t;
Query() {}
Query(int _l, int _r, int _id, int _t) { l = _l, r = _r, id = _id, t = _t; }
bool operator<(const Query &rhs) const {
return be[l] == be[rhs.l] ? (be[r] == be[rhs.r] ? t < rhs.t : r < rhs.r)
: l < rhs.l;
}
} q[200005];
struct Change {
int x, y, lz;
Change() {}
Change(int _x, int _y, int _lz) { x = _x, y = _y, lz = _lz; }
} p[200005];
int getid(int x) {
if (!mp.count(x)) mp[x] = ++tot;
return mp[x];
}
void add(int x, int k) {
if (num[x]) cnt[num[x]]--;
num[x] += k;
if (num[x]) cnt[num[x]]++;
}
void change(int x, int k) {
if (l <= x && r >= x) {
add(a[x], -1);
add(k, 1);
}
a[x] = k;
}
int getres() {
for (int i = 1;; i++) {
if (cnt[i] == 0) return i;
}
}
int main() {
int n, m;
cin >> n >> m;
int len = pow(n, 0.6666);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
lz[i] = a[i] = getid(x);
be[i] = (i - 1) / len + 1;
}
for (int i = 1; i <= m; i++) {
int op, x, y;
scanf("%d%d%d", &op, &x, &y);
if (op == 1) {
q[++A] = Query(x, y, A, B);
} else {
y = getid(y);
p[++B] = Change(x, y, lz[x]);
lz[x] = y;
}
}
sort(q + 1, q + 1 + A);
l = 1, r = 0, t = 0;
for (int i = 1; i <= A; i++) {
while (t < q[i].t) change(p[t + 1].x, p[t + 1].y), t++;
while (t > q[i].t) change(p[t].x, p[t].lz), t--;
while (l < q[i].l) add(a[l], -1), l++;
while (l > q[i].l) add(a[l - 1], 1), l--;
while (r < q[i].r) add(a[r + 1], 1), r++;
while (r > q[i].r) add(a[r], -1), r--;
ans[q[i].id] = getres();
}
for (int i = 1; i <= A; i++) {
printf("%d\n", ans[i]);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long nChooseR(int n, int k);
long long gcd(long long a, long long b);
void strCountsort(string& arr);
void intCountSort(vector<int>& arr);
vector<string> split(string target, char c);
bool isPrime(long long g);
long long n, k, r, l, t, x, y, m, a[100005];
long long ans;
int main() {
string s, h;
cin >> n;
for (int i = 0; i < (int)(n); i++) scanf("%lld", a + i);
sort(a, a + n, greater<long long>());
vector<long long> v;
for (int i = 0; i < (int)(n - 1); i++) {
if (a[i] - a[i + 1] <= 1) {
v.push_back(a[i + 1]);
i++;
}
}
for (int i = 0; i < (int)(((int)((v).size())) - 1); i++) {
ans += v[i] * v[i + 1];
i++;
}
cout << ans;
return 0;
}
long long nChooseR(int n, int k) {
if (k > n) return 0;
if (k * 2 > n) k = n - k;
if (k == 0) return 1;
long long result = n;
for (int i = 2; i <= k; ++i) {
result *= (n - i + 1);
result /= i;
}
return result;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
void strCountsort(string& arr) {
string output = arr;
int max = *max_element(arr.begin(), arr.end());
int min = *min_element(arr.begin(), arr.end());
int range = max - min + 1;
vector<int> count(range);
int n = arr.size();
for (int i = 0; i < n; i++) count[arr[i] - min]++;
n = count.size();
for (int i = 1; i < n; i++) count[i] += count[i - 1];
n = arr.size();
for (int i = n - 1; i >= 0; i--) {
output[--count[arr[i] - min]] = arr[i];
}
arr = output;
}
void intCountSort(vector<int>& arr) {
int max = *max_element(arr.begin(), arr.end());
int min = *min_element(arr.begin(), arr.end());
int range = max - min + 1;
vector<int> count(range), output(arr.size());
int n = arr.size();
for (int i = 0; i < n; i++) count[arr[i] - min]++;
n = count.size();
for (int i = 1; i < n; i++) count[i] += count[i - 1];
n = arr.size();
for (int i = n - 1; i >= 0; i--) {
output[--count[arr[i] - min]] = arr[i];
}
for (int i = 0; i < n; i++) arr[i] = output[i];
}
vector<string> split(string target, char c) {
string d = "";
vector<string> arr;
for (auto n : target) {
if (n != c)
d += n;
else if (d != "")
arr.push_back(d), d = "";
}
if (d != "") arr.push_back(d), d = "";
return arr;
}
bool isPrime(long long g) {
if ((g % 2 == 0 && g > 2) || g == 1) return 0;
for (int i = 3; i * i <= g; i += 2)
if (g % i == 0) return 0;
return 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 140590;
const int maxnum = 187126;
long long data1[maxn];
long long ans[maxn];
long long sum[maxn];
int n;
int main() {
scanf("%d", &n);
long long ma = -1, mapl = -1;
bool issame = true;
for (int i = 0; i < n; i++) {
scanf("%lld", &data1[i]);
}
for (int i = 0; i < n; i++) {
if (data1[i] > ma && data1[i] > data1[(i - 1 + n) % n]) {
ma = data1[i];
mapl = i;
}
}
for (int i = 0; i < n - 1; i++) {
if (data1[i] != data1[i + 1]) issame = false;
}
if (issame) {
if (data1[1] != 0) {
puts("NO");
} else {
puts("YES");
for (int i = 1; i <= n; i++) {
printf("1 ");
}
}
return 0;
}
puts("YES");
ans[mapl] = data1[mapl];
for (int i = mapl - 1; i >= 0; i--) {
ans[i] = ans[i + 1] + data1[i];
}
for (int i = n - 1; i >= mapl + 1; i--) {
ans[i] = ans[(i + 1 + n) % n] + data1[i];
}
long long base = ma * 10;
for (int i = 0; i < n; i++) {
if (i == mapl) continue;
ans[i] += base;
}
for (int i = 0; i < n; i++) {
printf("%lld ", ans[i]);
}
}
| 8 |
#include <bits/stdc++.h>
const double eps = 1e-8;
const long long mod = 1e9 + 7;
const long long maxn = 1e5 + 7;
const double pi = acos(-1);
const long long inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
using namespace std;
int n, k, cnt;
string name[maxn];
int a[maxn], ans[maxn];
int len = 0;
void init() {
int cnt = 0;
name[cnt] = "Accc";
for (int i = int('a'); i <= int('z'); i++) {
name[++cnt] = "A";
name[cnt] += char(i);
}
for (int i = int('a'); i <= int('z'); i++) {
name[++cnt] = "B";
name[cnt] += char(i);
}
for (int i = int('a'); i <= int('z'); i++) {
name[++cnt] = "C";
name[cnt] += char(i);
}
}
int main(int argc, char const *argv[]) {
init();
scanf("%d %d", &n, &k);
for (int i = 1; i <= n - k + 1; ++i) {
string t;
cin >> t;
if (t == "NO")
a[i] = 0;
else
a[i] = 1;
}
for (int i = 1; i <= k - 1; i++) {
ans[i] = i;
}
cnt = k - 1;
for (int i = 1; i <= n; i++) {
if (a[i] == 1) {
ans[i + k - 1] = ++cnt;
} else {
ans[i + k - 1] = ans[i];
}
}
for (int i = 1; i <= n; i++) {
cout << name[ans[i]] << ' ';
}
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int inf = 0x3f3f3f3f;
struct Zzz {
int num, id;
bool operator<(const Zzz& rhs) const { return num < rhs.num; }
} ar[maxn];
int n, h, ans[maxn];
int main() {
scanf("%d %d", &n, &h);
for (int i = 0; i < n; ++i) {
scanf("%d", &ar[i].num);
ar[i].id = i;
}
sort(ar, ar + n);
int result = inf, index = -1;
for (int i = 0; i < n; ++i) {
if (i == 0) {
int maxv = ar[n - 1].num + ar[n - 2].num;
int minv = ar[0].num + ar[1].num;
int curv = maxv - minv;
if (curv < result) {
result = curv;
index = i;
}
} else if (i == 1) {
int maxv = ar[0].num + ar[n - 1].num + h;
if (i <= n - 2) maxv = max(maxv, ar[n - 1].num + ar[n - 2].num);
int minv = ar[0].num + ar[1].num + h;
if (n > 2) minv = min(minv, ar[1].num + ar[2].num);
int curv = maxv - minv;
if (curv < result) {
result = curv;
index = i;
}
} else if (i == n - 1) {
int maxv = ar[n - 2].num + ar[n - 1].num + h;
int minv = ar[0].num + ar[n - 1].num + h;
if (i > 2) minv = min(minv, ar[0].num + ar[1].num);
int curv = maxv - minv;
if (curv < result) {
result = curv;
index = i;
}
} else {
int maxv = ar[i - 1].num + ar[n - 1].num + h;
maxv = max(maxv, ar[n - 1].num + ar[n - 2].num);
int minv = ar[0].num + ar[1].num;
int curv = maxv - minv;
if (curv < result) {
result = curv;
index = i;
}
}
}
for (int i = 0; i < index; ++i) {
ans[ar[i].id] = 1;
}
for (int i = index; i < n; ++i) {
ans[ar[i].id] = 2;
}
printf("%d\n", result);
for (int i = 0; i < n; ++i) {
if (i) putchar(' ');
printf("%d", ans[i]);
}
puts("");
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.