solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long N, Q;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cin >> N >> Q;
vector<pair<long long, long long> > flips;
long long spaces = N - 1;
long long lvl = 0;
while (spaces > 0) {
long long flip = 1ll << lvl;
lvl++;
long long end = N + spaces;
long long begin = end - flip;
flips.push_back({begin, end});
spaces -= flip;
}
reverse((flips).begin(), (flips).end());
while (Q--) {
long long x;
cin >> x;
for (pair<long long, long long> p : flips) {
if (x <= p.first && (p.first - x) % 2 == 0) {
x = p.second - (p.first - x) / 2;
} else {
}
}
cout << (x + 1) / 2 << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long int>;
using vvi = vector<vi>;
using vb = vector<bool>;
using vc = vector<char>;
using vs = vector<string>;
using vld = vector<long double>;
using pii = pair<long long int, long long int>;
using psi = pair<string, long long int>;
using pci = pair<char, long long int>;
using vpii = vector<pii>;
long long int const mod = 1e9 + 7;
long long int const maxn = 1e5 + 5;
long long int const inf = 1e18;
long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
long long int mul(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
long long int powm(long long int x, long long int n, long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long int modinverse(long long int a, long long int m) {
return powm(a, m - 2, m);
}
bool prime(long long int x) {
if (x <= 1) return false;
for (int i = 2; i <= sqrt(x); i++)
if (x % i == 0) return false;
return true;
}
long long int divisor(long long int x) {
long long int cnt = 0;
for (int i = 1; i <= sqrt(x); i++) {
if (x % i == 0) {
if (i != x / i)
cnt += 2;
else
cnt += 1;
}
}
return cnt;
}
vector<long long int> sieve(long long int n) {
bool prim[n + 1];
memset(prim, true, sizeof(prim));
for (long long int p = 2; p * p <= n; p++) {
if (prim[p] == true) {
for (int i = p * p; i <= n; i += p) prim[i] = false;
}
}
vector<long long int> v;
for (int i = 2; i <= n; i++)
if (prim[i]) v.push_back(i);
return v;
}
vector<long long int> z_algo(vi s) {
long long int n = s.size();
vector<long long int> z(n);
for (long long int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n and s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
return z;
}
void fun(vi &v) {
vi a;
for (int i = 1; i < (long long int)v.size(); i++) {
a.push_back(v[i] - v[i - 1]);
}
v = a;
}
void solve() {
long long int n, m;
cin >> n >> m;
vi v1(n);
vi v2(m);
for (int i = 0; i < n; i++) cin >> v1[i];
for (int i = 0; i < n; i++) cin >> v2[i];
if (m == 1) {
cout << n;
return;
}
fun(v1);
fun(v2);
v2.insert(v2.end(), v1.begin(), v1.end());
vi v = z_algo(v2);
long long int ans = 0;
for (int i = m - 1; i < (long long int)v.size(); i++) {
if (v[i] >= m - 1) ans++;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, lenl, lenr, leno;
string s, o, l = "", r = "";
cin >> s;
for (x = 0; s[x] != '|'; x++) l += s[x];
x++;
for (x; s[x]; x++) r += s[x];
cin >> o;
leno = o.size();
lenl = l.size();
lenr = r.size();
if (lenl == lenr) {
if (leno & 1)
cout << "Impossible\n";
else {
for (int i = 0; o[i]; i++) {
if (i & 1)
r += o[i];
else
l += o[i];
}
cout << l << "|" << r << endl;
}
} else if (lenl > lenr) {
if ((leno >= (lenl - lenr)) && (((leno - lenl + lenr) & 1) == 0)) {
for (int i = 0; i < (lenl - lenr); i++) r += o[i];
for (int i = (lenl - lenr); o[i]; i++) {
if (i & 1)
r += o[i];
else
l += o[i];
}
cout << l << "|" << r << endl;
} else
cout << "Impossible\n";
} else {
if ((leno >= (lenr - lenl)) && (((leno - lenr + lenl) & 1) == 0)) {
for (int i = 0; i < (lenr - lenl); i++) l += o[i];
for (int i = (lenr - lenl); o[i]; i++) {
if (i & 1)
r += o[i];
else
l += o[i];
}
cout << l << "|" << r << endl;
} else
cout << "Impossible\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 10;
int n, a[1000], s[1000];
char str[10];
int dp[1001][8];
int DP(int idx, int state) {
int &ret = dp[idx][state];
if (ret != -1) return ret;
if (state == (1 << 3) - 1) return ret = 0;
if (idx == n) return ret = inf;
ret = inf;
ret = min(ret, DP(idx + 1, state));
ret = min(ret, DP(idx + 1, state | s[idx]) + a[idx]);
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%s", a + i, str);
int m = strlen(str);
for (int j = 0; j < m; j++) s[i] |= 1 << (str[j] - 'A');
}
memset(dp, -1, sizeof(dp));
int val = DP(0, 0);
if (val >= inf)
puts("-1");
else
printf("%d\n", val);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int k;
cin >> k;
int minn = 0, maxx = 0, c = 0;
int len = s.length();
for (int i = 0; i < len; i++) {
if (s[i] != '*' && s[i] != '?') {
minn++;
maxx++;
c++;
} else if (s[i] == '*' && i != 0) {
minn--;
maxx = 1000;
} else {
minn--;
}
}
int l = 0, additional = k - c;
string st = "";
if (k >= minn && maxx >= k) {
if (additional == 0) {
for (int i = 0; i < len; i++) {
if (s[i] != '*' && s[i] != '?') {
st = st + s[i];
}
}
} else if (additional > 0) {
int done = 0;
for (int i = 0; i < len; i++) {
if (s[i] != '*' && s[i] != '?')
st = st + s[i];
else if (s[i] == '*' && !done) {
done++;
for (int j = 0; j < additional; j++) {
st = st + s[i - 1];
}
}
}
} else {
int rem = abs(additional);
for (int i = 0; i < len; i++) {
if (rem && s[i] != '*' && s[i] != '?' &&
(i + 1 < len && (s[i + 1] != '*') && (s[i + 1] != '?'))) {
st = st + s[i];
} else if (rem && s[i] != '*' && s[i] != '?' &&
(i + 1 < len && ((s[i + 1] != '*') || (s[i + 1] != '?')))) {
rem--;
} else if (!rem && s[i] != '*' && s[i] != '?') {
st = st + s[i];
}
}
}
cout << st << endl;
} else {
cout << "Impossible" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1073741824")
using namespace std;
const int nmax = 100009;
pair<int, int> a[nmax];
int main() {
int n, h;
cin >> n >> h;
for (int i = 0; i < n; ++i) {
cin >> a[i].first;
a[i].second = i;
}
if (n == 2) {
cout << 0 << endl;
cout << 1 << " " << 1 << endl;
return 0;
}
sort(a, a + n);
long long ans1 = a[n - 1].first + a[n - 2].first - (a[0].first + a[1].first);
long long ans2;
vector<long long> tmp;
tmp.push_back(a[0].first + a[1].first + h);
tmp.push_back(a[0].first + a[n - 1].first + h);
tmp.push_back(a[1].first + a[2].first);
tmp.push_back(a[n - 1].first + a[n - 2].first);
sort((tmp).begin(), (tmp).end());
ans2 = tmp.back() - tmp[0];
if (ans1 <= ans2) {
cout << ans1 << endl;
for (int i = 0; i < n - 1; ++i) cout << 1 << " ";
cout << 1 << endl;
} else {
cout << ans2 << endl;
for (int i = 0; i < n; ++i) {
int pa = 1;
if (i == a[0].second) pa = 2;
cout << pa;
if (i == n - 1)
cout << endl;
else
cout << " ";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
char c;
bool nega = 0;
while ((!isdigit(c = getchar())) && (c != '-'))
;
if (c == '-') {
nega = 1;
c = getchar();
}
x = c - 48;
while (isdigit(c = getchar())) x = x * 10 + c - 48;
if (nega) x = -x;
}
template <typename T>
inline void writep(T x) {
if (x > 9) writep(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
writep(x);
putchar(' ');
}
template <typename T>
inline void writeln(T x) {
write(x);
putchar('\n');
}
using namespace std;
const int mod = 998244353;
int n, len, k, dp[100005][101], cnt[101];
void Add(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> len;
dp[0][0] = 1;
for (int i = (1); i <= (n); ++i) {
int x;
cin >> x;
for (int j = (1); j <= (k); ++j)
if (x == -1 || x == j) {
++cnt[j];
Add(dp[i][j], dp[i - 1][0]);
if (cnt[j] >= len) {
Add(dp[i][j], mod - dp[i - len][0]);
Add(dp[i][j], dp[i - len][j]);
}
Add(dp[i][0], dp[i][j]);
} else
cnt[j] = 0;
}
cout << dp[n][0];
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, i, cnt = 0, a[100005], sum = 0;
vector<long long> v;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum % k != 0) {
cout << "No";
return 0;
}
long long q = sum / k, p = 0;
for (i = 0; i < n; i++) {
p += a[i];
if (p == q) {
p = 0;
cnt++;
v.push_back(cnt);
cnt = 0;
} else if (p > q) {
cout << "No";
return 0;
} else {
cnt++;
}
}
cout << "Yes\n";
for (auto it : v) {
cout << it << " ";
}
}
| 1 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
const int maxn = (5e2 + 10);
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
using namespace std;
map<long long, long long> ys;
long long a[200010];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n;
long double ans = 0, sum = 0;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
ys[a[i]] += 1;
}
for (long long i = 1; i <= n; i++) {
ans += sum - (long double)(n - i + 1) * (long double)a[i];
ans += ys[a[i] - 1] - ys[a[i] + 1];
sum -= a[i];
ys[a[i]] -= 1;
}
cout << fixed << setprecision(0) << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
return os << "(" << a.first << ", " << a.second << ")";
};
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cerr << *i << " ";
cerr << endl;
}
template <class T>
bool chmin(T &t, const T &f) {
if (t > f) {
t = f;
return true;
}
return false;
}
template <class T>
bool chmax(T &t, const T &f) {
if (t < f) {
t = f;
return true;
}
return false;
}
template <class T, class S, class OpTT, class OpST, class OpSS>
struct SegmentTree {
const OpTT opTT;
const OpST opST;
const OpSS opSS;
const T idT;
const S idS;
int n;
vector<T> ts;
vector<S> ss;
SegmentTree(int n_, const OpTT opTT, const OpST opST, const OpSS opSS,
const T &idT, const S &idS)
: opTT(opTT), opST(opST), opSS(opSS), idT(idT), idS(idS) {
for (n = 1; n < n_; n <<= 1) {
}
ts.assign(n << 1, idT);
ss.assign(n << 1, idS);
}
T &at(int a) { return ts[n + a]; }
void build() {
for (int a = n; --a;) ts[a] = opTT(ts[a << 1], ts[a << 1 | 1]);
}
T query(int a, int b, const S &s) { return query(1, 0, n, a, b, s); }
private:
T query(int u, int l, int r, int a, int b, const S &s) {
if (a < l) a = l;
if (b > r) b = r;
if (a >= b) return idT;
if (a == l && b == r) {
ts[u] = opST(s, ts[u], r - l);
ss[u] = opSS(s, ss[u]);
return ts[u];
}
const int uL = u << 1, uR = u << 1 | 1;
const int mid = (l + r) >> 1;
{
ts[uL] = opST(ss[u], ts[uL], mid - l);
ts[uR] = opST(ss[u], ts[uR], r - mid);
ss[uL] = opSS(ss[u], ss[uL]);
ss[uR] = opSS(ss[u], ss[uR]);
ss[u] = idS;
}
const T resL = query(uL, l, mid, a, b, s);
const T resR = query(uR, mid, r, a, b, s);
ts[u] = opTT(ts[uL], ts[uR]);
return opTT(resL, resR);
}
};
constexpr int MAX = 50005;
int N, M, Q, C;
int F[MAX], P[MAX];
int D[MAX];
int T[MAX], X[MAX], K[MAX];
double anss[MAX];
int f[MAX];
int queriesLen;
pair<pair<int, int>, pair<int, int>> queries[4 * MAX];
Int vals[MAX];
void brute() {
fill(vals, vals + N, 0);
Int s1 = 0, s2 = 0;
for (int h = 0; h < queriesLen; ++h) {
switch (queries[h].second.second) {
case +1: {
const int u = queries[h].second.first;
for (int v = u; v != -1; v = P[v]) {
++s1;
s2 += vals[v];
}
for (int v = u; v != -1; v = P[v]) {
++vals[v];
}
} break;
case -1: {
const int u = queries[h].second.first;
for (int v = u; v != -1; v = P[v]) {
--vals[v];
}
for (int v = u; v != -1; v = P[v]) {
--s1;
s2 -= vals[v];
}
} break;
case 0: {
const int k = queries[h].first.first;
double ans = 0.0;
ans += 1.0 * C * C * N;
ans -= 2.0 * C * D[k] * s1;
ans += 1.0 * D[k] * D[k] * (s1 + 2.0 * s2);
ans /= N;
anss[queries[h].second.first] = ans;
} break;
default:
assert(false);
}
}
for (int q = 0; q < Q; ++q) {
if (T[q] == 2) {
printf("%.10f\n", anss[q]);
}
}
}
vector<int> G[MAX];
int par[MAX], sz[MAX], dep[MAX];
int O, ord[MAX], head[MAX];
void dfs0(int u, int p) {
par[u] = p;
sz[u] = 1;
dep[u] = (p == -1) ? 0 : (dep[p] + 1);
for (const int v : G[u]) {
if (v != p) {
dfs0(v, u);
sz[u] += sz[v];
}
}
}
void dfs1(int u, int p, int h) {
ord[u] = O++;
head[u] = h;
int vm = -1;
for (const int v : G[u]) {
if (v != p) {
if (vm == -1 || sz[vm] < sz[v]) {
vm = v;
}
}
}
if (vm != -1) {
dfs1(vm, u, h);
for (const int v : G[u]) {
if (v != p && v != vm) {
dfs1(v, u, v);
}
}
}
}
void solve() {
for (int u = 0; u < N; ++u) {
G[u].clear();
}
for (int u = 1; u < N; ++u) {
G[P[u]].push_back(u);
}
const int rt = 0;
dfs0(rt, -1);
O = 0;
dfs1(rt, -1, 0);
auto opTT = [](Int t0, Int t1) { return t0 + t1; };
auto opST = [](Int s, Int t, Int sz) { return t + s * sz; };
auto opSS = [](Int s0, Int s1) { return s0 + s1; };
SegmentTree<Int, Int, decltype(opTT), decltype(opST), decltype(opSS)> seg(
N, opTT, opST, opSS, 0, 0);
auto query = [&](int u, int val) {
Int ret = 0;
for (; u != -1;) {
const Int h = head[u];
ret += seg.query(ord[h], ord[u] + 1, val);
u = par[h];
}
return ret;
};
Int s1 = 0, s2 = 0;
for (int h = 0; h < queriesLen; ++h) {
switch (queries[h].second.second) {
case +1: {
const int u = queries[h].second.first;
s1 += (dep[u] + 1);
s2 += query(u, 0);
query(u, +1);
} break;
case -1: {
const int u = queries[h].second.first;
s1 -= (dep[u] + 1);
s2 -= query(u, -1);
} break;
case 0: {
const int k = queries[h].first.first;
double ans = 0.0;
ans += 1.0 * C * C * N;
ans -= 2.0 * C * D[k] * s1;
ans += 1.0 * D[k] * D[k] * (s1 + 2.0 * s2);
ans /= N;
anss[queries[h].second.first] = ans;
} break;
default:
assert(false);
}
}
for (int q = 0; q < Q; ++q) {
if (T[q] == 2) {
printf("%.10f\n", anss[q]);
}
}
}
int main() {
for (; ~scanf("%d%d%d%d", &N, &M, &Q, &C);) {
for (int u = 0; u < N; ++u) {
scanf("%d", &F[u]);
--F[u];
}
P[0] = -1;
for (int u = 1; u < N; ++u) {
scanf("%d", &P[u]);
--P[u];
}
for (int k = 0; k < M; ++k) {
scanf("%d", &D[k]);
}
for (int q = 0; q < Q; ++q) {
scanf("%d", &T[q]);
if (T[q] == 1) {
scanf("%d", &X[q]);
--X[q];
}
scanf("%d", &K[q]);
--K[q];
}
copy(F, F + N, f);
queriesLen = 0;
for (int u = 0; u < N; ++u) {
queries[queriesLen++] = {{f[u], -1}, {u, +1}};
}
for (int q = 0; q < Q; ++q) {
if (T[q] == 1) {
const int u = X[q];
queries[queriesLen++] = {{f[u], q}, {u, -1}};
f[u] = K[q];
queries[queriesLen++] = {{f[u], q}, {u, +1}};
} else {
queries[queriesLen++] = {{K[q], q}, {q, 0}};
}
}
for (int u = 0; u < N; ++u) {
queries[queriesLen++] = {{f[u], Q}, {u, -1}};
}
sort(queries, queries + queriesLen);
solve();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
int main() {
std::string input;
getline(std::cin, input);
int next(0);
if (input[0] == 'f') {
printf("ftp://");
next = 3;
} else if (input[0] == 'h') {
printf("http://");
next = 4;
}
while (true) {
printf("%c", input[next++]);
if (input[next] == 'r' && input[next + 1] == 'u') {
next += 2;
break;
}
}
printf(".ru");
if (next < input.size()) {
printf("/");
}
while (next < input.size()) {
printf("%c", input[next++]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void c_p_c() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void solve() {
long long n, k;
cin >> n >> k;
long long ash = k;
long long j = 0;
while (k--) {
long long m;
cin >> m;
vector<long long> arr(m);
for (auto &x : arr) {
cin >> x;
}
if (arr[0] == 1) {
for (long long i = 0; i < m - 1; ++i) {
if (arr[i + 1] != arr[i] + 1) {
j += m - i - 1;
break;
}
}
j++;
} else {
j += m;
}
}
cout << 2 * j - ash - 1;
return;
}
int32_t main() {
c_p_c();
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 100, mod = 1e9 + 7, inf = 1e17;
int n, m, x1, x2, d, z, t, sum, y, maxi, mini, ans, ptr, x, dp[330][MAXN], sq;
deque<int> q[MAXN];
void upd(long long x, long long y) {
if (x / sq == y / sq) {
for (int i = (y - 1) % sq; i >= (x % sq); i--) {
swap(q[x / sq][i], q[x / sq][i + 1]);
}
} else {
q[x / sq].insert(q[x / sq].begin() + (x % sq), q[y / sq][y % sq]);
dp[x / sq][q[y / sq][y % sq]]++;
dp[y / sq][q[y / sq][y % sq]]--;
q[y / sq].erase(q[y / sq].begin() + (y % sq));
for (int i = (x / sq) + 1; i <= y / sq; i++) {
q[i].push_front(q[i - 1].back());
dp[i][q[i - 1].back()]++;
dp[i - 1][q[i - 1].back()]--;
q[i - 1].pop_back();
}
}
}
long long query(long long x, long long y, long long z) {
ans = 0;
while (x <= y && x % sq != 0) {
if (q[(x / sq)][x % sq] == z) ans++;
x++;
}
while (x + sq <= y) {
ans += dp[x / sq][z];
x += sq;
}
while (x <= y) {
if (q[(x / sq)][x % sq] == z) ans++;
x++;
}
return ans;
}
int main() {
cin >> n;
sq = ceil(sqrt(n));
for (int i = 0; i < n; i++) {
cin >> x;
q[i / sq].push_back(x);
dp[i / sq][x]++;
}
cin >> m;
long long lastans = 0;
while (m--) {
cin >> t;
if (t == 1) {
cin >> x >> y;
x = ((x + lastans - 1) % n);
y = ((y + lastans - 1) % n);
if (x > y) {
swap(x, y);
}
upd(x, y);
} else {
cin >> x >> y >> z;
x = ((x + lastans - 1) % n);
y = ((y + lastans - 1) % n);
z = ((z + lastans - 1) % n) + 1;
if (x > y) {
swap(x, y);
}
lastans = query(x, y, z);
cout << lastans << endl;
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long num = 0, flag = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
while (c >= '0' && c <= '9') num = num * 10 + c - 48, c = getchar();
return num * flag;
}
int n;
int f[305], vis[305], Q, ma[305][305], num;
struct pt {
int x, y;
} p[305];
struct Mat {
double a[305][305];
} pw[14];
struct Vector {
double d[305];
} ans;
vector<int> line[305 * 305];
inline int operator*(const pt &A, const pt &B) { return A.x * B.y - A.y * B.x; }
inline pt operator-(const pt &A, const pt &B) {
return (pt){A.x - B.x, A.y - B.y};
}
inline Mat operator*(const Mat &A, const Mat &B) {
Mat C;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) C.a[i][j] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) C.a[i][j] += A.a[i][k] * B.a[k][j];
return C;
}
inline Vector operator*(const Vector &A, const Mat &B) {
Vector C;
for (int i = 1; i <= n; i++) C.d[i] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) C.d[j] += A.d[i] * B.a[i][j];
return C;
}
inline void calc(int t, int m) {
for (int i = 1; i <= n; i++) ans.d[i] = 0;
ans.d[t] = 1;
for (int i = 13; i >= 0; --i)
if (m >> i & 1) ans = ans * pw[i];
}
inline void work() {
for (int i = 0; i < line[num].size(); ++i)
for (int j = 0; j < line[num].size(); ++j)
ma[line[num][i]][line[num][j]] = 1;
}
int main() {
n = getint();
for (int i = 1; i <= n; i++) p[i].x = getint(), p[i].y = getint();
for (int i = 1; i <= n; i++) {
int Line_num = 0;
double nw = 0;
for (int j = 1; j <= n; j++) {
if (j == i || vis[j]) continue;
int tot = 0;
++Line_num;
for (int k = 1; k <= n; k++)
if ((p[k] - p[i]) * (p[j] - p[i]) == 0) vis[k] = 1, ++tot;
for (int k = 1; k <= n; ++k)
if ((p[k] - p[i]) * (p[j] - p[i]) == 0) f[k] = tot;
nw += 1.0 / (double)tot;
}
double p = 1.0 / (double)Line_num;
for (int j = 1; j <= n; j++) {
if (j == i) {
pw[0].a[i][i] = nw * p;
continue;
}
pw[0].a[j][i] = 1.0 / (double)f[j];
pw[0].a[j][i] *= p;
}
for (int j = 1; j <= n; j++) f[j] = vis[j] = 0;
}
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
if (ma[i][j]) continue;
++num;
for (int k = 1; k <= n; k++)
if ((p[i] - p[k]) * (p[j] - p[k]) == 0) line[num].push_back(k);
work();
}
for (int i = 1; i <= 13; i++) pw[i] = pw[i - 1] * pw[i - 1];
Q = getint();
while (Q--) {
int t = getint(), m = getint();
double nw = 0;
calc(t, m - 1);
for (int i = 1; i <= num; ++i) {
double k = 0;
for (int j = 0; j < line[i].size(); ++j) k += ans.d[line[i][j]];
k *= 1.0 / (double)line[i].size();
nw = max(k, nw);
}
printf("%.12lf\n", nw);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 2520;
int t, dig[20], fac[50], d[50][10], num[mod + 5];
long long dp[20][50][mod + 5];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
long long dfs(int pos, int beishu, int yu, bool limit) {
if (pos == 0) {
return yu % fac[beishu] == 0;
}
if (!limit && dp[pos][beishu][yu] != -1) {
return dp[pos][beishu][yu];
}
long long ans = 0;
int ed = limit ? dig[pos] : 9;
for (int i = 0; i <= ed; i++) {
ans += dfs(pos - 1, d[beishu][i], (yu * 10 + i) % mod, limit && i == ed);
}
if (!limit) {
dp[pos][beishu][yu] = ans;
}
return ans;
}
long long work(long long x) {
int cnt = 0;
while (x > 0) {
dig[++cnt] = x % 10;
x = x / 10;
}
return dfs(cnt, 1, 0, 1);
}
void init() {
memset(dp, -1, sizeof(dp));
int tot = 0;
for (int i = 1; i <= mod; i++) {
if (mod % i == 0) {
fac[++tot] = i;
num[i] = tot;
}
}
for (int i = 1; i <= tot; i++) {
d[i][0] = i;
for (int j = 1; j <= 9; j++) {
d[i][j] = num[lcm(fac[i], j)];
}
}
}
int main() {
init();
scanf("%d", &t);
while (t--) {
long long a, b;
scanf("%I64d %I64d", &a, &b);
printf("%I64d\n", work(b) - work(a - 1));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
string ans = "";
for (int i = 0; i < n; ++i) {
if (ans.size() % 2 == 0 || ans[ans.size() - 1] != s[i]) {
ans.push_back(s[i]);
}
}
int k = ans.size();
if (k % 2 == 1) {
k--;
}
cout << n - k << '\n';
cout << ans.substr(0, k);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
const int BLOCK = 100;
int n;
int f[N][2];
vector<int> node;
vector<int> g[N];
int fa[N];
void dfs(int u, int f = 1) {
for (auto v : g[u]) {
if (v != f) {
dfs(v, u);
}
}
node.push_back(u);
fa[u] = f;
}
int solve(int k) {
for (int i = 1; i <= n; i++) {
f[i][0] = f[i][1] = 0;
}
int ret = 0;
for (int u : node) {
if (f[u][0] + f[u][1] + 1 >= k) {
ret++;
} else {
if (f[fa[u]][0] < f[u][0] + 1) {
f[fa[u]][1] = f[fa[u]][0];
f[fa[u]][0] = f[u][0] + 1;
} else {
f[fa[u]][1] = max(f[fa[u]][1], f[u][0] + 1);
}
}
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
int x = N, k = 1;
while (x > BLOCK) {
x = solve(k++);
printf("%d\n", x);
}
for (int i = BLOCK; i >= 0; i--) {
if (solve(k) != i || k > n) {
continue;
}
int l = k, r = n + 1;
while (r - l > 1) {
int mid = (l + r) / 2;
if (solve(mid) == i) {
l = mid;
} else {
r = mid;
}
}
while (k <= l) {
printf("%d\n", i);
k++;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
char s[1500];
bool S[5205][5205];
int N, sum[5205][5205];
int f(char x) {
if (x <= '9') return x - '0';
return x - 'A' + 10;
}
bool p(int x) {
if (x > N) return 1;
for (int i = 1; i <= N; i += x) {
for (int j = 1; j <= N; j += x) {
int a = i + x - 1, b = j + x - 1;
int t = sum[a][b] - sum[a][j - 1] - sum[i - 1][b] + sum[i - 1][j - 1];
if (t != x * x && t) return 1;
}
}
return 0;
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
scanf("%s", s + 1);
for (int j = 1; j <= N; ++j) {
S[i][j] = (f(s[(j + 3) / 4]) >> ((j + 3) % 4)) & 1;
if (j % 4 == 0)
swap(S[i][j], S[i][j - 3]), swap(S[i][j - 1], S[i][j - 2]);
}
}
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= N; ++j) {
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + S[i][j];
}
}
for (int i = N; i; --i)
if (N % i == 0 && p(i) == 0) return !printf("%d", i);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "inline")
using namespace std;
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
const int N = 200005;
int n, m;
vector<int> e[N], id[N];
struct Edge {
int x, y, z;
} a[N];
int depth[N], size[N], son[N], fa[N], top[N], I[N], aI[N], Time = 0;
void dfs1(int x, int pre, int d) {
depth[x] = d, fa[x] = pre, size[x] = 1, son[x] = 0;
for (int i = 0; i < e[x].size(); i++) {
int y = e[x][i];
if (y != pre) {
dfs1(y, x, d + 1);
size[x] += size[y];
if (!son[x] || size[y] > size[son[x]]) son[x] = y;
}
}
}
void dfs2(int x, int Top) {
top[x] = Top;
I[x] = ++Time;
aI[Time] = x;
if (son[x]) dfs2(son[x], Top);
for (int i = 0; i < e[x].size(); i++) {
int y = e[x][i];
if (y != fa[x] && y != son[x]) dfs2(y, y);
}
}
long long c[N];
void Add(int x, long long v) {
for (; x <= n; x += x & -x) c[x] += v;
}
long long Ask(int x) {
long long ans = 0;
for (; x; x -= x & -x) ans += c[x];
return ans;
}
int LCA(int x, int y) {
while (top[x] != top[y]) {
if (depth[top[x]] < depth[top[y]]) swap(x, y);
x = fa[top[x]];
}
return depth[x] < depth[y] ? x : y;
}
int Goup(int x, int y) {
while (top[x] != top[y]) {
x = top[x];
if (fa[x] == y) return x;
x = fa[x];
}
return son[y];
}
long long dp[N], val[N];
long long Query(int x, int y) {
long long ans = dp[son[x]];
while (top[x] != top[y]) {
ans += Ask(I[x]) - Ask(I[top[x]] - 1);
ans -= dp[top[x]];
x = fa[top[x]];
ans += dp[son[x]];
}
ans += Ask(I[x]) - Ask(I[y] - 1);
return ans;
}
void dfs3(int x) {
dp[x] = 0;
for (int i = 0; i < e[x].size(); i++) {
int y = e[x][i];
if (y != fa[x]) {
dfs3(y);
dp[x] += dp[y];
if (y != son[x]) val[x] += dp[y];
}
}
Add(I[x], val[x]);
for (int cly = 0; cly < id[x].size(); cly++) {
int i = id[x][cly];
dp[x] = max(dp[x], Query(a[i].x, x) + Query(a[i].y, x) - val[x] -
dp[son[x]] + a[i].z);
}
}
int main() {
n = read();
if (1) m = read();
for (int i = 1; i <= n - 1; i++) {
if (1) {
int f = read();
e[i + 1].push_back(f), e[f].push_back(i + 1);
} else {
int x = read(), y = read();
e[x].push_back(y), e[y].push_back(x);
}
}
dfs1(1, 0, 0);
dfs2(1, 1);
if (!1) m = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read(), z = read();
a[i].x = x, a[i].y = y, a[i].z = z;
id[LCA(x, y)].push_back(i);
}
dfs3(1);
cout << dp[1] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y, z;
};
int n;
point pt[5010];
double dist[5010][5010];
double ans = 1e12;
double findDist(point a, point b) {
return sqrtl((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y) +
(a.z - b.z) * (a.z - b.z));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &pt[i].x, &pt[i].y, &pt[i].z);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dist[i][j] = findDist(pt[i], pt[j]);
}
}
for (int i = 2; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
double a, b;
a = dist[1][i], b = dist[1][j];
if (a > b) swap(a, b);
ans = min(ans, b + (dist[i][j] - (b - a)) / 2.0);
}
}
cout << fixed << setprecision(7) << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
vector<int> endhere[300010];
int lef[300010];
int n, q;
int bit[300010], an[300010];
void add(int idx, int val) {
for (; idx < 300010; idx += idx & (-idx)) bit[idx] += val;
}
int pref(int idx) {
int ans = 0;
for (; idx > 0; idx -= idx & (-idx)) ans += bit[idx];
return ans;
}
int sum(int a, int b) { return pref(b) - pref(a - 1); }
void solve() {
cin >> n >> q;
vector<int> v(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> v[i];
v[i] = i - v[i];
}
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
lef[i] = 1 + a;
endhere[n - b].push_back(i);
}
int init = 0;
for (int r = 1; r <= n; r++) {
int target = v[r];
if (target >= 0) {
int lo = 1, hi = r, mid, ans = 0;
while (lo <= hi) {
mid = lo + hi >> 1;
if (pref(mid) >= target) {
ans = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
add(1, 1);
add(ans + 1, -1);
}
for (auto x : endhere[r]) an[x] = pref(lef[x]);
}
for (int i = 0; i < q; i++) cout << an[i] << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-30;
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
const int MAXN = 100000 + 10;
const long long MOD = 1000000007;
int a[MAXN], b[MAXN], c[MAXN];
int main() {
int n;
cin >> n;
int tot = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
b[a[i]]++;
if (b[a[i]] % 2 == 1)
tot++;
else
tot--;
}
if (tot > 1 || (tot == 1 && n % 2 == 0)) {
printf("0\n");
return 0;
}
int l, r;
for (l = 0, r = n - 1; l <= n / 2; ++l, --r) {
if (a[l] != a[r]) break;
b[a[l]] -= 2;
}
if (r <= l) {
printf("%lld\n", (long long)n * (n + 1) / 2);
return 0;
}
int cnt = 0;
for (int i = l; i <= r; ++i) {
c[a[i]]++;
if (i < n / 2) {
if (c[a[i]] <= b[a[i]] / 2)
cnt++;
else
break;
} else {
if (a[i] == a[n - 1 - i] && (n % 2 == 0 || b[a[i]] % 2 == 1))
cnt++;
else
break;
}
}
memset(c, 0, sizeof(c));
for (int i = r; i >= l; --i) {
c[a[i]]++;
if (i > n / 2 || (i == n / 2 && n % 2 == 0)) {
if (c[a[i]] <= b[a[i]] / 2)
cnt++;
else
break;
} else {
if (a[i] == a[n - 1 - i] && (n % 2 == 0 || b[a[i]] % 2 == 1))
cnt++;
else
break;
}
}
printf("%I64d\n", (long long)(l + 1) * (l + 1 + cnt));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<int> H;
set<int>::iterator it;
int ind[1000666], a[1000666], b[1000666], k;
int i, Arb[1000666], n;
bool fr[1000666];
long long result;
void update(int pos) {
for (; pos <= n; pos += (pos & (pos ^ (pos - 1)))) Arb[pos]++;
}
int query(int pos) {
int res = 0;
for (; pos > 0; pos -= (pos & (pos ^ (pos - 1)))) res += Arb[pos];
return res;
}
bool comp(int i1, int i2) { return a[i1] < a[i2]; }
int main() {
cin >> n >> k;
for (i = 1; i <= n; ++i) {
cin >> a[i];
ind[i] = i;
}
for (i = 1; i <= n; ++i) {
cin >> b[i];
fr[b[i]] = true;
}
sort(ind + 1, ind + n + 1, comp);
for (i = 1; i <= n; ++i) {
int ls, ld;
if (fr[a[ind[i]]] == true) {
H.insert(ind[i]);
continue;
}
update(ind[i]);
if (H.empty() == true) {
result += n - query(n) + 1;
continue;
}
it = H.lower_bound(ind[i]);
if (it == H.end()) {
ld = n;
ls = (*(--it)) + 1;
} else if (it == H.begin()) {
ls = 1;
ld = (*it) - 1;
} else {
ld = (*it) - 1;
ls = (*(--it)) + 1;
}
result += (long long)((ld - ls + 1) - query(ld) + query(ls - 1) + 1);
}
cout << result << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#define INF 2000000000
typedef long long int ll;
typedef pair<ll,ll> ii;
typedef pair<ii,ll> iii;
typedef vector<ll> vi;
typedef vector<ii> vii;
#define getbit(n,i) (((n)&(1LL<<(i)))!=0)
#define setbit0(n,i) ((n)&(~(1LL<<(i))))
#define setbit1(n,i) ((n)|(1LL<<(i)))
#define lastone(n) ((n)&(-(n)))
#define read freopen("debug//in.txt","r",stdin)
#define write freopen("debug//out.txt","w",stdout)
#define DBG(a) cerr<<#a<<" ->->->-> "<<a<<"\n"
#define fi first
#define se second
#define PI (acos(-1))
#define fastread ios::sync_with_stdio(false);cin.tie(NULL)
#define mod (100000007)
#define asz 10005
template<class T,class V> ostream& operator<<(ostream &s,pair<T,V> a)
{
s<<a.fi<<' '<<a.se;
return s;
}
int main()
{
fastread;
#ifdef FILE_IO2
read;
write;
#endif
int T=1;
cin>>T;
for(int qq=1; qq<=T; qq++)
{
int n;
cin>>n;
ll sum=0;
vi v(n);
for(auto &x:v)cin>>x,sum+=x;
sort(v.begin(),v.end());
ll tot=v.back()*(n-1);
if(tot>sum){
cout<<tot-sum<<endl;
}
else{
if(sum%(n-1)==0)cout<<0<<endl;
else cout<<n-1-sum%(n-1)<<endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 998244353;
inline int add(int a, int b) {
a += b;
return a - MOD * (a >= MOD);
}
inline int mult(int a, int b) { return (ll)a * b % MOD; }
inline int sub(int a, int b) {
a -= b;
return a + MOD * (a < 0);
}
int power(int a, int b) {
if (!b) {
return 1;
}
if (b % 2) {
return mult(a, power(a, b - 1));
}
return power(mult(a, a), b / 2);
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (auto &el : a) {
cin >> el;
}
if (k == 1) {
cout << "0\n";
return 0;
}
int good = 0, bad = 0;
for (int i = 0; i < n; i++) {
(a[i] == a[(i + 1) % n] ? good : bad)++;
}
vector<int> fact(n + 1, 1);
for (int i = 1; i <= n; i++) {
fact[i] = mult(fact[i - 1], i);
}
vector<int> rfact(n + 1, power(fact[n], MOD - 2));
for (int i = n; i; i--) {
rfact[i - 1] = mult(rfact[i], i);
}
auto C = [&](int n, int k) -> int {
return mult(fact[n], mult(rfact[k], rfact[n - k]));
};
int ans = 0;
for (int cnt = 0; cnt < bad; cnt++) {
int now = bad - cnt;
if (now % 2) {
ans = add(ans,
mult(C(bad, cnt), mult(power(k - 2, cnt), power(2, now - 1))));
} else {
ans = add(ans,
mult(C(bad, cnt), mult(power(k - 2, cnt),
mult(sub(power(2, now), C(now, now / 2)),
power(2, MOD - 2)))));
}
}
ans = mult(ans, power(k, good));
cout << ans << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i, a, b) for (auto i = (a); i < (b); ++i)
#define per(i, a, b) for (auto i = (b); i-- > (a); )
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) int((x).size())
#define lb(x...) lower_bound(x)
#define ub(x...) upper_bound(x)
template<class T> bool ckmin(T& a, const T& b) { return a > b ? a = b, 1 : 0; }
template<class T> bool ckmax(T& a, const T& b) { return a < b ? a = b, 1 : 0; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 1 << 18;
const ll inf = 1e18;
ll d[N][2][2];
vector<pair<int, int>> g[N];
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m; cin >> n >> m;
rep(e, 0, m) {
int u, v, w; cin >> u >> v >> w; --u; --v;
g[u].emplace_back(v, w);
g[v].emplace_back(u, w);
}
rep(u, 0, n) rep(i, 0, 2) rep(j, 0, 2) d[u][i][j] = inf;
priority_queue<tuple<ll, int, int, int>> q;
d[0][1][1] = 0; q.push({0, 0, 1, 1});
while (!q.empty()) {
auto [d_u, u, a, b] = q.top(); q.pop();
if (-d_u != d[u][a][b]) continue;
for (auto [v, w] : g[u])
for (int x = 0; x <= a; ++x)
for (int y = 0; y <= b; ++y)
if (ckmin(d[v][a ^ x][b ^ y], d[u][a][b] + (1 - x + y) * w))
q.push({-d[v][a ^ x][b ^ y], v, a ^ x, b ^ y});
}
rep(u, 1, n) cout << d[u][0][0] << ' ';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int x[100005], y[100005];
pair<int, int> p[100005];
pair<pair<int, int>, int> r[100005];
int ans[100005];
vector<int> ht;
struct st {
int st[800005];
void init() { memset(st, 0, sizeof(st)); }
void update(int n, int s, int e, int idx, int v) {
if (s == e)
st[n] = max(st[n], v);
else {
int mid = (s + e) / 2;
if (idx <= mid)
update(n + n, s, mid, idx, v);
else
update(n + n + 1, mid + 1, e, idx, v);
st[n] = max(st[n + n], st[n + n + 1]);
}
}
int query(int n, int s, int e, int l, int r) {
if (s > r || l > e) return -2e9;
if (l <= s && e <= r) return st[n];
int mid = (s + e) / 2;
int q1 = query(n + n, s, mid, l, r);
int q2 = query(n + n + 1, mid + 1, e, l, r);
return max(q1, q2);
}
} st[2];
int main() {
int n, m;
scanf("%d%d", &n, &m);
int c, h, a, b, j;
scanf("%d", &c);
for (int i = 1; i <= c; i++) {
scanf("%d%d", &x[i], &y[i]);
p[i] = pair<int, int>(x[i], y[i]);
ht.push_back(y[i]);
}
sort(p + 1, p + 1 + c);
for (int i = 1; i <= c; i++) x[i] = p[i].first, y[i] = p[i].second;
scanf("%d", &h);
for (int i = 1; i <= h; i++) {
scanf("%d%d", &a, &b);
r[i] = pair<pair<int, int>, int>(pair<int, int>(a, b), i);
ht.push_back(b);
}
sort(r + 1, r + 1 + h);
sort(ht.begin(), ht.end());
ht.erase(unique(ht.begin(), ht.end()), ht.end());
int N = ht.size();
int l = 1;
for (int i = 1; i <= h; i++) {
a = r[i].first.first, b = r[i].first.second, j = r[i].second;
while (l <= c) {
if (x[l] <= a) {
int k = lower_bound(ht.begin(), ht.end(), y[l]) - ht.begin() + 1;
st[0].update(1, 1, N, k, n - x[l] + m - y[l]);
st[1].update(1, 1, N, k, n - x[l] + y[l]);
l++;
} else
break;
}
int k = lower_bound(ht.begin(), ht.end(), b) - ht.begin() + 1;
ans[j] = max(ans[j], st[0].query(1, 1, N, 1, k) - (n - a) - (m - b));
ans[j] = max(ans[j], st[1].query(1, 1, N, k, N) - (n - a) - b);
}
st[0].init();
st[1].init();
l = c;
for (int i = h; i >= 1; i--) {
a = r[i].first.first, b = r[i].first.second, j = r[i].second;
while (l >= 1) {
if (x[l] >= a) {
int k = lower_bound(ht.begin(), ht.end(), y[l]) - ht.begin() + 1;
st[0].update(1, 1, N, k, x[l] + m - y[l]);
st[1].update(1, 1, N, k, x[l] + y[l]);
l--;
} else
break;
}
int k = lower_bound(ht.begin(), ht.end(), b) - ht.begin() + 1;
ans[j] = max(ans[j], st[0].query(1, 1, N, 1, k) - a - (m - b));
ans[j] = max(ans[j], st[1].query(1, 1, N, k, N) - a - b);
}
int mn = 2e9, idx = 0;
for (int i = 1; i <= h; i++) {
if (ans[i] < mn) {
mn = ans[i];
idx = i;
}
}
printf("%d\n%d\n", mn, idx);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<string> g;
int res[10003];
int ans[10003];
vector<vector<int> > gg;
string a;
string b;
int m;
bool flag[10003];
int main() {
scanf("%d", &m);
gg.resize(2 * m);
int i, j, jj;
int ind1, ind2;
for (i = 0; i < m; i++) {
cin >> a >> b;
for (j = 0; j < g.size(); j++)
if (g[j] == a) break;
if (j == g.size()) g.push_back(a);
for (j = 0; j < g.size(); j++)
if (g[j] == b) break;
if (j == g.size()) g.push_back(b);
for (j = 0; j < g.size(); j++) {
if (g[j] == a)
ind1 = j;
else if (g[j] == b)
ind2 = j;
}
gg[ind1].push_back(ind2);
gg[ind2].push_back(ind1);
}
int maxi;
for (i = 0; i < g.size(); i++) {
maxi = 0;
for (j = 0; j < g.size(); j++) flag[j] = false;
for (j = 0; j < gg[i].size(); j++) flag[gg[i][j]] = true;
for (j = 0; j < g.size(); j++) {
res[j] = 0;
if (i != j && !flag[j]) {
for (jj = 0; jj < gg[j].size(); jj++)
if (flag[gg[j][jj]]) res[j]++;
maxi = max(maxi, res[j]);
}
}
for (j = 0; j < g.size(); j++)
if (res[j] == maxi && i != j && !flag[j]) ans[i]++;
}
cout << g.size() << endl;
for (i = 0; i < g.size(); i++) cout << g[i] << " " << ans[i] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T rd() {
T nmb = 0;
int sgn = 0;
char chr = getchar();
while (!isdigit(chr)) {
if (chr == '-') sgn = 1;
chr = getchar();
}
while (isdigit(chr)) {
nmb = (nmb << 3) + (nmb << 1) + chr - '0';
chr = getchar();
}
return sgn ? -nmb : nmb;
}
template <typename T>
void wt(T nmb) {
if (nmb > 9) wt(nmb / 10);
putchar(nmb % 10 + '0');
}
template <typename T>
inline void cmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
inline void cmin(T &x, T y) {
x = x < y ? x : y;
}
inline void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
const int N = 1e3 + 10, M = 5e3 + 10;
const int inf = 1e9;
int n;
pair<int, int> a[M];
vector<int> g[N];
int in[N], vis[N];
void dfs(int x) {
vis[x] = 1;
if (x == n) {
in[x] = 1;
return;
}
for (int i = g[x].size() - 1; ~i; --i) {
int k = g[x][i];
if (!vis[k]) dfs(k);
if (in[k]) in[x] = 1;
}
}
int to[M << 1], fs[N], nx[M << 1], w[M << 1], e;
inline void add(int x, int y, int z) {
to[++e] = y;
nx[e] = fs[x];
fs[x] = e;
w[e] = z;
}
int d[N];
queue<int> q;
int num[N];
int main() {
n = rd<int>();
int m = rd<int>();
for (int t = 1; t <= m; ++t) {
int x = rd<int>(), y = rd<int>();
a[t] = make_pair(x, y);
g[x].push_back(y);
}
dfs(1);
for (int t = 1; t <= m; ++t) {
int x = a[t].first, y = a[t].second;
if (!in[x] || !in[y]) continue;
add(x, y, 2), add(y, x, -1);
}
fill(d + 1, d + n + 1, inf);
d[1] = 0;
q.push(1);
memset(vis, 0, sizeof vis);
vis[1] = 1;
while (!q.empty()) {
int x = q.front();
q.pop(), vis[x] = 0;
for (int i = fs[x]; i; i = nx[i]) {
int k = to[i];
if (d[k] > d[x] + w[i]) {
d[k] = d[x] + w[i];
++num[k];
if (num[k] > n - 1) return puts("No"), 0;
if (!vis[k]) q.push(k), vis[k] = 1;
}
}
}
puts("Yes");
for (int t = 1; t <= m; ++t) {
int x = a[t].first, y = a[t].second;
if (in[x] && in[y])
printf("%d\n", d[a[t].second] - d[a[t].first]);
else
puts("1");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
string str;
cin >> str;
if (n == 1)
cout << "Yes" << endl;
else {
int c[26];
for (int i = 0; i < 26; i++) c[i] = 0;
for (int i = 0; i < str.length(); i++) {
c[str[i] - 'a']++;
}
bool pos = false;
for (int i = 0; i < 26; i++) {
if (c[i] >= 2) {
pos = true;
break;
}
}
if (pos)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, l, m, n, U[2100][2100], D[2100][2100], X, Y, ans, x, y, d;
int get(int fa[2100][2100], int x, int y) {
return fa[x][y] == x ? x : (fa[x][y] = get(fa, fa[x][y], y));
}
void renew(int xx, int yy) {
if (xx < 1 || xx > n || yy < 1 || yy > m) return;
int d = abs(xx - x) + abs(yy - y);
if (d < ans || d == ans && xx < X || d == ans && xx == X && yy < Y) {
ans = d;
X = xx;
Y = yy;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i <= n + 1; ++i)
for (j = 0; j <= m + 1; ++j) U[i][j] = D[i][j] = i;
for (i = 1; i <= k; ++i) {
scanf("%d%d", &x, &y);
ans = 1000000;
for (d = 0; d <= ans; ++d) {
if (y - d >= 1)
renew(get(U, x, y - d), y - d), renew(get(D, x, y - d), y - d);
if (y + d <= m)
renew(get(U, x, y + d), y + d), renew(get(D, x, y + d), y + d);
}
U[X][Y] = X - 1;
D[X][Y] = X + 1;
printf("%d %d\n", X, Y);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[5];
for (int i = 0; i < 5; i++) cin >> a[i];
cout << min(min(min(a[0], a[1]), a[2] / 2), min(a[3] / 7, a[4] / 4)) << endl;
}
| 4 |
//#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
#include <bits/stdc++.h>
#include<utility>
#include<map>
#include<set>
#include <array>
using namespace std;
#define ll long long
#define endl '\n'
#define mod 1000000007
#define pb push_back
#define ff first
#define ss second
#define con continue
#define ub upper_bound
#define lb lower_bound
#define si(x) int(x.size())
#define sum_all(a) ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a) (*min_element((a).begin(), (a).end()))
#define maxe(a) (*max_element((a).begin(), (a).end()))
#define mini(a) ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a) ( max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) ( lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) ( upper_bound((a).begin(), (a).end(), (x)) - (a).begin())
const double pi = 2 * acos(0.0);
const int dx[] = { -1, 0, 1, 0 };
const int dy[] = { 0, -1, 0, 1 };
const int dx8[] = { -1, 0, 1, 0,1,1,-1,-1 };
const int dy8[] = { 0, -1, 0, 1,1,-1,1,-1 };
ll min(ll a, ll b)
{
if (a < b)return a;
return b;
}
ll max(ll a, ll b)
{
if (a > b)return a;
return b;
}
ll ceil1(ll a, ll b)
{
return(a + b - 1) / b;
}
void read(vector<ll> & arr)
{
for (ll i = 0; i < si(arr); i++)
cin >> arr[i];
}
void read_graph(vector<vector<ll>>& g, ll m)
{
while (m--)
{
ll x, y; cin >> x >> y;
x--, y--;
g[x].pb(y);
g[y].pb(x);
}
}
struct node
{
ll a, b, c, d;
};
map<pair<ll, ll>, ll> line;
vector<vector<pair<int, int>>> g;
vector<bool>vis;
vector<pair<int, int>> ans;
vector<bool> used;
ll gcd(ll a, ll b)
{
if (a == 0) return b;
return gcd(b%a, a);
}
pair<ll, ll> get_slope(ll a, ll b, ll c, ll d, bool rev)
{
ll x, y, g;
if (!rev)
{
x = (c + d)*b;
y = a * d;
}
else
{
x = c * b;
y = (a + b)*d;
}
g = gcd(x, y);
return { x / g,y / g };
}
void dfs(int u, int p = -1, int edge = -1)
{
vis[u] = true;
vector<int> temp;
for (auto v2 : g[u])
{
int v = v2.ff, e = v2.ss;
if (v == p) continue;
if (vis[v])
{
if(!used[e])
temp.pb(e);
}
else
{
dfs(v, u, e);
if (used[e]) continue;
else temp.pb(e);
}
}
for (int i = 0; i < si(temp); i += 2)
{
if (i == si(temp) - 1 )
{
if (edge == -1) continue;
ans.pb({ temp[i],edge });
used[temp[i]] = used[edge] = true;
continue;
}
ans.pb({ temp[i],temp[i + 1] });
used[temp[i]] = used[temp[i + 1]] = true;
}
return;
}
void solve()
{
int n;
cin >> n;
vector<node> pts(n);
for (int i = 0; i < n; ++i)
cin >> pts[i].a >> pts[i].b >> pts[i].c >> pts[i].d;
int c = 0;
for (int i = 0; i < n; ++i)
{
pair<ll, ll> m = get_slope(pts[i].a, pts[i].b, pts[i].c, pts[i].d, false);
if (line.find(m) == line.end()) line[m] = c++;
pair<ll, ll> m2 = get_slope(pts[i].a, pts[i].b, pts[i].c, pts[i].d, true);
if (line.find(m2) == line.end()) line[m2] = c++;
}
g = vector<vector<pair<int, int>>>(c);
vis = vector<bool>(c);
used = vector<bool>(n + 1);
for (int i = 0; i < n; ++i)
{
pair<ll, ll> m = get_slope(pts[i].a, pts[i].b, pts[i].c, pts[i].d, false);
pair<ll, ll> m2 = get_slope(pts[i].a, pts[i].b, pts[i].c, pts[i].d, true);
int u = line[m], v = line[m2];
g[u].pb({ v,1 + i });
g[v].pb({ u,1 + i });
}
// the above graph can have multiedges
ans.clear();
for (int i = 0; i < c; ++i)
{
if (vis[i]) continue;
dfs(i);
}
cout << si(ans) << endl;
for (auto a : ans)
{
cout << a.ff << " " << a.ss << endl;
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
//int t; cin >> t; while (t--)
solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void input_array(T arr[], int &n) {
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int test{0};
cin >> test;
while (test--) {
int n{0};
cin >> n;
if (n == 2) {
std::cout << "2\n2 1\n";
} else if (n == 3) {
std::cout << "2\n3 1\n2 2\n";
} else {
std::cout << "2\n";
int proxy{n - 1};
std::cout << n - 2 << " " << n << "\n";
for (int(i) = (n - 1); (i) > (0); (i)--) {
if (i == n - 2) i--;
std::cout << proxy << " " << i << "\n";
proxy = (proxy + i) / 2;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int xx, yy;
double x, y;
point(double x = 0, double y = 0) {
this->x = x;
this->y = y;
}
void init(int xx, int yy) {
this->xx = xx, this->yy = yy;
x = 1.0 / xx;
y = 1.0 / yy;
}
point operator+(const point& a) const { return point(x + a.x, y + a.y); }
point operator-(const point& a) const { return point(x - a.x, y - a.y); }
bool operator==(point& p) { return p.xx == xx && p.yy == yy; }
};
vector<point> a;
vector<point> ch;
vector<point> upper, lower;
double crossProduct(point first, point second, point third) {
return (second.x - first.x) * (third.y - first.y) -
(second.y - first.y) * (third.x - first.x);
}
bool leftLower(point first, point second) {
if (first.x == second.x) return first.y < second.y;
return first.x < second.x;
}
void convexHull() {
if (int((a).size()) <= 3) {
for (int i = (0); i <= (int((a).size()) - 1); i++) ch.push_back(a[i]);
return;
}
sort((a).begin(), (a).end(), leftLower);
upper.push_back(a[0]);
upper.push_back(a[1]);
for (int i = (2); i <= (int((a).size()) - 1); i++) {
upper.push_back(a[i]);
while (int((upper).size()) >= 3 &&
crossProduct(upper[int((upper).size()) - 3],
upper[int((upper).size()) - 2],
upper[int((upper).size()) - 1]) > 1e-22) {
upper.erase(upper.end() - 2);
}
}
for (int i = (0); i <= (int((upper).size()) - 1); i++) ch.push_back(upper[i]);
lower.push_back(a[int((a).size()) - 1]);
lower.push_back(a[int((a).size()) - 2]);
for (int i = (int((a).size()) - 3); i >= (0); i--) {
lower.push_back(a[i]);
while (int((lower).size()) >= 3 &&
crossProduct(lower[int((lower).size()) - 3],
lower[int((lower).size()) - 2],
lower[int((lower).size()) - 1]) > 1e-22) {
lower.erase(lower.end() - 2);
}
}
for (int i = (1); i <= (int((lower).size()) - 2); i++) ch.push_back(lower[i]);
}
map<pair<int, int>, vector<int> > ma;
vector<int> res;
int n;
point leftMost, downMost;
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = (1); i <= (n); i++) {
int a, b;
cin >> a >> b;
ma[pair<int, int>(a, b)].push_back(i);
}
if (int((ma).size()) == 1) {
for (int i = (1); i <= (n); i++) cout << i << " ";
return 0;
}
for (__typeof((ma).begin()) it = (ma).begin(); it != (ma).end(); it++) {
pair<int, int> z = it->first;
point p;
p.init(z.first, z.second);
a.push_back(p);
}
convexHull();
leftMost = downMost = ch[0];
for (int i = (1); i <= (int((ch).size()) - 1); i++)
if (ch[i].x < leftMost.x)
leftMost = ch[i];
else if (leftMost.x == ch[i].x && leftMost.y > ch[i].y)
leftMost = ch[i];
for (int i = (1); i <= (int((ch).size()) - 1); i++)
if (ch[i].y < downMost.y)
downMost = ch[i];
else if (downMost.y == ch[i].y && downMost.x > ch[i].x)
downMost = ch[i];
if (int((ch).size()) == 3) {
if (crossProduct(ch[0], ch[1], ch[2]) > 1e-22)
reverse((ch).begin(), (ch).end());
}
for (int i = (0); i <= (int((ch).size()) - 1); i++)
if (ch[i] == leftMost) {
int u = i;
while (1) {
vector<int> z = ma[pair<int, int>(ch[u].xx, ch[u].yy)];
for (int j = (0); j <= (int((z).size()) - 1); j++) res.push_back(z[j]);
if (ch[u] == downMost) break;
u = (u - 1 + int((ch).size())) % int((ch).size());
}
break;
}
sort((res).begin(), (res).end());
for (int i = (0); i <= (int((res).size()) - 1); i++) cout << res[i] << " ";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
long long sum = 0;
for (int i = 0; i < k; i++) sum += a[i];
cout << sum << '\n';
}
int main() {
ios::sync_with_stdio(NULL);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int n, ne, te[N], sz[N], c[N], f[N];
int fd(int u) { return u == te[u] ? u : te[u] = fd(te[u]); }
vector<int> split(int x) {
vector<int> s;
for (int k = 1; k <= x; k *= 2) {
s.push_back(k), x -= k;
}
if (x) {
s.push_back(x), x = 0;
}
return s;
}
bool check(int x) {
for (; x; x /= 10) {
if (x % 10 != 4 and x % 10 != 7) {
return false;
}
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> ne, f[0] = 0;
for (int x = (1); x < (n + 1); ++x) {
f[x] = N;
}
for (int u = (0); u < (n); ++u) {
te[u] = u, sz[u] = 1;
}
for (int i = (0); i < (ne); ++i) {
int u, v;
cin >> u >> v, u = fd(--u), v = fd(--v);
if (u != v) {
sz[v] += sz[u], te[u] = v;
}
}
for (int u = (0); u < (n); ++u) {
if (fd(u) == u) {
c[sz[u]] += 1;
}
}
for (int x = (1); x < (n + 1); ++x) {
for (const int &y : split(c[x])) {
for (int i = (n + 1 - x * y) - 1; i >= (0); --i) {
f[i + x * y] = min(f[i + x * y], f[i] + y);
}
}
}
int res = N;
for (int x = (1); x < (n + 1); ++x) {
if (check(x)) {
res = min(res, f[x]);
}
}
cout << (res == N ? -1 : res - 1) << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int d[N], head[N], tot;
int to[N * N], nex[N * N], vis[N * N];
vector<pair<int, int> > ans;
void init() {
tot = 0;
memset(d, 0, sizeof(d));
memset(head, -1, sizeof(head));
ans.clear();
}
void add(int u, int v, int w) {
d[v]++;
to[tot] = v;
nex[tot] = head[u];
vis[tot] = w;
head[u] = tot++;
}
void dfs(int x) {
for (int& i = head[x]; ~i;) {
if (vis[i] == 1) {
i = nex[i];
continue;
}
if (vis[i] == 0) ans.push_back(make_pair(x, to[i]));
vis[i] = vis[i ^ 1] = 1;
dfs(to[i]);
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
init();
int n, m, u, v;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
add(u, v, 0);
add(v, u, 0);
}
vector<int> tmp;
int ret = n;
for (int i = 1; i <= n; i++)
if (d[i] & 1) tmp.push_back(i), ret--;
for (int i = 0; i < tmp.size(); i += 2) {
add(tmp[i], tmp[i + 1], -1);
add(tmp[i + 1], tmp[i], -1);
}
for (int i = 1; i <= n; i++) dfs(i);
printf("%d\n", ret);
for (int i = 0; i < ans.size(); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool f = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return f ? -x : x;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
puts("");
}
const int N = 2005, mo = 1e9 + 7, base = 31;
const long long mod = 998244353;
int n, m, f[2][N][N];
long long bin[N];
char s[2][N], T[N];
struct info {
long long sum[N];
void init(int n, char *s, bool d) {
if (!d) {
sum[0] = 0;
for (int i = 1; i <= n; i++)
sum[i] = (sum[i - 1] * base + s[i] - 'a') % mod;
} else {
sum[n + 1] = 0;
for (int i = n; i; i--) sum[i] = (sum[i + 1] * base + s[i] - 'a') % mod;
}
}
long long find(int l, int r, bool d) {
if (!d) return (sum[r] - sum[l - 1] * bin[r - l + 1] % mod + mod) % mod;
return (sum[l] - sum[r + 1] * bin[r - l + 1] % mod + mod) % mod;
}
} sump[2], sumf[2], t;
void add(int &x, int y) {
x += y;
if (x >= mo) x -= mo;
}
int dp(bool d) {
int res = 0;
memset(f, 0, sizeof(f));
for (int j = 1; j <= n; j++) {
f[0][j][0] = f[1][j][0] = 1;
for (int i = 0; i < 2; i++) {
for (int k = 2; k <= min(m / 2, n - j + 1); k++) {
if (t.find(m - 2 * k + 1, m - k, 0) == sump[i].find(j, j + k - 1, 0) &&
t.find(m - k + 1, m, 0) == sumf[i ^ 1].find(j, j + k - 1, 1)) {
if (2 * k != m || d) add(res, f[i][j][m - 2 * k]);
}
}
}
for (int i = 0; i < 2; i++) {
for (int k = 2; k <= min(m / 2, j); k++) {
if (t.find(1, k, 0) == sumf[i ^ 1].find(j - k + 1, j, 1) &&
t.find(k + 1, 2 * k, 0) == sump[i].find(j - k + 1, j, 0)) {
if (2 * k != m || d) add(f[i][j + 1][2 * k], 1);
}
}
}
for (int i = 0; i < 2; i++) {
for (int k = 0; k <= m; k++) {
if (s[i][j] == T[k + 1]) {
add(f[i][j + 1][k + 1], f[i][j][k]);
if (k + 2 <= m && s[i ^ 1][j] == T[k + 2])
add(f[i ^ 1][j + 1][k + 2], f[i][j][k]);
}
}
}
for (int i = 0; i < 2; i++) add(res, f[i][j + 1][m]);
}
return res;
}
int main() {
scanf("%s%s%s", s[0] + 1, s[1] + 1, T + 1);
n = strlen(s[0] + 1);
m = strlen(T + 1);
t.init(m, T, 0);
bin[0] = 1;
for (int i = 1; i <= 2000; i++) bin[i] = bin[i - 1] * base % mod;
for (int i = 0; i < 2; i++)
sump[i].init(n, s[i], 0), sumf[i].init(n, s[i], 1);
int ans = 0;
add(ans, dp(1));
if (m > 1) {
reverse(T + 1, T + m + 1);
t.init(m, T, 0);
add(ans, dp(0));
if (m == 2) {
for (int j = 1; j <= n; j++) {
for (int i = 0; i < 2; i++)
if (s[i][j] == T[1] && s[i ^ 1][j] == T[2]) add(ans, mo - 1);
}
}
}
write(ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long poww(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353ll;
y = y >> 1;
x = (x * x) % 998244353ll;
}
return res;
}
long long p, s, r;
long long fac[100005], inv[100005], num[100005];
long long func(long long, long long, long long),
calc(long long, long long, long long), C(long long, long long);
int main() {
cin >> p >> s >> r;
fac[0] = inv[0] = 1;
for (int i = 1; i < 10005; i++) {
num[i] = poww(i, 998244353ll - 2);
fac[i] = (fac[i - 1] * i) % 998244353ll;
inv[i] = poww(fac[i], 998244353ll - 2);
}
long long ans = 0, div = poww(C(s - r + p - 1, s - r), 998244353ll - 2);
for (int i = r; i < s + 1; i++) {
ans = (ans + func(p, s, i)) % 998244353ll;
}
cout << ((ans * div) % 998244353ll);
}
long long func(long long p, long long s, long long top) {
long long ans = 0;
for (int i = 0; i < p; i++) {
long long rem = s - (i + 1) * top;
long long left = (p - i - 1);
if (rem < 0 || left * (top - 1) < rem) continue;
ans = (ans + num[i + 1] * C(p - 1, i) % 998244353ll * calc(left, rem, top) %
998244353ll) %
998244353ll;
}
return ans;
}
long long calc(long long left, long long rem, long long top) {
long long ans = 0;
long long p = 1;
for (int i = 0; i < rem + 1; i++) {
long long rr = (rem - top * i);
if (rr < 0) break;
ans = ((ans + p * C(left, i) * (rr == 0 ? 1 : C(left - 1 + rr, rr))) %
998244353ll +
998244353ll) %
998244353ll;
p *= -1;
}
return ans;
}
long long C(long long x, long long y) {
return fac[x] * inv[y] % 998244353ll * inv[x - y] % 998244353ll;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 100004;
long long a[N], ans[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) a[i] += a[i - 1];
for (int k = 1; k <= n; ++k) {
int r = n - 1;
long long s = k;
for (int j = 1; r > 0; ++j) {
int l = max(0LL, r - s);
ans[k] += j * (a[r] - a[l]);
r = l;
s *= k;
}
}
int q;
scanf("%d", &q);
while (q--) {
int u;
scanf("%d", &u);
printf("%lld ", ans[min(u, n)]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<long long> h;
int main() {
int n;
cin >> n;
long long sum = 0;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
h.push(-a);
}
int has = 0;
while (h.size() > 1) {
int tmp = h.top();
h.pop();
if (h.top() == tmp) {
h.pop();
h.push(tmp - 1);
} else
has++;
}
cout << -h.top() - has << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int ar[n];
for (int i = 0; i < n; ++i) scanf("%d", &ar[i]);
int sum = 0;
for (int i = 0; i < n; ++i) sum += ar[i];
if (sum % n) {
printf("Unrecoverable configuration.\n");
return 0;
}
int each = sum / n;
for (int i = 0; i < n; ++i) ar[i] -= each;
int s, l, sc = 0, lc = 0;
for (int i = 0; i < n; ++i) {
if (ar[i] < 0) {
s = i;
sc++;
}
if (ar[i] > 0) {
l = i;
lc++;
}
}
if (sc == 0 && lc == 0) {
printf("Exemplary pages.\n");
return 0;
}
if (-1 * ar[s] != ar[l] || !(sc == 1 && lc == 1)) {
printf("Unrecoverable configuration.\n");
return 0;
}
printf("%d ml. from cup #%d to cup #%d.", ar[l], s + 1, l + 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3fll;
const int MAX = 4e5 + 5;
const long long MOD = 1e9 + 7;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline void read(T& num) {
bool start = false, neg = false;
char c;
num = 0;
while ((c = getchar()) != EOF) {
if (c == '-')
start = neg = true;
else if (c >= '0' && c <= '9') {
start = true;
num = num * 10 + c - '0';
} else if (start)
break;
}
if (neg) num = -num;
}
inline long long powMM(long long a, long long b, long long M) {
long long ret = 1;
a %= M;
while (b) {
if (b & 1) ret = ret * a % M;
b >>= 1;
a = a * a % M;
}
return ret;
}
void open() { freopen("out.txt", "w", stdout); }
int k, n, num;
bool pea;
int vi[505], lin[505];
char a[2505][5005];
vector<int> que;
bool st;
int t;
bool check(int who) {
int ge;
bool re = true;
for (int j = 0; j < k && re; j++) {
ge = 0;
if (j == who) continue;
for (int i = 0; i < n; i++) {
if (a[who][i] != a[j][i]) ++ge;
}
re &= (ge == 2 || (ge == 0 && pea));
}
return re;
}
int main() {
scanf("%d%d", &k, &n);
for (int i = 0; i < k; i++) scanf("%s", a[i]);
for (int i = 0; i < n; i++) {
if (vi[a[0][i]]) pea = true;
vi[a[0][i]]++;
}
st = true;
for (int i = 1; i < k && st; i++) {
memset(lin, 0, sizeof(lin));
for (int j = 0; j < n; j++) lin[a[i][j]]++;
for (int t = 'a'; t <= 'z'; t++) {
if (vi[t] != lin[t]) st = false;
}
}
if (!st) return 0 * printf("-1\n");
num = 0;
for (int i = 1; i < k && st; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] != a[0][j]) que.push_back(j);
}
if (que.size() == 0)
continue;
else if (que.size() >= 2 && que.size() <= 6) {
num = que.size();
t = i;
break;
} else
st = false;
que.clear();
}
if (!st) return 0 * printf("-1\n");
if (!num) {
swap(a[0][0], a[0][1]);
if (check(0))
return 0 * printf("%s\n", a[0]);
else
return 0 * printf("-1\n");
}
if (num == 2) {
for (int i = 0; i < num; i++) {
for (int j = 0; j < n; j++) {
if (j == que[i]) continue;
swap(a[0][que[i]], a[0][j]);
if (check(0)) return 0 * printf("%s\n", a[0]);
swap(a[0][que[i]], a[0][j]);
swap(a[t][que[i]], a[t][j]);
if (check(t)) return 0 * printf("%s\n", a[t]);
swap(a[t][que[i]], a[t][j]);
}
}
return 0 * printf("-1\n");
}
for (int i = 0; i < num; i++) {
for (int j = i + 1; j < num; j++) {
swap(a[0][que[i]], a[0][que[j]]);
if (check(0)) return 0 * printf("%s\n", a[0]);
swap(a[0][que[i]], a[0][que[j]]);
swap(a[t][que[i]], a[t][que[j]]);
if (check(t)) return 0 * printf("%s\n", a[t]);
swap(a[t][que[i]], a[t][que[j]]);
}
}
printf("-1\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = 0, c = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '.') break;
n++;
}
if (s[0] == '-') cout << "(";
cout << "$";
for (int i = 0; i < s.size(); i++) {
n--;
if (s[i] == '-') continue;
if (s[i - 1] == '.' || s[i - 2] == '.') {
c++;
}
cout << s[i];
if (c == 2) break;
if (n % 3 == 0 && n > 0) cout << ",";
}
if (c == 0) cout << ".";
for (int i = c; i < 2; i++) cout << 0;
if (s[0] == '-') cout << ")" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int maxn = 1e5 + 10;
using namespace std;
long long quickqow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a;
a *= a;
b >>= 1;
}
return ans;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long euler_phi(long long n) {
long long m = int(sqrt(n + 0.5));
long long ans = n;
for (int i = 2; i <= m; i++) {
if (n % i == 0) {
ans = ans / i * (i - 1);
while (n % i == 0) n /= i;
}
}
if (n > 1) ans = ans / n * (n - 1);
return ans;
}
int main() {
int T;
cin >> T;
while (T--) {
long long a, m;
cin >> a >> m;
long long p = gcd(a, m);
m /= p;
cout << euler_phi(m) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 410000;
int n;
char A[maxn], B[maxn];
int ans[maxn], ansn, L, R, rev;
int main() {
int Tcase;
scanf("%d", &Tcase);
while (Tcase--) {
scanf("%d", &n);
scanf("%s", A + 1);
scanf("%s", B + 1);
ansn = 0;
L = 1, R = n, rev = 0;
for (int i = n; i >= 1; i--) {
if (rev == 0) {
if (A[R] == B[i]) {
R--;
} else {
if (A[L] != B[i]) {
ans[++ansn] = i;
L++;
rev ^= 1;
} else {
ans[++ansn] = 1;
ans[++ansn] = i;
L++;
rev ^= 1;
}
}
} else {
if ((A[L] ^ 1) == B[i]) {
L++;
} else {
if (A[R] == B[i]) {
ans[++ansn] = i;
R--;
rev ^= 1;
} else {
ans[++ansn] = 1;
ans[++ansn] = i;
R--;
rev ^= 1;
}
}
}
}
printf("%d", ansn);
for (int i = 1; i <= ansn; i++) printf(" %d", ans[i]);
puts("");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[30][30];
char s[20];
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> s;
int l = strlen(s);
int str = s[0] - 'a';
int fin = s[l - 1] - 'a';
for (int j = 0; j < 26; j++) {
if (dp[j][str] > 0) {
dp[j][fin] = max(dp[j][fin], dp[j][str] + l);
}
}
dp[str][fin] = max(dp[str][fin], l);
ans = max(ans, dp[fin][fin]);
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char p[200005], s[200005];
int lenp, lens, a[200005];
bool check(int mid) {
set<int> ss(a, a + mid);
int i = 0, j = 0;
while (i < lens && j < lenp) {
while (j < lenp) {
if (ss.count(j + 1)) {
j++;
continue;
}
if (p[j] == s[i]) {
j++;
i++;
break;
}
j++;
}
}
return i == lens;
}
int main() {
scanf("%s%s", p, s);
lenp = strlen(p);
lens = strlen(s);
for (int i = 0; i < lenp; ++i) scanf("%d", &a[i]);
int mid, l = 0, r = lenp + 1;
while (r - l > 1) {
mid = (l + r) >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
printf("%d\n", l);
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <class T>
inline bool cmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
inline bool cmin(T& a, const T& b) {
return a > b ? a = b, 1 : 0;
}
using namespace std;
char ss[1 << 17], *A = ss, *B = ss;
inline char gc() {
return A == B && (B = (A = ss) + fread(ss, 1, 1 << 17, stdin), A == B) ? -1
: *A++;
}
template <class T>
inline void sd(T& x) {
char c;
T y = 1;
while (c = gc(), (c < 48 || 57 < c) && c != -1)
if (c == 45) y = -1;
x = c - 48;
while (c = gc(), 47 < c && c < 58) x = x * 10 + c - 48;
x *= y;
}
const int N = 3e5 + 5, inf = ~0u >> 1;
typedef int arr[N];
int n, ans;
arr a, f, L, R;
inline void sol() {
sd(n);
for (register int i = 1, I = n + 1; i < I; ++i)
L[i] = inf, R[i] = -inf, sd(a[i]);
for (register int i = 1, I = n + 1; i < I; ++i)
cmin(L[a[i]], i), cmax(R[a[i]], i);
sort(a + 1, a + n + 1);
n = unique(a + 1, a + n + 1) - a - 1;
f[n] = 1, ans = n - 1;
for (register int i = n - 1, I = 1 - 1; i > I; --i) {
if (R[a[i]] > L[a[i + 1]])
f[i] = 1;
else
f[i] = f[i + 1] + 1;
cmin(ans, n - f[i]);
}
printf("%d\n", ans);
}
int main() {
int q;
scanf("%d", &q);
while (q--) sol();
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int n;
void op1(int a[]){
for(int i=1;i<2*n;i+=2)
swap(a[i],a[i+1]);
}
void op2(int a[]){
for(int i=1;i<=n;i++)
swap(a[i],a[i+n]);
}
bool check(int a[]){
for(int i=1;i<=2*n;i++)
if(a[i]!=i)
return 0;
return 1;
}
int main()
{
int a[2010];
cin>>n;
for(int i=1;i<=2*n;i++)
cin>>a[i];
if(n%2==0)
for(int i=1;i<=4;i++)
{
if(i%2==1)
op1(a);
else
op2(a);
if(check(a))
{
cout<<min(i,4-i)<<endl;
return 0;
}
}
else
for(int i=1;i<=2*n;i++)
{
if(i%2==1)
op1(a);
else
op2(a);
if(check(a))
{
cout<<min(i,2*n-i)<<endl;
return 0;
}
}
cout<<-1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1e5 + 10;
pair<int, long long> ans = {-1, -1};
long long cube(int x) { return 1LL * x * x * x; }
void solve(long long m, int steps, long long sub) {
if (m == 0) {
ans = max(ans, {steps, sub});
return;
}
int x = 0;
while (cube(x) <= m) x++;
x--;
solve(m - cube(x), steps + 1, sub + cube(x));
if (x - 1 >= 1)
solve(cube(x) - 1 - cube(x - 1), steps + 1, sub + cube(x - 1));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long m;
cin >> m;
solve(m, 0, 0);
cout << ans.first << " " << ans.second;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
vector<pair<int, int>> seg(m);
vector<set<int>> was(n + 1);
for (int i = 0; i < m; ++i) {
cin >> seg[i].first >> seg[i].second;
if (seg[i].first > seg[i].second) {
swap(seg[i].first, seg[i].second);
}
was[seg[i].first].insert(seg[i].second);
}
auto check = [&](int k) {
int cnt = 0;
for (int i = 0; i < m; ++i) {
int l = seg[i].first + k, r = seg[i].second + k;
if (l > n) {
l -= n;
}
if (r > n) {
r -= n;
}
if (l > r) {
swap(l, r);
}
cnt += (was[l].find(r) != was[l].end());
}
return cnt == m;
};
for (int k = 1; k * k <= n; ++k) {
if (k == 1) {
if (check(1)) {
cout << "Yes";
return 0;
}
} else if (n % k == 0) {
if (check(k)) {
cout << "Yes";
return 0;
} else if (check(n / k)) {
cout << "Yes";
return 0;
}
}
}
cout << "No";
return 0;
}
| 5 |
#include <bits/stdc++.h>
char s[100010];
int main() {
int i, j, k, l, m, n, p, q, y, z;
scanf("%s", s);
m = strlen(s);
if (m % 2 == 1) {
for (i = 0; i < (m + 1) / 2; i++) printf("4");
for (i = 0; i < (m + 1) / 2; i++) printf("7");
printf("\n");
return 0;
}
if (s[0] == '1' || s[0] == '2' || s[0] == '3') {
for (i = 0; i < m / 2; i++) printf("4");
for (i = 0; i < m / 2; i++) printf("7");
printf("\n");
return 0;
}
if (s[0] == '8' || s[0] == '9') {
for (i = 0; i <= m / 2; i++) printf("4");
for (i = 0; i <= m / 2; i++) printf("7");
printf("\n");
return 0;
}
if (s[0] == '5' || s[0] == '6') {
printf("7");
for (i = 0; i < m / 2; i++) printf("4");
for (i = 0; i < m / 2 - 1; i++) printf("7");
printf("\n");
return 0;
}
if (s[0] == '4') {
j = 0;
k = 0;
l = 0, p = 0, q = 0;
for (i = 0; i < m; i++) {
if (s[i] == '4')
k++;
else if (s[i] == '7')
l++;
else if (s[i] == '0' || s[i] == '1' || s[i] == '2' || s[i] == '3') {
j = 1;
p = i;
break;
} else if (s[i] == '5' || s[i] == '6') {
j = 2;
p = i;
break;
} else {
j = 3;
p = i;
break;
}
if (k == m / 2 || l == m / 2) {
p = i;
break;
}
}
if (j == 1) {
for (i = 0; i < p; i++) printf("%c", s[i]);
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l; i++) printf("7");
printf("\n");
return 0;
} else if (j == 2) {
for (i = 0; i < p; i++) printf("%c", s[i]);
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
} else if (j == 3) {
if (k == 1) {
printf("7");
for (i = 0; i < m / 2; i++) printf("4");
for (i = 0; i < m / 2 - 1; i++) printf("7");
printf("\n");
return 0;
} else {
for (z = p - 1; z; z--)
if (s[z] == '4') break;
k = 0;
l = 0;
for (i = 0; i < z; i++) {
if (s[i] == '4') k++;
if (s[i] == '7') l++;
printf("%c", s[i]);
}
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
}
} else {
if (k == m / 2) {
y = 0;
for (i = p + 1; i < m; i++) {
if (s[i] < '7') break;
if (s[i] > '7') {
y = 1;
break;
}
}
if (y == 0) {
for (i = 0; i <= p; i++) printf("%c", s[i]);
for (i = p + 1; i < m; i++) printf("7");
printf("\n");
return 0;
} else {
for (i = 0; i < p; i++) printf("%c", s[i]);
printf("7");
printf("4");
for (i = p + 2; i < m; i++) printf("7");
printf("\n");
return 0;
}
} else {
y = 0;
for (i = p + 1; i < m; i++) {
if (s[i] < '4') break;
if (s[i] > '4') {
y = 1;
break;
}
}
if (y == 0) {
for (i = 0; i <= p; i++) printf("%c", s[i]);
for (i = p + 1; i < m; i++) printf("4");
printf("\n");
return 0;
} else {
if (k == 1) {
printf("7");
for (i = 0; i < m / 2; i++) printf("4");
for (i = 0; i < m / 2 - 1; i++) printf("7");
printf("\n");
return 0;
} else {
for (z = p - 1; z; z--)
if (s[z] == '4') break;
k = 0, l = 0;
for (i = 0; i < z; i++) {
if (s[i] == '4') k++;
if (s[i] == '7') l++;
printf("%c", s[i]);
}
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
}
}
}
}
} else {
j = 0;
k = 0;
l = 0, p = 0, q = 0;
for (i = 0; i < m; i++) {
if (s[i] == '4')
k++;
else if (s[i] == '7')
l++;
else if (s[i] == '0' || s[i] == '1' || s[i] == '2' || s[i] == '3') {
j = 1;
p = i;
break;
} else if (s[i] == '5' || s[i] == '6') {
j = 2;
p = i;
break;
} else {
j = 3;
p = i;
break;
}
if (k == m / 2 || l == m / 2) {
p = i;
break;
}
}
if (j == 1) {
for (i = 0; i < p; i++) printf("%c", s[i]);
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l; i++) printf("7");
printf("\n");
return 0;
} else if (j == 2) {
for (i = 0; i < p; i++) printf("%c", s[i]);
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
} else if (j == 3) {
if (k == 0) {
for (i = 0; i <= m / 2; i++) printf("4");
for (i = 0; i <= m / 2; i++) printf("7");
printf("\n");
return 0;
} else {
for (z = p - 1; z; z--)
if (s[z] == '4') break;
k = 0;
l = 0;
for (i = 0; i < z; i++) {
if (s[i] == '4') k++;
if (s[i] == '7') l++;
printf("%c", s[i]);
}
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
}
} else {
if (k == m / 2) {
y = 0;
for (i = p + 1; i < m; i++) {
if (s[i] < '7') break;
if (s[i] > '7') {
y = 1;
break;
}
}
if (y == 0) {
for (i = 0; i <= p; i++) printf("%c", s[i]);
for (i = p + 1; i < m; i++) printf("7");
printf("\n");
return 0;
} else {
for (i = 0; i < p; i++) printf("%c", s[i]);
printf("7");
printf("4");
for (i = p + 2; i < m; i++) printf("7");
printf("\n");
return 0;
}
} else {
y = 0;
for (i = p + 1; i < m; i++) {
if (s[i] < '4') break;
if (s[i] > '4') {
y = 1;
break;
}
}
if (y == 0) {
for (i = 0; i <= p; i++) printf("%c", s[i]);
for (i = p + 1; i < m; i++) printf("4");
printf("\n");
return 0;
} else {
if (k == 0) {
for (i = 0; i <= m / 2; i++) printf("4");
for (i = 0; i <= m / 2; i++) printf("7");
printf("\n");
return 0;
} else {
for (z = p - 1; z; z--)
if (s[z] == '4') break;
k = 0, l = 0;
for (i = 0; i < z; i++) {
if (s[i] == '4') k++;
if (s[i] == '7') l++;
printf("%c", s[i]);
}
printf("7");
for (i = 0; i < m / 2 - k; i++) printf("4");
for (i = 0; i < m / 2 - l - 1; i++) printf("7");
printf("\n");
return 0;
}
}
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const long long INF = 1e18;
template <typename T1, typename T2>
inline bool chmin(T1& a, T2 b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool chmax(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
T pow(T a, int b) {
return b ? pow(a * a, b / 2) * (b % 2 ? a : 1) : 1;
}
const int mod = 1000000007;
long long modpow(long long a, int b) {
return b ? modpow(a * a % mod, b / 2) * (b % 2 ? a : 1) % mod : 1;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < ((int)v.size()); ++i) {
if (i) os << " ";
os << v[i];
}
return os;
}
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << p.first << " " << p.second;
return os;
}
template <class T>
inline void add(T& a, int b) {
a += b;
if (a >= mod) a - mod;
}
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T;
T = 1;
while (T--) {
solve();
}
}
void solve() {
int n;
cin >> n;
string s;
cin >> s;
string t = s;
vector<int> col(n, -1);
for (int i = 0; i < (n); ++i) {
char c = s[i];
int now = i;
for (int j = i + 1; j < (n); ++j)
if (chmin(c, s[j])) now = j;
for (int j = now - 1; j >= i; --j) swap(s[j], s[j + 1]);
if (col[now] != -1) {
for (int j = i; j < (now); ++j)
if (col[j] == col[now]) {
cout << "NO" << endl;
return;
}
col[i] = col[now];
for (int j = i + 1; j < (now + 1); ++j) col[j] = col[i] ^ 1;
} else {
int o = 0, z = 0;
for (int j = i; j < (now); ++j) {
if (col[j] == 0)
z++;
else if (col[j] == 1)
o++;
}
if (o && z) {
cout << "NO" << endl;
return;
}
col[i] = o ? 0 : 1;
for (int j = i + 1; j < (now + 1); ++j) {
col[j] = col[i] ^ 1;
}
}
}
cout << "YES" << endl;
vector<int> used(n);
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (n); ++j) {
if (t[i] != s[j] || used[j]) continue;
used[j] = 1;
cout << col[j];
break;
}
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int p[200200], h[200200], friends[200200];
int good[200200], flag;
vector<int> g[200200];
void dfs(int v, int pred = -1) {
friends[v] = p[v];
int sumg = 0;
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (to == pred) continue;
dfs(to, v);
friends[v] += friends[to];
sumg += good[to];
}
if ((friends[v] + h[v]) % 2) flag = 0;
good[v] = (friends[v] + h[v]) / 2;
if (good[v] < 0 || good[v] > friends[v]) flag = 0;
if (good[v] < sumg) flag = 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> p[i];
g[i].clear();
}
for (int i = 0; i < n; i++) {
cin >> h[i];
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
flag = 1;
dfs(0);
flag ? cout << "YES\n" : cout << "NO\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
for (; t > 0; --t) {
int n, p;
scanf("%d %d", &n, &p);
int cnt = 2 * n + p;
for (int i = 1; i < n && cnt > 0; ++i) {
for (int j = i + 1; j <= n && cnt > 0; ++j) {
printf("%d %d\n", i, j);
--cnt;
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
inline void MAXR(int &a, int b) {
if (a < b) a = b;
}
using namespace std;
int main() {
double a, d, x, y, dist = 0;
int n, cnt = 0;
cin >> a >> d;
n = ({
int x;
scanf("%d", &x);
x;
});
for (int(i) = (0); i < n; i++) {
dist += d;
int quot = dist / a;
if (quot > 0) dist -= quot * a, cnt += quot;
cnt %= 4;
if (cnt == 0) {
y = 0;
x = dist;
} else if (cnt == 1) {
y = dist;
x = a;
} else if (cnt == 2) {
y = a;
x = a - dist;
} else if (cnt == 3) {
y = a - dist;
x = 0;
}
if (x < 0) x += a;
if (y < 0) y += a;
printf("%0.10lf %0.10lf\n", x, y);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f(1);
char c(getchar());
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c - '0');
x *= f;
}
template <typename T>
void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x / 10) write(x / 10), x %= 10;
putchar(x + '0');
}
const int maxn = 84, saxn = 6405;
struct Edge {
int v, w, f, nt;
} e[saxn * 6];
int num, hd[saxn];
void add_edge(int u, int v, int w, int f) {
++num, e[num].v = v, e[num].w = w, e[num].f = f, e[num].nt = hd[u],
hd[u] = num;
}
void add(int u, int v, int w, int f) {
add_edge(u, v, w, f);
add_edge(v, u, 0, -f);
}
int S, T, q[saxn], dis[saxn], flow[saxn], last[saxn], pre[saxn], in[saxn];
int spfa(void) {
memset(dis, 0x3f, sizeof dis);
flow[T] = 0;
flow[S] = 0x3f3f3f3f;
int fro = 0, bac = 0;
in[q[bac++] = S] = true;
dis[S] = 0;
while (fro != bac) {
int u = q[fro++];
in[u] = false;
if (fro == saxn) fro = 0;
for (int i = hd[u]; i; i = e[i].nt) {
int v = e[i].v;
if (e[i].w && dis[v] > dis[u] + e[i].f) {
dis[v] = dis[u] + e[i].f;
flow[v] = min(flow[u], e[i].w);
last[v] = i;
pre[v] = u;
if (!in[v]) {
q[bac++] = v;
in[v] = true;
if (bac == saxn) bac = 0;
}
}
}
}
return flow[T];
}
void solve(void) {
int maxflow = 0, mincost = 0;
while (spfa()) {
maxflow += flow[T];
mincost += flow[T] * dis[T];
int now = T;
while (now != S) {
e[last[now]].w -= flow[T];
e[(last[now] - 1 ^ 1) + 1].w += flow[T];
now = pre[now];
}
}
write(mincost), putchar('\n');
}
int txt[maxn][maxn];
const int di[4] = {0, 0, 1, -1}, dj[4] = {1, -1, 0, 0};
int main() {
int n, m;
read(n), read(m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) read(txt[i][j]);
S = n * m + 1;
T = S + 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int no = j + (i - 1) * m;
if (i + j & 1) {
for (int t = 0; t < 4; ++t) {
int ti = i + di[t], tj = j + dj[t], to = tj + (ti - 1) * m;
if (ti >= 1 && ti <= n && tj >= 1 && tj <= m) {
add(no, to, 1, txt[ti][tj] != txt[i][j]);
}
}
add(S, no, 1, 0);
} else
add(no, T, 1, 0);
}
}
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100005], b[100005], c[100005], last[100005], tot;
int check(int k) {
for (int i = 1; i <= k; i++) last[a[b[i]]] = b[i];
int Free = 0;
int num = 0;
for (int i = 1; i <= b[k]; i++) {
if (!a[i] || last[a[i]] != i)
Free++;
else {
Free -= c[a[i]];
num++;
}
if (Free < 0) return 0;
}
if (num == m) return 1;
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i]) b[++tot] = i;
}
for (int i = 1; i <= m; i++) scanf("%d", &c[i]);
int l = 0, r = tot + 1;
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
if (r == tot + 1)
printf("-1");
else
printf("%d", b[r]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, nest, num, count = 0, currNest = 0;
cin >> n;
nest = 1;
num = n;
while (count <= n) {
for (int i = 0; i < (num - nest + 1); i++) {
if (i == currNest) {
for (int j = 0; j < nest; j++) {
cout << "(";
}
for (int k = 0; k < nest; k++) {
cout << ")";
}
} else {
cout << "()";
}
}
nest++;
cout << endl;
count++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int c = 220000;
int main() {
int a[300], k;
string second;
cin >> k >> second;
memset(a, 0, sizeof(a));
for (int i = 0; i < second.size(); i++) a[second[i] - 'a']++;
bool p = 1;
for (int i = 0; i <= 'z' - 'a'; i++)
if (a[i] % k != 0) p = 0;
if (p)
for (int i = 0; i < k; i++)
for (int j = 0; j <= 'z' - 'a'; j++)
for (int u = 0; u < a[j] / k; u++) cout << char('a' + j);
else
cout << -1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, h, m, sum, H, M;
scanf("%d:%d", &h, &m);
scanf("%d", &a);
sum = h * 60 + m + a;
sum %= 1440;
M = sum % 60;
sum /= 60;
H = sum;
if (H < 10)
printf("0%d:", H);
else
printf("%d:", H);
if (M < 10)
printf("0%d", M);
else
printf("%d", M);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char k[10000];
int kr[10000], kn[10000];
int u, f, m;
cin.getline(k, 256);
for (int a = 0; a < strlen(k); a++) {
f = 128;
kr[a] = 0;
kn[a] = int(k[a]);
for (int b = 1; b <= 8; b++) {
kr[a] += (kn[a] / f) * (128 / f);
kn[a] = kn[a] % f;
f = f / 2;
}
}
m = (0 - kr[0]) % 256;
if (m < 0) m = 256 - (-1 * m);
cout << m << endl;
for (int a = 1; a < strlen(k); a++) {
m = (kr[a - 1] - kr[a]) % 256;
if (m < 0) m = 256 - (-1 * m);
cout << m << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long freq1[N], freq2[N];
vector<long double> val;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
long double m100[65], p100[65];
for (int i = 0; i < n; ++i) {
cin >> m100[i];
}
for (int i = 0; i < m; ++i) {
cin >> p100[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
long double tmp = (m100[i] - p100[j]) / 2 + p100[j];
int flag = 0;
for (int k = 0; k < val.size(); ++k) {
if (abs(val[k] - tmp) < 1e-9) {
freq1[k] |= (1LL << i);
freq2[k] |= (1LL << j);
flag = 1;
}
}
if (flag == 0) {
val.push_back(tmp);
freq1[val.size() - 1] |= (1LL << i);
freq2[val.size() - 1] |= (1LL << j);
}
}
}
int ans = -1;
for (int i = 0; i < val.size(); ++i) {
for (int j = i; j < val.size(); ++j) {
ans = max(ans, __builtin_popcountll(freq1[i] | freq1[j]) +
__builtin_popcountll(freq2[i] | freq2[j]));
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
while (t--) {
long long int i, y, h, j, k, r, l, n, m, x, o, cnt1 = INT_MAX, cnt2 = 0,
cnt3 = 0, cnt4 = 0;
cin >> n;
long long int a[n], b[200005] = {0};
long long int c[n], d[n];
for (i = 0; i < n; i++) {
cin >> a[i];
b[a[i]]++;
cnt2 = max(cnt2, a[i]);
}
for (i = 0; i <= cnt2; i++) {
if (b[i] > 2) {
cout << "NO\n";
return 0;
}
}
j = 0, k = 0;
for (i = 0; i <= cnt2; i++) {
if (b[i] == 2) {
b[i]--;
c[j++] = i;
}
}
for (i = 0; i <= cnt2; i++) {
if (b[i] == 1) {
b[i]--;
d[k++] = i;
}
}
cout << "YES\n";
cout << j << endl;
sort(c, c + j);
sort(d, d + k, greater<long long int>());
for (i = 0; i < j; i++) cout << c[i] << " ";
cout << endl;
cout << k << endl;
for (i = 0; i < k; i++) cout << d[i] << " ";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, M, L, K, to[110][30], dp[110][110][110], pi[110];
char s1[110], s2[110], virus[110], ans[110];
void calc_pi() {
int i, j, q = 0;
for (i = 2, pi[1] = 0; i <= L; i++) {
while (q && virus[q + 1] != virus[i]) q = pi[q];
if (virus[q + 1] == virus[i]) q++;
pi[i] = q;
}
for (i = 0; i < L; i++)
for (j = 0; j < 26; j++) {
q = i;
while (q && virus[q + 1] - 'A' != j) q = pi[q];
if (virus[q + 1] - 'A' == j) q++;
to[i][j] = q;
}
}
int main() {
cin >> (s1 + 1);
cin >> (s2 + 1);
cin >> (virus + 1);
s1[0] = s2[0] = virus[0] = '.';
N = strlen(s1) - 1, M = strlen(s2) - 1, L = strlen(virus) - 1;
calc_pi();
int i, j, k;
for (i = N; i > 0; i--)
for (j = M; j > 0; j--)
for (k = 0; k < L; k++) {
dp[i][j][k] = max(dp[i + 1][j][k], dp[i][j + 1][k]);
if (s1[i] == s2[j] && to[k][s1[i] - 'A'] != L)
dp[i][j][k] =
max(dp[i][j][k], 1 + dp[i + 1][j + 1][to[k][s1[i] - 'A']]);
}
i = 1, j = 1, k = 0;
int cr = dp[1][1][0];
while (i <= N && j <= M) {
if (dp[i + 1][j][k] == cr)
i++;
else if (dp[i][j + 1][k] == cr)
j++;
else {
k = to[k][s1[i] - 'A'];
ans[++K] = s1[i];
i++, j++;
cr = dp[i][j][k];
}
}
for (i = 1; i <= K; i++) cout << ans[i];
if (K == 0) cout << 0;
cout << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
char ch;
int fu = 1;
while ((ch = getchar()) <= 32)
;
x = 0;
if (ch == '-')
fu = -1;
else
x = ch - 48;
while ((ch = getchar()) > 32) x = x * 10 + ch - 48;
x *= fu;
}
const double pi = acos(-1);
const int N = 4020, p = 1000000007;
struct point {
int x, y, d, id, kd;
double beta;
};
vector<point> a;
int n, m, cas;
int cmp(point &p, point &q) { return p.beta < q.beta; }
void solve(vector<point> &a) {
int mx = -1, mxi = 0;
int r = a.size() - 1;
for (int i = 0; i <= r; i++)
if (a[i].d > mx) mx = a[i].d, mxi = i;
if (mx == 1) {
for (int i = 0; i <= r; i++)
if (a[i].d == 0) {
swap(a[i], a[0]);
break;
}
assert(a[0].d == 0);
for (int i = 1; i <= r; i++) {
assert(a[i].d == 1);
printf("%d %d\n", a[i].id, a[0].id);
}
return;
}
swap(a[0], a[mxi]);
point stdd = a[0];
int now = 0;
for (int i = 1; i <= r; i++) {
a[i].beta = atan2(a[i].y - stdd.y, a[i].x - stdd.x);
if (a[i].beta > 0)
now += a[i].d - 1, a[i].kd = 0, a[i].beta -= pi;
else
a[i].kd = 1;
}
a[0].beta = -1234;
sort(a.begin(), a.end(), cmp);
int i;
for (i = 0; i <= r;) {
if (now <= -1 && now >= 1 - mx) break;
i++;
if (a[i].kd)
now += a[i].d - 1;
else
now -= a[i].d - 1;
}
assert(now <= -1 && now >= 1 - mx);
vector<point> pl, pr;
stdd.d = -now;
pl.push_back(stdd);
stdd.d = now + mx;
pr.push_back(stdd);
for (int j = 1; j <= r; j++)
if (j <= i && a[j].kd == 1)
pl.push_back(a[j]);
else if (j > i && a[j].kd == 0)
pl.push_back(a[j]);
else
pr.push_back(a[j]);
a.clear();
solve(pl);
solve(pr);
}
int main() {
scanf("%d", &cas);
for (int ii = 1; ii <= cas; ii++) {
scanf("%d%d", &n, &m);
a.clear();
a.resize(n + m);
for (int i = 0; i < m; i++) read(a[i].d);
for (int i = m; i < m + n; i++) {
read(a[i].x), read(a[i].y);
a[i].id = i - m + 1;
a[i].d = 0;
}
for (int i = 0; i < m; i++) {
read(a[i].x), read(a[i].y);
a[i].id = i + 1;
}
printf("YES\n");
solve(a);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
long long choose(int n, int k) {
return k == 0 ? 1 : choose(n - 1, k - 1) * n / k;
}
int main() {
int n;
long long cnt3, cnt5;
scanf("%d", &n);
cnt3 = choose(n, 1) * 1;
cnt3 += n < 2 ? 0 : choose(n, 2) * choose(2, 1);
cnt3 += n < 3 ? 0 : choose(n, 3);
cnt5 = choose(n, 1) * 1;
cnt5 += n < 2 ? 0 : choose(n, 2) * (choose(2, 1) + choose(2, 1));
cnt5 += n < 3 ? 0 : choose(n, 3) * (choose(3, 1) + choose(3, 2));
cnt5 += n < 4 ? 0 : choose(n, 4) * choose(4, 1);
cnt5 += n < 5 ? 0 : choose(n, 5);
printf("%lld\n", cnt3 * cnt5);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class DisjointSet {
public:
vector<int> parent;
DisjointSet(int n) : parent(n) {
for (int i = 0; i < n; i++) parent[i] = i;
}
void join(int a, int b) { parent[find(b)] = find(a); }
int find(int a) { return a == parent[a] ? a : parent[a] = find(parent[a]); }
bool check(int a, int b) { return find(a) == find(b); }
};
DisjointSet d(300001);
bool v[300001] = {0}, v1[300001] = {0}, v2[300001] = {0};
vector<int> ad[300001], ad1[300001], ad2[300001], ad11[300001];
vector<int> vc;
int di = 0;
void dfs(int no, int gh) {
v[no] = 1;
for (int i = 0; i < ad[no].size(); i++) {
if (ad[no][i] != gh) {
ad11[no].push_back(ad[no][i]);
}
if (v[ad[no][i]] == 0) {
dfs(ad[no][i], no);
}
}
vc.push_back(no);
}
void dfs1(int no) {
v1[no] = 1;
for (int i = 0; i < ad1[no].size(); i++) {
if (v1[ad1[no][i]] == 1) {
ad2[d.find(no)].push_back(d.find(ad1[no][i]));
ad2[d.find(ad1[no][i])].push_back(d.find(no));
} else {
d.join(no, ad1[no][i]);
dfs1(ad1[no][i]);
}
}
}
int dfs2(int no) {
v2[no] = 1;
int ma = 0;
int t, ma1 = 0, ma2 = 0, c1 = 0;
for (int i = 0; i < ad2[no].size(); i++) {
if (v2[ad2[no][i]] == 0) {
t = dfs2(ad2[no][i]);
c1++;
if (t > ma1) {
ma2 = ma1;
ma1 = t;
} else if (t > ma2) {
ma2 = t;
}
}
}
if (ma1 > di) {
di = ma1;
}
if (ma2 > di) {
di = ma2;
}
if (ma1 + ma2 > di && ma1 > 0 && ma2 > 0) {
di = ma1 + ma2;
}
return max(ma1 + 1, ma2 + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, t1, t2;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> t1 >> t2;
ad[t1].push_back(t2);
ad[t2].push_back(t1);
}
dfs(1, 0);
for (int i = 0; i < n + 1; i++) {
for (int j = 0; j < ad11[i].size(); j++) {
ad1[ad11[i][j]].push_back(i);
}
}
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < ad1[i].size(); j++) {
}
}
for (int i = vc.size() - 1; i >= 0; i--) {
if (v1[vc[i]] == 0) {
dfs1(vc[i]);
}
}
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < ad2[i].size(); j++) {
}
}
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < ad2[i].size(); j++) {
if (d.find(ad2[i][j]) != ad2[i][j]) {
ad2[i][j] = d.find(ad2[i][j]);
}
}
}
for (int i = 1; i < n + 1; i++) {
if (i != d.find(i)) {
for (int j = 0; j < ad2[i].size(); j++) {
ad2[d.find(i)].push_back(ad2[i][j]);
}
ad2[i].clear();
}
}
dfs2(d.find(1));
cout << di << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long w, h, n;
set<long long> px, py;
multiset<long long> lx, ly;
multiset<long long>::iterator it;
int main() {
cin >> w >> h >> n;
px.insert(0), px.insert(w);
py.insert(0), py.insert(h);
lx.insert(w), ly.insert(h);
for (int i = 1; i <= n; ++i) {
char op;
long long p;
cin >> op >> p;
if (op == 'H') {
py.insert(p);
it = py.find(p);
it--;
long long l = *it;
it++, it++;
long long r = *it;
it = ly.find(r - l);
ly.erase(it);
ly.insert(r - p), ly.insert(p - l);
} else {
px.insert(p);
it = px.find(p);
it--;
long long l = *it;
it++, it++;
long long r = *it;
it = lx.find(r - l);
lx.erase(it);
lx.insert(r - p), lx.insert(p - l);
}
it = lx.end();
it--;
long long x = *it;
it = ly.end();
it--;
long long y = *it;
cout << x * y << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
double x, y, v, a, b, k = 10000;
cin >> a >> b >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y >> v;
k = min(k, sqrt((x - a) * (x - a) + (y - b) * (y - b)) / v);
}
printf("%.7f", k);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
int cnt = 0;
int a = 0;
while (n--) {
string x;
cin >> x;
for (int i = 0; i < x.size(); i++) {
if (x[i] == '4' || x[i] == '7') a++;
}
if (a <= k) cnt++;
a = 0;
}
cout << cnt << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
const int mod = 998244353;
int n;
int p[N];
namespace fft {
struct num {
double x, y;
num() { x = y = 0; }
num(double x, double y) : x(x), y(y) {}
};
inline num operator+(num a, num b) { return num(a.x + b.x, a.y + b.y); }
inline num operator-(num a, num b) { return num(a.x - b.x, a.y - b.y); }
inline num operator*(num a, num b) {
return num(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
}
inline num conj(num a) { return num(a.x, -a.y); }
int base = 1;
vector<num> roots = {{0, 0}, {1, 0}};
vector<int> rev = {0, 1};
const double PI = acosl(-1.0);
void ensure_base(int nbase) {
if (nbase <= base) return;
rev.resize(1 << nbase);
for (int i = 0; i < (1 << nbase); i++)
rev[i] = (rev[i >> 1] >> 1) + ((i & 1) << (nbase - 1));
roots.resize(1 << nbase);
while (base < nbase) {
double angle = 2 * PI / (1 << (base + 1));
for (int i = 1 << (base - 1); i < (1 << base); i++) {
roots[i << 1] = roots[i];
double angle_i = angle * (2 * i + 1 - (1 << base));
roots[(i << 1) + 1] = num(cos(angle_i), sin(angle_i));
}
base++;
}
}
void fft(vector<num> &a, int n = -1) {
if (n == -1) n = a.size();
assert((n & (n - 1)) == 0);
int zeros = __builtin_ctz(n);
ensure_base(zeros);
int shift = base - zeros;
for (int i = 0; i < n; i++)
if (i < (rev[i] >> shift)) swap(a[i], a[rev[i] >> shift]);
for (int k = 1; k < n; k <<= 1) {
for (int i = 0; i < n; i += 2 * k) {
for (int j = 0; j < k; j++) {
num z = a[i + j + k] * roots[j + k];
a[i + j + k] = a[i + j] - z;
a[i + j] = a[i + j] + z;
}
}
}
}
vector<num> fa, fb;
vector<int> multiply_mod(vector<int> &a, vector<int> &b, int m, int eq = 0) {
int need = a.size() + b.size() - 1;
int nbase = 0;
while ((1 << nbase) < need) nbase++;
ensure_base(nbase);
int sz = 1 << nbase;
if (sz > (int)fa.size()) fa.resize(sz);
for (int i = 0; i < (int)a.size(); i++) {
int x = (a[i] % m + m) % m;
fa[i] = num(x & ((1 << 15) - 1), x >> 15);
}
fill(fa.begin() + a.size(), fa.begin() + sz, num{0, 0});
fft(fa, sz);
if (sz > (int)fb.size()) fb.resize(sz);
if (eq)
copy(fa.begin(), fa.begin() + sz, fb.begin());
else {
for (int i = 0; i < (int)b.size(); i++) {
int x = (b[i] % m + m) % m;
fb[i] = num(x & ((1 << 15) - 1), x >> 15);
}
fill(fb.begin() + b.size(), fb.begin() + sz, num{0, 0});
fft(fb, sz);
}
double ratio = 0.25 / sz;
num r2(0, -1), r3(ratio, 0), r4(0, -ratio), r5(0, 1);
for (int i = 0; i <= (sz >> 1); i++) {
int j = (sz - i) & (sz - 1);
num a1 = (fa[i] + conj(fa[j]));
num a2 = (fa[i] - conj(fa[j])) * r2;
num b1 = (fb[i] + conj(fb[j])) * r3;
num b2 = (fb[i] - conj(fb[j])) * r4;
if (i != j) {
num c1 = (fa[j] + conj(fa[i]));
num c2 = (fa[j] - conj(fa[i])) * r2;
num d1 = (fb[j] + conj(fb[i])) * r3;
num d2 = (fb[j] - conj(fb[i])) * r4;
fa[i] = c1 * d1 + c2 * d2 * r5;
fb[i] = c1 * d2 + c2 * d1;
}
fa[j] = a1 * b1 + a2 * b2 * r5;
fb[j] = a1 * b2 + a2 * b1;
}
fft(fa, sz);
fft(fb, sz);
vector<int> res(need);
for (int i = 0; i < need; i++) {
long long aa = fa[i].x + 0.5;
long long bb = fb[i].x + 0.5;
long long cc = fa[i].y + 0.5;
res[i] = (aa + ((bb % m) << 15) + ((cc % m) << 30)) % m;
}
return res;
}
}; // namespace fft
struct pol {
vector<int> a;
pol() {}
pol(const pol &oth) { a = oth.a; }
bool operator<(const pol &oth) const { return a.size() <= oth.a.size(); }
};
set<pol> st;
int main() {
cin >> n;
map<int, int> rep;
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
rep[p[i]]++;
}
for (map<int, int>::iterator it = rep.begin(); it != rep.end(); it++) {
int sz = it->second;
pol temp;
for (int i = 0; i <= sz; i++) {
temp.a.push_back(1);
}
st.insert(temp);
}
while (st.size() > 1) {
pol x = *st.begin();
st.erase(st.begin());
pol y = *st.begin();
st.erase(st.begin());
x.a = fft::multiply_mod(x.a, y.a, mod);
st.insert(x);
}
long long res = 0;
pol x = *st.begin();
if (x.a.size() > n / 2) res = x.a[n / 2];
cout << res << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
int main() {
int n, m, po;
long long a[100];
long long b[100];
long long maxn = -INF, maxx = -INF;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (a[i] * b[j] > maxn) {
po = i;
maxn = a[i] * b[j];
}
}
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) {
if (b[i] * a[j] > maxx && j != po) {
maxx = b[i] * a[j];
}
}
cout << maxx << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tc = 1;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, x;
long long ans = -1;
while (tc--) {
cin >> n >> x;
vector<long long> a(2 * n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
a[i + n] = a[i];
}
n *= 2;
vector<long long> b = {0}, c = {0};
for (long long i = 0; i < n; i++) {
b.push_back(b.back() + a[i]);
}
for (long long i = 0; i < n; i++) {
c.push_back(c.back() + ((a[i] + 1) * a[i]) / 2);
}
for (long long i = 0; i < n; i++) {
if (b[i + 1] >= x) {
long long z = upper_bound(b.begin(), b.end(), b[i + 1] - x) - b.begin();
long long cnt = c[i + 1] - c[z];
long long days = b[i + 1] - b[z];
long long too = x - days;
cnt += ((a[z - 1] * (a[z - 1] + 1)) / 2);
cnt -= (((a[z - 1] - too) * (a[z - 1] + 1 - too)) / 2);
ans = max(ans, cnt);
}
}
cout << ans << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5, mod = 1e9 + 7;
long long pow_mod(long long a, long long b);
char p[maxn];
int pos[maxn], Next[maxn], mark[maxn];
int main() {
int n, m, len;
scanf("%d %d %s", &n, &m, p + 1);
len = strlen(p + 1);
for (int i = 2, j = 0; i <= len; i++) {
while (j > 0 && p[i] != p[j + 1]) j = Next[j];
if (p[i] == p[j + 1]) j++;
Next[i] = j;
}
for (int i = len; i; i = Next[i]) mark[i] = 1;
scanf("%d", &pos[1]);
for (int i = 2; i <= m; i++) {
scanf("%d", &pos[i]);
if (pos[i] - pos[i - 1] >= len) continue;
if (pos[i] + len - 1 > n || mark[len - (pos[i] - pos[i - 1])] == 0) {
printf("0");
return 0;
}
}
if (m) n -= len;
for (int i = 2; i <= m; i++)
n -= pos[i] - pos[i - 1] < len ? pos[i] - pos[i - 1] : len;
printf("%lld", pow_mod((long long)26, (long long)n));
return 0;
}
long long pow_mod(long long a, long long b) {
a %= mod;
if (a == 0) return 0;
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans % mod;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int i;
char a[10], b[10];
scanf("%s %s", a, b);
printf("%c", a[0]);
for (i = 1; i < strlen(a); i++) {
if (a[i] < b[0]) {
printf("%c", a[i]);
} else {
break;
}
}
printf("%c", b[0]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 69;
const long long inf = (long long)1e18 + 69;
struct LCA {
int idx[MAX], height[MAX], st[8 * MAX];
vector<int> euler;
LCA(int root, int n, vector<int> adj[]) {
euler.reserve(2 * n);
dfs(root, -1, 0, adj);
build(1, 0, euler.size() - 1);
}
inline void dfs(int node, int par, int h, vector<int> adj[]) {
height[node] = h;
idx[node] = euler.size();
euler.push_back(node);
for (int to : adj[node]) {
if (to != par) {
dfs(to, node, h + 1, adj);
euler.push_back(node);
}
}
}
inline void build(int node, int l, int r) {
if (l == r) {
st[node] = euler[l];
return;
}
int mid = (l + r) >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
int lt = st[node << 1], rt = st[node << 1 | 1];
st[node] = height[lt] < height[rt] ? lt : rt;
}
inline int rmq(int node, int l, int r, int p, int q) {
if (l > q || r < p) return -1;
if (p <= l && r <= q) return st[node];
int mid = (l + r) >> 1;
int lt = rmq(node << 1, l, mid, p, q);
int rt = rmq(node << 1 | 1, mid + 1, r, p, q);
if (lt == -1) return rt;
if (rt == -1) return lt;
return height[lt] < height[rt] ? lt : rt;
}
inline int lca(int u, int v) {
int p = idx[u], q = idx[v];
if (p > q) swap(p, q);
return rmq(1, 0, euler.size() - 1, p, q);
}
};
int n;
int sz[MAX], par[MAX], depth[MAX], heavy[MAX], head[MAX], pos[MAX];
pair<long long, pair<int, int> > ar[MAX], st[4 * MAX];
long long lazy[4 * MAX], upd[4 * MAX];
vector<int> adj[MAX], girl[MAX];
inline int dfs(int node) {
sz[node] = 1;
int max_sz = 0;
for (int to : adj[node]) {
if (to != par[node]) {
par[to] = node;
depth[to] = depth[node] + 1;
int to_sz = dfs(to);
sz[node] += to_sz;
if (to_sz > max_sz) max_sz = to_sz, heavy[node] = to;
}
}
return sz[node];
}
static int cur_pos = 1;
inline void hld(int node, int h) {
head[node] = h;
pos[node] = cur_pos++;
if (heavy[node] != -1) hld(heavy[node], h);
for (int to : adj[node])
if (to != par[node] && to != heavy[node]) hld(to, to);
}
inline void build(int node, int l, int r) {
if (l == r) {
st[node] = ar[l];
return;
}
int mid = (l + r) >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
st[node] = min(st[node << 1], st[node << 1 | 1]);
}
inline void modify(int node, int l, int r, int p, int q, long long val) {
if (lazy[node]) {
st[node].first = min(inf, st[node].first + lazy[node]);
if (l < r) {
lazy[node << 1] += lazy[node];
lazy[node << 1 | 1] += lazy[node];
} else
upd[node] += lazy[node];
lazy[node] = 0;
}
if (l > q || r < p) return;
if (p <= l && r <= q) {
st[node].first = min(inf, st[node].first + val);
if (l < r) {
lazy[node << 1] += val;
lazy[node << 1 | 1] += val;
} else
upd[node] += val;
return;
}
int mid = (l + r) >> 1;
modify(node << 1, l, mid, p, q, val);
modify(node << 1 | 1, mid + 1, r, p, q, val);
st[node] = min(st[node << 1], st[node << 1 | 1]);
}
inline pair<long long, pair<int, int> > rmq(int node, int l, int r, int p,
int q) {
if (lazy[node]) {
st[node].first = min(inf, st[node].first + lazy[node]);
if (l < r) {
lazy[node << 1] += lazy[node];
lazy[node << 1 | 1] += lazy[node];
} else
upd[node] += lazy[node];
lazy[node] = 0;
}
if (l > q || r < p) return {inf, {-1, -1}};
if (p <= l && r <= q) return st[node];
int mid = (l + r) >> 1;
return min(rmq(node << 1, l, mid, p, q),
rmq(node << 1 | 1, mid + 1, r, p, q));
}
inline void addweigh(int node, int k) {
modify(1, 1, n, pos[node], pos[node] + sz[node] - 1, k);
}
inline pair<long long, pair<int, int> > getGirl(int u, int lc) {
pair<long long, pair<int, int> > res = {inf, {-1, -1}};
for (; head[lc] != head[u]; u = par[head[u]]) {
if (u == 0) exit(0);
res = min(res, rmq(1, 1, n, pos[head[u]], pos[u]));
}
res = min(res, rmq(1, 1, n, pos[lc], pos[u]));
return res;
}
inline void change(int node, int l, int r, int p, int ver) {
if (lazy[node]) {
st[node].first = min(inf, st[node].first + lazy[node]);
if (l < r) {
lazy[node << 1] += lazy[node];
lazy[node << 1 | 1] += lazy[node];
} else
upd[node] += lazy[node];
lazy[node] = 0;
}
if (l > p || r < p) return;
if (l == r) {
if (girl[ver].empty())
st[node] = {inf, {-1, -1}};
else {
int x = girl[ver].back();
girl[ver].pop_back();
st[node] = {x + upd[node], {x, ver}};
}
return;
}
int mid = (l + r) >> 1;
change(node << 1, l, mid, p, ver);
change(node << 1 | 1, mid + 1, r, p, ver);
st[node] = min(st[node << 1], st[node << 1 | 1]);
}
inline void query(int u, int v, int k, int lc) {
vector<int> ans;
for (int i = 0; i < k; ++i) {
pair<long long, pair<int, int> > tmp = min(getGirl(u, lc), getGirl(v, lc));
if (tmp.first == inf) break;
ans.push_back(tmp.second.first);
change(1, 1, n, pos[tmp.second.second], tmp.second.second);
}
cout << ans.size();
for (int x : ans) cout << " " << x;
cout << '\n';
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m, q;
cin >> n >> m >> q;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= m; ++i) {
int c;
cin >> c;
girl[c].push_back(i);
}
for (int i = 1; i <= n; ++i) {
reverse(girl[i].begin(), girl[i].end());
heavy[i] = -1;
}
depth[1] = 0;
dfs(1);
hld(1, 1);
for (int i = 1; i <= n; ++i) {
if (girl[i].empty())
ar[pos[i]] = {inf, {-1, -1}};
else {
int x = girl[i].back();
girl[i].pop_back();
ar[pos[i]] = {x, {x, i}};
}
}
build(1, 1, n);
LCA lca(1, n, adj);
while (q--) {
int t;
cin >> t;
if (t == 1) {
int u, v, k;
cin >> u >> v >> k;
query(u, v, k, lca.lca(u, v));
} else {
int v, k;
cin >> v >> k;
addweigh(v, k);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = (const int)(1e6 + 11);
int T[4 * MAX], P[4 * MAX];
static void t_set(int v, int a, int b, int idx, int x) {
if (a == idx && b == idx) {
T[v] = x;
P[v] = max(P[v], x);
} else {
int m = (a + b) / 2;
if (idx <= m)
t_set(2 * v, a, m, idx, x);
else
t_set(2 * v + 1, m + 1, b, idx, x);
T[v] = T[2 * v] + T[2 * v + 1];
P[v] = max(P[2 * v + 1], P[2 * v] + T[2 * v + 1]);
}
}
static int t_get(int v, int a, int b, int f, int t) {
if (f > t) return 0;
if (a == f && b == t) return T[v];
int m = (a + b) / 2;
int x = t_get(2 * v, a, m, f, min(t, m));
int y = t_get(2 * v + 1, m + 1, b, max(f, m + 1), t);
return x + y;
}
static int t_idx(int v, int a, int b, int x, int p = 0) {
if (a == b) return a;
int m = (a + b) / 2;
if (P[2 * v + 1] + p >= x) return t_idx(2 * v + 1, m + 1, b, x, p);
return t_idx(2 * v, a, m, x, p + T[2 * v + 1]);
}
struct {
int p, t, x;
} A[MAX];
int N;
static int t_get(int f, int t) { return t_get(1, 0, N - 1, f, t); }
static void t_set(int idx, int x) { t_set(1, 0, N - 1, idx, x); }
static int t_idx() {
if (P[1] <= 0) return -1;
return t_idx(1, 0, N - 1, 1);
}
static void solve(std::int32_t test) {
memset(P, 0xFF, sizeof(P));
memset(T, 0, sizeof(T));
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> A[i].p >> A[i].t;
if (A[i].t != 0) cin >> A[i].x;
}
map<int, int> xs;
for (int i = 0; i < N; ++i)
if (A[i].t != 0) xs[A[i].p] = A[i].x;
for (int i = 0; i < N; ++i) {
if (A[i].t == 0)
t_set(A[i].p - 1, -1);
else
t_set(A[i].p - 1, +1);
int res = t_idx();
if (0 <= res && res < N) res = xs[res + 1];
cout << res << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cout << setprecision(12) << fixed;
solve(0);
return 0;
}
| 7 |
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define st first
#define nd second
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int n; cin >> n;
vector<int> a(n);
for(int &x : a) cin >> x, x--;
vector<int> dp(n + 1), r(n, -1), c(n), l(n);
for(int i = n - 1; i >= 0; i--) l[a[i]] = i;
for(int i = n - 1; i >= 0; i--) {
c[a[i]]++;
if(r[a[i]] == -1) r[a[i]] = i;
dp[i] = max(dp[i + 1], (l[a[i]] == i ? dp[r[a[i]] + 1] : 0) + c[a[i]]);
}
cout << n - dp[0] << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int a, b;
cin >> a >> b;
cout << a + b;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z, t1, t2, t3, ts, te;
cin >> x >> y >> z >> t1 >> t2 >> t3;
ts = abs(x - y) * t1;
te = t3 * 2 + abs(x - z) * t2 + t3 + abs(x - y) * t2;
if (ts >= te)
cout << "YES";
else
cout << "NO";
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 50;
int n, m;
int fa[MAXN + 5], deg[MAXN + 5];
bool exist_cycle;
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
bool check1() {
for (int i = 1; i <= n; ++i)
if (deg[i] != 2) return 0;
for (int i = 2; i <= n; ++i)
if (find(i) != find(1)) return 0;
return 1;
}
bool check2() {
if (m >= n) return 0;
if (exist_cycle) return 0;
for (int i = 1; i <= n; ++i)
if (deg[i] > 2) return 0;
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
++deg[u];
++deg[v];
exist_cycle |= find(u) == find(v);
fa[fa[u]] = fa[v];
}
if (check1()) {
puts("YES");
puts("0");
return 0;
}
if (!check2()) {
puts("NO");
return 0;
}
puts("YES");
printf("%d\n", n - m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (deg[i] < 2 && deg[j] < 2 && find(i) != find(j)) {
fa[fa[i]] = fa[j];
++deg[i];
++deg[j];
printf("%d %d\n", i, j);
}
int u, v;
for (int i = 1; i <= n; ++i)
if (deg[i] < 2) {
u = i;
break;
}
for (int i = n; i; --i)
if (deg[i] < 2) {
v = i;
break;
}
printf("%d %d\n", u, v);
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int INF = 1 << 30;
inline int read() {
int x = 0;
bool f = false;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = true;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
if (f) return -x;
return x;
}
const int D = 50;
int a, b, c, x, y, z;
int rem, ned;
int main() {
a = read();
b = read();
c = read();
x = read();
y = read();
z = read();
if (a > x)
rem += (a - x) / 2;
else
ned += x - a;
if (b > y)
rem += (b - y) / 2;
else
ned += y - b;
if (c > z)
rem += (c - z) / 2;
else
ned += z - c;
if (rem >= ned)
printf("Yes");
else
printf("No");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int rooms, p, q, count = 0;
cin >> rooms;
for (int i = 0; i < rooms; i++) {
cin >> p >> q;
if (p <= (q - 2)) {
count++;
}
}
cout << count << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
long long M;
cin >> M;
int cnt[110];
for (int i = 0; i <= 100; i++) cnt[i] = 0;
long long total = 0;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
total += t;
long long tmp = total;
int ans = 0;
if (tmp > M) {
for (int j = 100; j >= 1; j--) {
if (tmp - j * cnt[j] > M) {
tmp -= j * cnt[j];
ans += cnt[j];
} else {
ans += (tmp - M + j - 1) / j;
break;
}
}
}
cnt[t]++;
if (i < n - 1)
cout << ans << " ";
else
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100001];
long long arr[100001];
int visit[100001];
void dfs(int s, long long *pos, long long *neg) {
visit[s] = 1;
int i;
long long k, maxi = 0, mini = 0, ps = 0, ng = 0;
for (i = 0; i < v[s].size(); i++) {
if (!visit[v[s][i]]) {
dfs(v[s][i], &ps, &ng);
if (ps > maxi) maxi = ps;
if (ng < mini) mini = ng;
}
}
*pos = maxi;
*neg = mini;
k = arr[s] + maxi + mini;
if (k < 0)
*pos = *pos - k;
else
*neg = *neg - k;
}
int main() {
int n, i, a, b;
long long pos = 0, neg = 0;
scanf("%d", &n);
for (i = 0; i < n - 1; i++) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
for (i = 1; i <= n; i++) cin >> arr[i];
dfs(1, &pos, &neg);
cout << pos - neg;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100 * 1000 + 1;
vector<int> adj[max_n];
bool vis[max_n];
int dfs(int at) {
vis[at] = true;
vector<int> tmp, child;
for (int i = 0; i < (adj[at].size()); i++) {
int to = adj[at][i];
if (!vis[to]) {
child.push_back(to);
}
}
for (int i = 0; i < (child.size()); i++) {
int to = child[i];
int x = dfs(to);
if (x != -1)
printf("%d %d %d\n", x, to, at);
else
tmp.push_back(to);
}
for (int i = 0; i + 1 < tmp.size(); i += 2)
printf("%d %d %d\n", tmp[i], at, tmp[i + 1]);
return (tmp.size() & 1) ? tmp.back() : -1;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (m); i++) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
if (m & 1)
printf("No solution\n");
else {
memset(vis, false, sizeof vis);
dfs(1);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
cout << "1 " << n << '\n';
for (int i = 0; i < n; ++i) cout << -1ll * n * a[i] << ' ';
cout << '\n';
if (n > 1) {
cout << "1 " << n - 1 << '\n';
for (int i = 0; i < n - 1; ++i) cout << 1ll * (n - 1) * a[i] << ' ';
} else {
cout << "1 1\n0";
}
cout << '\n';
cout << n << ' ' << n << '\n';
cout << 1ll * (n - 1) * a[n - 1];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m, x, i, j;
cin >> n >> m >> x;
long long int a[n + 5];
long long int b[n + 5];
long long int ans = 0;
x = (x < m ? x : m);
long long int num = m - x;
long long int h = 0;
for (i = 0; i < n; i++) {
h = (h > a[i] ? h : a[i]);
cin >> a[i];
}
for (i = 0; i < n; i++) {
b[i] = a[n - 1 - i];
}
if (num == 0) {
long long int ans1 = 0;
for (i = 0; i < m; i++) {
ans = (a[i] > b[m - i - 1] ? a[i] : b[m - i - 1]);
ans1 = (ans > ans1 ? ans : ans1);
}
cout << ans1 << endl;
} else {
long long int c;
for (i = 0; i <= x; i++) {
c = 10000000000;
for (j = 0; j < num; j++) {
long long int index = (x - i) + (num - j);
long long int y = (a[j + i] > b[index - 1] ? a[j + i] : b[index - 1]);
c = (c < y ? c : y);
}
ans = (ans > c ? ans : c);
}
cout << ans << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, r, t, g = 0;
cin >> a >> b >> r;
if ((r * 2) <= a && (r * 2) <= b)
cout << "First" << endl;
else
cout << "Second" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long long gig = 1e18;
const long long gg = 25 * 1e6;
const long long md = 1e9 + 7;
const long long N = 100050;
const double PI = 3.1415926535897932384626433832795;
using namespace std;
long long d[555];
long long a[N];
map<long long, long long> mp;
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, d, ans = 0;
cin >> d >> n;
long long a;
cin >> a;
for (int i = 2; i <= n; i++) {
ans += d - a;
cin >> a;
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (a[j] < a[i]) ans++;
}
}
ans %= 2;
int m;
cin >> m;
while (m--) {
int l, r;
cin >> l >> r;
l--;
r--;
int swaps = (r - l + 1) / 2;
if (swaps % 2 == 1) ans += 1, ans %= 2;
if (ans == 0)
cout << "even\n";
else
cout << "odd\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> x, cost;
for (int i = 0; i < n; i++) {
int no;
cin >> no;
x.push_back(no);
}
sort(x.begin(), x.end());
int q;
cin >> q;
while (q--) {
int cost, j;
cin >> cost;
j = upper_bound(x.begin(), x.end(), cost) - x.begin();
cout << j << endl;
}
}
| 1 |
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
if (flag) x = -x;
}
using namespace std;
int n, P, q;
inline long long quickpow(long long x, int k) {
long long res = 1;
while (k) {
if (k & 1) res = res * x % P;
x = x * x % P;
k >>= 1;
}
return res;
}
int a[101000];
int pri[101000], ptot, phi;
inline void Divi(int x) {
phi = 1;
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) {
pri[++ptot] = i;
phi *= (i - 1);
x /= i;
while (x % i == 0) x /= i, phi *= i;
}
}
if (x > 1) pri[++ptot] = x, phi *= (x - 1);
}
int ls[401000], rs[401000], root, ttot;
struct node {
int h[10];
node() { memset(h, 0, sizeof(h)); }
inline void clear() { memset(h, 0, sizeof(h)); }
};
long long sum[401000];
node tag[401000];
long long tagrst[401000], tagmul[401000];
inline void pushup(int cur) { sum[cur] = (sum[ls[cur]] + sum[rs[cur]]) % P; }
void build(int L, int R, int &cur) {
cur = ++ttot;
tagrst[cur] = tagmul[cur] = 1;
if (L == R) {
sum[cur] = a[L];
for (int i = 1; i <= ptot; ++i) {
while (a[L] % pri[i] == 0) ++tag[cur].h[i], a[L] /= pri[i];
}
tagrst[cur] = a[L];
return;
}
int mid = (L + R) >> 1;
build(L, mid, ls[cur]), build(mid + 1, R, rs[cur]);
pushup(cur);
}
bool havt[401000];
inline void pusht(int cur, node nd, int rst, int mul) {
for (int i = 1; i <= ptot; ++i) tag[cur].h[i] += nd.h[i];
tagrst[cur] = tagrst[cur] * rst % P;
tagmul[cur] = tagmul[cur] * mul % P;
sum[cur] = sum[cur] * mul % P;
havt[cur] = true;
}
inline void pushdown(int cur) {
if (havt[cur])
pusht(ls[cur], tag[cur], tagrst[cur], tagmul[cur]),
pusht(rs[cur], tag[cur], tagrst[cur], tagmul[cur]),
havt[cur] = false, tag[cur].clear(), tagrst[cur] = tagmul[cur] = 1;
}
void modify_mul(int L, int R, int l, int r, node nd, int rst, int mul,
int cur) {
if (l <= L && R <= r) return pusht(cur, nd, rst, mul), void();
int mid = (L + R) >> 1;
pushdown(cur);
if (l <= mid) modify_mul(L, mid, l, r, nd, rst, mul, ls[cur]);
if (r > mid) modify_mul(mid + 1, R, l, r, nd, rst, mul, rs[cur]);
pushup(cur);
}
void modify_div(int L, int R, int pos, int x, int cur) {
if (L == R) {
for (int i = 1; i <= ptot; ++i)
while (x % pri[i] == 0) x /= pri[i], --tag[cur].h[i];
sum[cur] = tagrst[cur] = tagrst[cur] * quickpow(x, phi - 1) % P;
for (int i = 1; i <= ptot; ++i)
sum[cur] = sum[cur] * quickpow(pri[i], tag[cur].h[i]) % P;
return;
}
int mid = (L + R) >> 1;
pushdown(cur);
if (pos <= mid)
modify_div(L, mid, pos, x, ls[cur]);
else
modify_div(mid + 1, R, pos, x, rs[cur]);
pushup(cur);
}
long long query(int L, int R, int l, int r, int cur) {
if (l <= L && R <= r) return sum[cur];
int mid = (L + R) >> 1;
long long res = 0;
pushdown(cur);
if (l <= mid) res += query(L, mid, l, r, ls[cur]);
if (r > mid) res += query(mid + 1, R, l, r, rs[cur]);
return res % P;
}
int main() {
read(n), read(P);
Divi(P);
for (int i = 1; i <= n; ++i) read(a[i]);
build(1, n, root);
read(q);
while (q--) {
int op;
read(op);
if (op == 1) {
int l, r, x;
read(l), read(r), read(x);
int tmpx = x;
node nd;
for (int i = 1; i <= ptot; ++i)
while (x % pri[i] == 0) ++nd.h[i], x /= pri[i];
modify_mul(1, n, l, r, nd, x, tmpx, root);
} else if (op == 2) {
int p, x;
read(p), read(x);
modify_div(1, n, p, x, root);
} else {
int l, r;
read(l), read(r);
long long res = query(1, n, l, r, root);
printf("%lld\n", (res % P + P) % P);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
long long int s = 0;
s = ((n * (n - 1)) / 2) + (((n - 1) * n * (2 * n - 1)) / 6) - 2;
cout << s << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
long long mod = 1e9 + 7;
long long dp[maxn * 3][3];
long long nv[maxn * 3];
long long qpow(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
long long a[maxn * 3];
int main() {
int n, q, x;
long long inv = qpow(3, mod - 2);
scanf("%d%d", &n, &q);
long long sum = 3 * n;
a[0] = 1;
a[1] = sum;
dp[0][0] = n;
dp[0][1] = n;
dp[0][2] = n;
nv[1] = 1;
for (int i = 2; i <= 3 * n; i++) {
nv[i] = mod - mod / i * nv[mod % i] % mod;
}
for (int i = 1; i < 3 * n; i++) {
sum = sum * (3 * n - i) % mod * nv[i + 1] % mod;
a[i + 1] = sum;
dp[i][0] =
(sum - 2 * dp[i - 1][0] - dp[i - 1][1] + 3 * mod) % mod * inv % mod;
dp[i][1] = (dp[i][0] + dp[i - 1][0]) % mod;
}
while (q--) {
scanf("%d", &x);
if (x == 3 * n) {
cout << 1 << '\n';
continue;
}
printf("%lld\n", (dp[x][0] + a[x]) % mod);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
long long gcd(long long x, long long y) {
if (x == 0) return y;
return gcd(y % x, x);
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
long long min(long long a, long long b, long long c) {
return min(a, min(b, c));
}
long long min(long long a, long long b, long long c, long long d) {
return min(min(a, d), min(b, c));
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long max(long long a, long long b, long long c) {
return max(a, max(b, c));
}
long long max(long long a, long long b, long long c, long long d) {
return max(max(a, d), max(b, c));
}
long long powM(long long x, long long y, long long m) {
long long ans = 1, r = 1;
x = x % m;
while (r > 0 && r <= y) {
if (r & y) {
ans = ans * x;
ans = ans % m;
}
r = r << 1;
x = x * x;
x = x % m;
}
return ans;
}
long long countbits(long long n) {
long long cot = 0;
while (n) {
cot++;
n >>= 1;
}
return cot;
}
long long SOD(long long n) {
long long sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
long long countsubstring(const string &s, long long n) {
long long count = 0;
string ttt = "";
for (long long i = 0; i <= n; i++) {
if (s.substr(i, ttt.size()) == ttt) count++;
}
return count;
}
void m24(bool ok) { cout << (ok ? "Yes" : "No") << "\n"; }
long long inf = 1e15;
int main() {
fast();
long long t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
;
long long c0 = 0;
long long c1 = 0;
for (long long i = 0; i < n; i++) {
if (a[i] == 0)
c0++;
else
c1++;
}
if (c0 >= c1) {
cout << c0 << "\n";
for (long long i = 0; i < c0; i++) cout << 0 << " ";
cout << "\n";
} else {
if (c1 % 2 == 1) c1--;
cout << c1 << "\n";
for (long long i = 0; i < c1; i++) cout << 1 << " ";
cout << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<long long> g[N], t[N];
bool visit[N];
int dis[N];
void bfs(int s) {
queue<int> q;
q.push(s);
visit[s] = true;
while (q.size()) {
int u = q.front();
q.pop();
for (auto v : t[u]) {
if (!visit[v]) {
visit[v] = true;
dis[v] = 1 + dis[u];
q.push(v);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int n, m, u, v, k;
int min_r = 0, max_r = 0;
cin >> n >> m;
while (m--) {
cin >> u >> v;
g[u].push_back(v);
t[v].push_back(u);
}
cin >> k;
vector<int> d(k);
for (int i = 0; i < k; i++) cin >> d[i];
bfs(d[k - 1]);
for (int i = 0; i < k - 1; i++) {
if (dis[d[i + 1]] + 1 != dis[d[i]]) {
min_r++, max_r++;
continue;
}
for (auto v : g[d[i]])
if (dis[v] + 1 == dis[d[i]] && v != d[i + 1]) {
max_r++;
break;
}
}
cout << min_r << " " << max_r << endl;
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.