solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long a[300000], b[300000], c[300000];
int main() {
long long n, k, i, k1, k2, ans = 0, s = 0;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
k1 = a[0];
k2 = a[n - 1];
for (i = 0; i < n; i++) b[a[i]]++;
c[k2 + 1] = 0;
for (i = k2; i >= 1; i--) c[i] = c[i + 1] + b[i];
for (i = k2; i >= (1 + a[0]); i--) {
if ((s + c[i]) > k) {
ans++;
s = 0;
i++;
} else
s = s + c[i];
}
if (s != 0) ans++;
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
vector<int> v1;
vector<int> v0;
for (int i = 0; i < n; i++) {
char x;
cin >> x;
if (x == '0') {
v0.push_back(i);
} else {
v1.push_back(i);
}
}
if (k == n || v0.empty() || v1.empty()) {
cout << "tokitsukaze\n";
return 0;
}
int f0 = v0[0];
int l0 = v0[v0.size() - 1];
int f1 = v1[0];
int l1 = v1[v1.size() - 1];
if (min(l0 - f0 + 1, l1 - f1 + 1) <= k) {
cout << "tokitsukaze\n";
return 0;
}
for (int i = 0; i < n - k + 1; i++) {
int nf0 = min(f0, i);
int nl0 = max(l0, i + k - 1);
int nf1 = f1;
if (f1 >= i) {
nf1 = *upper_bound(v1.begin(), v1.end(), i + k - 1);
}
int nl1 = l1;
if (l1 <= i + k - 1) {
auto it = lower_bound(v1.begin(), v1.end(), i);
it--;
nl1 = *it;
}
if (min(nl0 - nf0 + 1, nl1 - nf1 + 1) > k) {
cout << "once again\n";
return 0;
}
}
for (int i = 0; i < n - k + 1; i++) {
int nf1 = min(f1, i);
int nl1 = max(l1, i + k - 1);
int nf0 = f0;
if (f0 >= i) {
nf0 = *upper_bound(v0.begin(), v0.end(), i + k - 1);
}
int nl0 = l0;
if (l0 <= i + k - 1) {
auto it = lower_bound(v0.begin(), v0.end(), i);
it--;
nl0 = *it;
}
if (min(nl0 - nf0 + 1, nl1 - nf1 + 1) > k) {
cout << "once again\n";
return 0;
}
}
cout << "quailty\n";
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1015;
int b[N][N];
char c[N];
int n;
char a[N];
int w[15];
int len = 0;
int sa[N], rk[N];
int tsa[N], trk[N];
int sum[15];
int f[2][N];
int cost[N][12][2];
int dj[11][N];
int lp[N];
int dp() {
for (int i = (int)1; i <= (int)n; i++) sa[i] = i;
for (int i = (int)1; i <= (int)n; i++) rk[sa[i]] = i;
for (int i = (int)0; i <= (int)n; i++) f[0][i] = f[1][i] = -1000000000;
int now = 0;
f[0][0] = 0;
for (int bit = (int)1; bit <= (int)1005; bit++) {
for (int i = (int)0; i <= (int)n; i++) f[now ^ 1][i] = -1000000000;
memset(cost, 0, sizeof cost);
for (int i = (int)1; i <= (int)n; i++) {
for (int j = (int)0; j <= (int)9; j++)
for (int k = (int)0; k <= (int)1; k++) {
if ((bit <= max(lp[sa[i]], len)) ||
(bit == max(lp[sa[i]], len) + 1 &&
((b[sa[i]][bit] + j + k) % 10 != 0)))
cost[i][j][k] = cost[i - 1][j][k] + w[(b[sa[i]][bit] + j + k) % 10];
else
cost[i][j][k] = cost[i - 1][j][k];
}
}
memset(sum, 0, sizeof sum);
for (int i = (int)1; i <= (int)n; i++) sum[b[i][bit]]++;
for (int i = (int)8; i >= (int)0; i--) sum[i] += sum[i + 1];
for (int i = (int)n; i >= (int)1; i--) tsa[sum[b[sa[i]][bit]]--] = sa[i];
for (int i = (int)1; i <= (int)n; i++) trk[tsa[i]] = i;
for (int i = (int)0; i <= (int)9; i++) {
int dc = 0;
while (dc < n && b[tsa[dc + 1]][bit] > i) ++dc;
for (int j = (int)0; j <= (int)n; j++) {
while (dc < n && rk[tsa[dc + 1]] <= j && b[tsa[dc + 1]][bit] == i) ++dc;
dj[i][j] = dc;
}
}
for (int i = (int)0; i <= (int)n; i++)
if (f[now][i] >= 0) {
for (int v = (int)0; v <= (int)9; v++) {
if (v > 0 && bit > len) continue;
if (bit <= len && a[bit] != '?' && (a[bit] - '0' != v)) continue;
if (bit == len && v == 0) continue;
f[now ^ 1][dj[9 - v][i]] =
max(f[now ^ 1][dj[9 - v][i]],
f[now][i] + cost[i][v][1] + cost[n][v][0] - cost[i][v][0]);
}
}
now ^= 1;
for (int i = (int)1; i <= (int)n; i++) sa[i] = tsa[i], rk[i] = trk[i];
}
return f[now][0];
}
int main() {
scanf("%s", a + 1);
n = strlen(a + 1);
len = n;
for (int i = (int)1; i <= (int)n; i++)
if (i < n + 1 - i) swap(a[i], a[n + 1 - i]);
scanf("%d", &n);
for (int i = (int)1; i <= (int)n; i++) {
scanf("%s", c + 1);
int m = strlen(c + 1);
lp[i] = m;
for (int j = (int)1; j <= (int)m; j++) b[i][j] = c[m + 1 - j] - '0';
}
for (int i = (int)0; i <= (int)9; i++) scanf("%d", &w[i]);
printf("%d\n", dp());
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, m, Q, Ans[N], ans;
int x[N], y[N];
int L[N][N], R[N][N];
char s[N][N];
void build(int id) {
L[id][0] = R[id][m + 1] = 0;
for (int i = (int)(1); i <= (int)(m); i++)
L[id][i] = (s[id][i] == 'X' ? 0 : L[id][i - 1] + 1);
for (int i = (int)(m); i >= (int)(1); i--)
R[id][i] = (s[id][i] == 'X' ? 0 : R[id][i + 1] + 1);
}
bool check(int y, int L, int R, int v) {
static int va[N], vb[N], q[N], sum[N];
for (int i = (int)(L); i <= (int)(R); i++) sum[i] = 0;
for (int i = (int)(L); i <= (int)(R); i++) va[i] = ::L[i][y];
for (int i = (int)(L); i <= (int)(R); i++) vb[i] = ::R[i][y];
int h = 1, t = 0;
for (int i = (int)(L); i <= (int)(R); i++) {
if (h <= t && q[h] <= i - v) ++h;
for (; h <= t && va[i] <= va[q[t]]; --t)
;
q[++t] = i;
sum[i] += va[q[h]];
}
h = 1, t = 0;
for (int i = (int)(L); i <= (int)(R); i++) {
if (h <= t && q[h] <= i - v) ++h;
for (; h <= t && vb[i] <= vb[q[t]]; --t)
;
q[++t] = i;
sum[i] += vb[q[h]];
}
for (int i = (int)(L + v - 1); i <= (int)(R); i++)
if (sum[i] >= v + 1) return 1;
return 0;
}
int main() {
ans = 1;
scanf("%d%d%d", &n, &m, &Q);
for (int i = (int)(1); i <= (int)(n); i++) scanf("%s", s[i] + 1);
for (int i = (int)(1); i <= (int)(Q); i++) scanf("%d%d", &x[i], &y[i]);
for (int i = (int)(1); i <= (int)(Q); i++) s[x[i]][y[i]] = 'X';
for (int i = (int)(1); i <= (int)(n); i++) build(i);
for (int i = (int)(1); i <= (int)(m); i++)
for (; check(i, 1, n, ans); ++ans)
;
for (int i = (int)(Q); i >= (int)(1); i--) {
Ans[i] = ans;
s[x[i]][y[i]] = '.';
build(x[i]);
for (; check(y[i], max(1, x[i] - ans), min(n, x[i] + ans), ans); ++ans)
;
}
for (int i = (int)(1); i <= (int)(Q); i++) printf("%d\n", Ans[i] - 1);
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
const long long INFLL = 1001001001001001001LL;
template <typename T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
double fin() {
double x;
scanf("%lf", &x);
return x;
}
long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
int R[100050], S[100050][2];
struct edge {
int src, dst;
edge(int s, int d) : src(s), dst(d) {}
};
void dfs(int v, const vector<vector<edge>>& g, vector<int>& ord,
vector<int>& num, int k) {
if (num[v] >= 0) {
return;
}
num[v] = k;
for (int i = 0; i < g[v].size(); ++i) {
dfs(g[v][i].dst, g, ord, num, k);
}
ord.push_back(v);
}
bool sat2(int m, const vector<pair<int, int>>& cs) {
int n = m * 2;
vector<vector<edge>> g(n), h(n);
for (int i = 0; i < cs.size(); ++i) {
int u = cs[i].first, v = cs[i].second;
g[((u) ^ 1)].push_back(edge(((u) ^ 1), v));
g[((v) ^ 1)].push_back(edge(((v) ^ 1), u));
h[v].push_back(edge(v, ((u) ^ 1)));
h[u].push_back(edge(u, ((v) ^ 1)));
}
vector<int> num(n, -1), ord, dro;
for (int i = 0; i < n; ++i) dfs(i, g, ord, num, i);
reverse(ord.begin(), ord.end());
fill(num.begin(), num.end(), -1);
for (int i = 0; i < n; ++i) dfs(ord[i], h, dro, num, i);
for (int i = 0; i < n; ++i)
if (num[i] == num[((i) ^ 1)]) return false;
return true;
}
int main() {
int N = in();
int M = in();
for (int i = 0; i < N; ++i) {
R[i] = in();
S[i][0] = S[i][1] = -1;
}
for (int i = 0; i < M; ++i) {
int k = in();
for (int j = 0; j < k; ++j) {
int u = in() - 1;
if (S[u][0] < 0) {
S[u][0] = i;
} else {
S[u][1] = i;
}
}
}
vector<pair<int, int>> cs;
for (int i = 0; i < N; ++i) {
if (R[i] == 0) {
cs.emplace_back(((S[i][0]) << 1), ((S[i][1]) << 1));
cs.emplace_back(((((S[i][0]) << 1)) ^ 1), ((((S[i][1]) << 1)) ^ 1));
} else {
cs.emplace_back(((S[i][0]) << 1), ((((S[i][1]) << 1)) ^ 1));
cs.emplace_back(((((S[i][0]) << 1)) ^ 1), ((S[i][1]) << 1));
}
}
if (sat2(M, cs)) {
puts("YES");
} else {
puts("NO");
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
static unsigned rnd() {
static int second = 124612741;
second ^= second << 13;
second ^= second >> 17;
return second ^= second << 5;
}
inline int fpow(int a, int st, int mod) {
int ans = 1;
while (st) {
if (st % 2) ans = (long long)ans * a % mod;
a = (long long)a * a % mod;
st /= 2;
}
return ans;
}
int invmod(int first, int second) {
int a = 1, b = 0, k;
for (; second; swap(first, second), swap(a, b)) {
k = first / second;
first -= second * k;
a -= b * k;
}
return a + max(b, 0);
}
struct Hash {
Hash() : x1(0), x2(0) {}
Hash(const int& x1, const int& x2) : x1(x1), x2(x2) {}
int x1, x2;
static int mod1, mod2;
static int p1, p2;
static int invp1, invp2;
static bool initCalled;
static const Hash ONE, ZERO, INVALID;
static Hash UNIT, INV_UNIT;
static bool prime(int a) {
if (a == 1) return 0;
for (int i = 2; i * i <= a; ++i) {
if (a % i == 0) return false;
}
return true;
}
static void init() {
if (initCalled) return;
initCalled = true;
mod1 = 1000000000 + rnd() % 10000000;
while (!prime(mod1)) ++mod1;
mod2 = 1000000000 + rnd() % 10000000;
while (mod2 == mod1 || !prime(mod2)) ++mod2;
invp1 = fpow(p1, mod1 - 2, mod1);
invp2 = fpow(p2, mod2 - 2, mod2);
INV_UNIT = Hash(invp1, invp2);
}
inline Hash& operator+=(const Hash& other) {
x1 += other.x1;
x1 -= (((x1 - mod1) >> 31) + 1) * mod1;
x2 += other.x2;
x1 -= (((x1 - mod2) >> 31) + 1) * mod2;
return *this;
}
inline Hash& operator-=(const Hash& other) {
x1 -= other.x1;
if (x1 < 0) x1 += Hash::mod1;
x2 -= other.x2;
if (x2 < 0) x2 += Hash::mod2;
return *this;
}
inline Hash& operator*=(const Hash& other) {
x1 = (long long)x1 * other.x1 % Hash::mod1;
x2 = (long long)x2 * other.x2 % Hash::mod2;
return *this;
}
inline Hash& operator*=(const int& other) {
x1 = (long long)x1 * other % Hash::mod1;
x2 = (long long)x2 * other % Hash::mod2;
return *this;
}
inline Hash& operator^=(const int& power) {
int st = power;
Hash ans(1, 1);
while (st) {
if (st % 2) ans *= *this;
x1 = (long long)x1 * x1 % Hash::mod1;
x2 = (long long)x2 * x2 % Hash::mod2;
st /= 2;
}
return *this;
}
inline bool operator==(const Hash& other) const {
return x1 == other.x1 && x2 == other.x2;
}
};
bool Hash::initCalled = false;
int Hash::mod1 = 0;
int Hash::mod2 = 0;
int Hash::p1 = 23561;
int Hash::p2 = 10000019;
int Hash::invp1 = -1;
int Hash::invp2 = -1;
const Hash Hash::ONE(1, 1);
const Hash Hash::ZERO(0, 0);
const Hash Hash::INVALID(-1, -1);
Hash Hash::UNIT(Hash::p1, Hash::p2);
Hash Hash::INV_UNIT(-1, -1);
inline Hash operator+(const Hash& a, const Hash& b) {
Hash ans(a.x1 + b.x1, a.x2 + b.x2);
if (ans.x1 >= Hash::mod1) ans.x1 -= Hash::mod1;
if (ans.x2 >= Hash::mod2) ans.x2 -= Hash::mod2;
return ans;
}
inline Hash operator-(const Hash& a, const Hash& b) {
Hash ans(a.x1 - b.x1, a.x2 - b.x2);
if (ans.x1 < 0) ans.x1 += Hash::mod1;
if (ans.x2 < 0) ans.x2 += Hash::mod2;
return ans;
}
inline Hash operator*(const Hash& a, const Hash& b) {
return Hash((long long)a.x1 * b.x1 % Hash::mod1,
(long long)a.x2 * b.x2 % Hash::mod2);
}
inline Hash operator*(const Hash& a, const int& b) {
return Hash((long long)a.x1 * b % Hash::mod1,
(long long)a.x2 * b % Hash::mod2);
}
inline Hash operator^(const Hash& a, const int& power) {
int st = power;
Hash ans(1, 1), cur(a);
while (st) {
if (st % 2) ans *= cur;
cur *= cur;
st /= 2;
}
return ans;
}
inline Hash fpow(const Hash& a, const int& power) { return a ^ power; }
inline Hash invmod(const Hash& a) {
return Hash(invmod(a.x1, Hash::mod1), invmod(a.x2, Hash::mod2));
}
template <class H>
struct HashString : public string {
HashString() : string() { precalc(0); }
HashString(const HashString& other) : string(other) { precalc(size()); }
HashString(HashString&& other)
: hh(std::move(other.hh)), string(std::move(other)) {
precalc(size());
}
HashString(const string& other) : string(other) {
precalc(size());
build();
}
HashString(string&& other) : string(std::move(other)) {
precalc(size());
build();
}
HashString(const char* other) : string(other) {
precalc(size());
build();
}
inline void clear() {
hh.clear();
string::clear();
}
inline static H getPow(int p) {
if (p < haveN) {
return pp[p];
} else {
return fpow(H::UNIT, p);
}
}
inline static H getInvPow(size_t p) {
if (p < invpp.size()) {
return invpp[p];
} else {
return fpow(H::INV_UNIT, p);
}
}
inline H getInvRegister(const H& p) const {
if (p == register_) {
return registerValue_;
} else {
register_ = p;
return registerValue_ = invmod(p);
}
}
static void precalc(int N = 0) {
Hash::init();
if (haveN >= N) return;
pp.resize(N);
invpp.resize(N);
if (!haveN) {
pp[0] = H::ONE;
invpp[0] = H::ONE;
haveN = 1;
}
for (int i = haveN; i < N; ++i) {
pp[i] = pp[i - 1] * H::UNIT;
invpp[i] = invpp[i - 1] * H::INV_UNIT;
}
haveN = N;
}
inline void build() {
int curSize = size();
if (haveN <= curSize) {
precalc(curSize);
}
for (int i = hh.size(); i < curSize; ++i) {
H pr = i ? hh.back() : H::ZERO;
hh.push_back(pr + getPow(i) * (*this)[i]);
}
}
inline H getHash(int pos, int len) const {
if (len <= 0) return H::ZERO;
const int S = size();
if (pos + len - 1 < S) {
H ans = hh[pos + len - 1];
if (pos) {
ans -= hh[pos - 1];
ans *= getInvPow(pos);
}
return ans;
} else {
H head = hh.back();
if (pos) {
head -= hh[pos - 1];
head *= getInvPow(pos);
}
int full = -1, en = -1;
H mid = H::ZERO;
int midlen = 0;
if (len <= S) {
en = pos + len - 1 - S;
H tail = hh[en];
full = 0;
return head + tail * getPow(S - pos);
} else {
en = (pos + len - 1) % S;
H tail = hh[en];
full = (len - (S - pos) - (en + 1)) / S;
mid = hh.back() * (H::ONE - getInvPow(full * S)) *
getInvRegister(H::ONE - getInvPow(S));
return head + mid * getPow(S - pos) + tail * getPow(len - (en + 1));
}
}
}
inline HashString& operator+=(const char& ch) {
string::operator+=(ch);
build();
return *this;
}
inline HashString& operator+=(const HashString& other) {
string::operator+=(other);
build();
return *this;
}
inline bool operator==(const HashString& other) const {
return hh.back() == other.hh.back();
}
inline bool operator<(const HashString& other) const {
int s1 = size();
int s2 = other.size();
const int S = min(s1, s2);
int l = 0, r = S + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
if (getHash(0, xx) == other.getHash(0, xx))
l = xx;
else
r = xx;
}
char c1 = 0, c2 = 0;
if (l < s1) c1 = (*this)[l];
if (l < s2) c2 = other[l];
return c1 < c2;
}
inline bool operator<=(const HashString& other) const {
return (*this == other) || (*this < other);
}
inline bool operator>(const HashString& other) const {
return !(*this == other) && !(*this < other);
}
inline bool operator>=(const HashString& other) const {
return !(*this < other);
}
inline bool operator!=(const HashString& other) const {
return !(*this == other);
}
inline void reserve(int N) {
hh.reserve(N);
string::reserve(N);
}
vector<H> hh;
static vector<H> pp, invpp;
private:
mutable H register_, registerValue_;
static int haveN;
};
template <>
int HashString<Hash>::haveN = 0;
template <>
vector<Hash> HashString<Hash>::pp = vector<Hash>();
template <>
vector<Hash> HashString<Hash>::invpp = vector<Hash>();
template <class H, bool cyclic = true>
struct HashStringPiece {
explicit HashStringPiece(const HashString<H>& s, int pos, int len)
: s(s), pos(pos), len(len), hash(H::INVALID) {}
inline H getHash() const {
if (hash == H::INVALID) hash = s.getHash(pos, len);
return hash;
}
inline H getPartialHash(int needLen) const { return s.getHash(pos, needLen); }
inline char getChar(int i) const {
i += pos;
const int S = s.size();
if (i < S) return s[i];
if (!cyclic) return 0;
i -= S;
if (i < S) return s[i];
return s[i % S];
}
const HashString<H>& s;
const int pos, len;
mutable H hash;
};
template <class H, class T>
char getHSPRangeChar(T beg, T en, int pos) {
for (T it = beg; it != en; ++it) {
if (pos < it->len) {
return it->getChar(pos);
}
pos -= it->len;
}
return 0;
}
template <class H, class T>
H getHSPRangeHash(T beg, T en, int len) {
H ans = H::ZERO;
int cur = 0;
for (T it = beg; it != en; ++it) {
if (len >= it->len) {
ans += it->getHash() * it->s.getPow(cur);
cur += it->len;
len -= it->len;
} else {
ans += it->getPartialHash(len) * it->s.getPow(cur);
break;
}
}
return ans;
}
int TB, IT;
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, int len1, T beg2, T en2, int len2) {
if (beg1 == en1 && beg2 == en2) return 0;
if (beg1 == en1) return -1;
if (beg2 == en2) return 1;
int l = 0, r = min(len1, len2) + 1;
while (r - l > 1) {
int xx = (r + l) / 2;
auto h1 = getHSPRangeHash<H, T>(beg1, en1, xx);
auto h2 = getHSPRangeHash<H, T>(beg2, en2, xx);
if (h1 == h2)
l = xx;
else
r = xx;
}
char c1 = getHSPRangeChar<H, T>(beg1, en1, l);
char c2 = getHSPRangeChar<H, T>(beg2, en2, l);
if (c1 < c2)
return -1;
else if (c1 == c2)
return 0;
else
return 1;
}
template <class H, class T>
inline int compareHSPRanges(T beg1, T en1, T beg2, T en2) {
int len1 = 0;
for (T it = beg1; it != en1; ++it) {
len1 += it->len;
}
int len2 = 0;
for (T it = beg2; it != en2; ++it) {
len2 += it->len;
}
return compareHSPRanges<H, T>(beg1, en1, len1, beg2, en2, len2);
}
int a, b, c, d, n, m, k;
char str[1000002];
int bal[2000002];
HashString<Hash> s;
inline string build(pair<pair<int, int>, int> a) {
string ans = "";
for (int _n((a.first.first) - 1), i(0); i <= _n; i++) ans += '(';
for (int _n((n)-1), i(0); i <= _n; i++) {
int cur = a.second + i;
if (cur >= n) cur -= n;
ans += str[cur];
}
for (int _n((a.first.second) - 1), i(0); i <= _n; i++) ans += ')';
return ans;
}
HashString<Hash> op, cl;
inline bool better(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b,
const HashString<Hash>& s) {
HashStringPiece<Hash> A[3] = {HashStringPiece<Hash>(op, 0, a.first.first),
HashStringPiece<Hash>(s, a.second, n),
HashStringPiece<Hash>(cl, 0, a.first.second)};
HashStringPiece<Hash> B[3] = {HashStringPiece<Hash>(op, 0, b.first.first),
HashStringPiece<Hash>(s, b.second, n),
HashStringPiece<Hash>(cl, 0, b.first.second)};
int t = compareHSPRanges<Hash>(A, A + 3, B, B + 3);
if (t == -1)
return 1;
else
return 0;
}
int main() {
gets(str);
n = (int)strlen(str);
HashString<Hash> s(str);
HashString<Hash>::precalc(2 * n + 1);
op.reserve(n + 1);
cl.reserve(n + 1);
for (int _n((n)-1), i(0); i <= _n; i++) {
op += '(';
cl += ')';
}
c = 0;
for (int _n((n)-1), i(0); i <= _n; i++) {
if (str[i] == '(')
++c;
else
--c;
}
bal[0] = 0;
for (int _n((2 * n) - 1), i(0); i <= _n; i++) {
if (i) bal[i] = bal[i - 1];
int cur = i;
if (i >= n) cur = i - n;
if (str[cur] == '(')
++bal[i];
else
--bal[i];
}
int blen = 1000000000;
pair<pair<int, int>, int> best = make_pair(make_pair(0, 0), 0);
stack<pair<int, int> > s1, s2;
for (int _n((n)-1), i(0); i <= _n; i++) {
int new_element = bal[i];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
for (int _n((n)-1), cyc(0); cyc <= _n; cyc++) {
int current_minimum = -1000000000;
if (s1.empty() || s2.empty())
current_minimum = s1.empty() ? s2.top().second : s1.top().second;
else
current_minimum = min(s1.top().second, s2.top().second);
int p = 0;
if (cyc) p = bal[cyc - 1];
int mn = current_minimum - p;
int beg = max(0, -mn);
int en = c + beg;
int len = beg + en + n;
if (len < blen ||
(len == blen && better(make_pair(make_pair(beg, en), cyc), best, s))) {
blen = len;
best = make_pair(make_pair(beg, en), cyc);
}
if (s2.empty()) {
while (!s1.empty()) {
int element = s1.top().first;
s1.pop();
int minima = s2.empty() ? element : min(element, s2.top().second);
s2.push(make_pair(element, minima));
}
}
s2.pop();
int new_element = bal[cyc + n];
int minima = s1.empty() ? new_element : min(new_element, s1.top().second);
s1.push(make_pair(new_element, minima));
}
string ans = build(best);
printf("%s\n", ans.c_str());
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<long long> p(n, 0);
p[0] = a[0];
for (int i = 1; i < n; i++) p[i] = p[i - 1] + a[i];
map<long long, long long> cnt;
for (int i = 0; i < n; i++) cnt[p[i]]++;
long long f = 0ll;
for (auto i : cnt) {
f = max(f, i.second);
}
cout << n - f;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int t = 1;
cin >> t;
for (int i = 0; i < t; ++i) {
string s;
cin >> s;
std::vector<char> ans;
int x = 0;
int n = s.length() - 1;
if (s.length() < 2) {
if (s.length() == 1) {
cout << s << endl;
} else {
if (s[0] == s[1]) {
cout << s[0] << endl;
} else {
cout << s << endl;
}
}
continue;
}
ans.push_back(s[0]);
for (int i = 1; i < s.length() - 1; ++i) {
if (s[i] == s[i + 1]) {
ans.push_back(s[i]);
i++;
x++;
} else {
ans.push_back(s[i]);
x++;
}
}
ans.push_back(s[n]);
for (auto e : ans) {
cout << e;
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s, t;
char tmp[20];
string itostr(int x) {
sprintf(tmp, "%d", x);
return tmp;
}
int main() {
int n, x, y, tmp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x >> y >> tmp;
s += "(" + itostr(x / 2) + "*((1-abs((t-" + itostr(i) + ")))+abs((abs((t-" +
itostr(i) + "))-1))))";
t += "(" + itostr(y / 2) + "*((1-abs((t-" + itostr(i) + ")))+abs((abs((t-" +
itostr(i) + "))-1))))";
if (i) s += ')', t += ')';
s += '+', t += '+';
}
s.erase(s.end() - 1), t.erase(t.end() - 1);
s = string(n - 1, '(') + s, t = string(n - 1, '(') + t;
cout << s << endl << t << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cout << i << ' ';
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 5;
const int MOD = 1e9 + 7;
const long long INF = 1061109567;
const long double EPS = 1e-9;
const long double PI = acos(-1);
long long F[MX], B[MX], T[MX];
long long qpow(long long b, long long e) {
if (!e) return 1LL;
if (e & 1LL) return (qpow(b, e - 1LL) * b) % MOD;
long long aux = qpow(b, e >> 1LL) % MOD;
return (aux * aux) % MOD;
}
long long invmod(long long n) { return qpow(n, MOD - 2) % MOD; }
long long comb(long long n, long long k) {
long long num = F[n] % MOD;
long long den = F[n - k] % MOD;
den = (den * F[k]) % MOD;
return num * invmod(den);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
F[0] = 1LL;
for (int i = (1); i < (MX); i++) F[i] = (F[i - 1] * i) % MOD;
B[0] = B[1] = T[0] = 1;
for (int i = 2; i <= 4000; i++) {
T[i - 1] = B[i - 1];
for (int j = i - 2; j >= 0; j--) T[j] = (T[j] + T[j + 1]) % MOD;
B[i] = T[0];
}
int n;
cin >> n;
long long ans = 1;
for (int i = 1; i < n; i++) {
ans = (ans + ((comb(n, i) % MOD) * (B[i] % MOD)) % MOD) % MOD;
}
cout << ans % MOD;
}
| 11 |
#include <bits/stdc++.h>
int a[100000], k[100000];
int main() {
int n, i, min = INT_MAX, max = 0;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", a + i);
if (a[i] < min) min = a[i];
if (a[i] > max) max = a[i];
}
if ((max - min) * 2 > n) {
printf("NO\n");
return 0;
}
for (i = 1; i <= n; ++i) ++k[a[i] - min];
for (i = 0; i < max - min; ++i)
if (k[i] < 1 || k[i] > k[i + 1]) {
printf("NO\n");
return 0;
} else
k[i + 1] -= k[i];
if (!k[max - min])
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 12 |
#include <bits/stdc++.h>
static int ndigits1[10], ndigits2[10];
char DP1[100000 + 1], DP2[100000 + 1];
static int n = 0;
int min(int a, int b) { return (a < b) ? a : b; }
void Digits_Permutations() {
char digit;
while ((digit = getchar()) != '\n') {
ndigits1[digit - '0']++;
ndigits2[digit - '0']++;
n++;
}
int flag = 0;
int nzero = 0;
int i, j;
for (i = 1; i < 10; i++) {
if (!ndigits1[i] || !ndigits2[10 - i]) continue;
int curnzero = 1;
ndigits1[i]--;
ndigits2[10 - i]--;
for (j = 0; j < 10; j++) curnzero += min(ndigits1[j], ndigits2[9 - j]);
curnzero += (min(ndigits1[0] - ndigits2[9], ndigits2[0] - ndigits1[9]) > 0)
? min(ndigits1[0] - ndigits2[9], ndigits2[0] - ndigits1[9])
: 0;
if (curnzero > nzero) {
flag = i;
nzero = curnzero;
}
ndigits1[i]++;
ndigits2[10 - i]++;
}
if (flag) {
ndigits1[flag]--;
ndigits2[10 - flag]--;
}
DP1[n] = DP2[n] = '\0';
i = n - 1;
for (j = min(ndigits1[0] - ndigits2[9], ndigits2[0] - ndigits1[9]); j > 0;
j--, i--, ndigits1[0]--, ndigits2[0]--)
DP1[i] = DP2[i] = '0';
if (flag) {
DP1[i] = flag + '0';
DP2[i] = 10 - flag + '0';
i--;
}
for (j = 0; j < 10; j++)
while (ndigits1[j] && ndigits2[9 - j]) {
DP1[i] = j + '0';
DP2[i] = 9 - j + '0';
i--;
ndigits1[j]--;
ndigits2[9 - j]--;
}
int cur = i;
for (j = 0; j < 10; j++)
while (ndigits1[j]) {
DP1[i--] = j + '0';
ndigits1[j]--;
}
i = cur;
for (j = 0; j < 10; j++)
while (ndigits2[j]) {
DP2[i--] = j + '0';
ndigits2[j]--;
}
printf("%s\n%s\n", DP1, DP2);
}
int main() {
Digits_Permutations();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXM = 1e4 + 5;
int dp[(1 << 16)][16][16];
int mat[16][MAXM];
int cst[16][16], trans[16][16];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> mat[i][j];
}
}
if (n == 1) {
int ans = 2e9;
for (int i = 1; i < m; i++) ans = min(ans, abs(mat[0][i] - mat[0][i - 1]));
cout << ans << endl;
return 0;
}
for (int s = 0; s < n; s++) {
for (int e = 0; e < n; e++) {
cst[s][e] = 2e9;
trans[s][e] = 2e9;
for (int i = 0; i < m; i++) {
cst[s][e] = min(cst[s][e], abs(mat[s][i] - mat[e][i]));
if (i < m - 1)
trans[s][e] = min(trans[s][e], abs(mat[s][i] - mat[e][i + 1]));
}
}
}
for (int msk = 1; msk < (1 << n); msk++) {
for (int s = 0; s < n; s++) {
for (int e = 0; e < n; e++) {
if (__builtin_popcount(msk) == 1) continue;
if (s == e) continue;
if (msk & (1 << s) == 0 || msk & (1 << e) == 0) continue;
if (__builtin_popcount(msk) == 2) {
dp[msk][s][e] = cst[s][e];
continue;
}
int nms = msk ^ (1 << s);
for (int b = 0; b < n; b++) {
if (b == e) continue;
if (nms & (1 << b))
dp[msk][s][e] = max(dp[msk][s][e], min(cst[s][b], dp[nms][b][e]));
}
}
}
}
int ans = 0;
for (int s = 0; s < n; s++) {
for (int e = 0; e < n; e++) {
if (s == e) continue;
ans = max(ans, min(dp[(1 << n) - 1][s][e], trans[e][s]));
}
}
cout << ans << endl;
}
| 12 |
#include <bits/stdc++.h>
double const EPS = 3e-8;
using namespace std;
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
template <class T>
inline bool read(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
const int NX = 1005;
int inp[NX];
int main() {
int ans = 0;
int n = ({
int a;
read(a);
a;
});
for (__typeof((n)-1) i = (0); i <= (n)-1; ++i)
inp[i] = ({
int a;
read(a);
a;
});
int i, j, k, mx;
bool ok = 1;
while (ok) {
ok = 0;
int id = 0;
for (i = 1; i < n; i++) {
if (inp[i] >= inp[id]) {
id = i;
ok = 1;
}
}
if (id == 0) break;
inp[0]++;
inp[id]--;
ans++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace SA {
const int Max_N(600050);
int N, SA[Max_N], wa[Max_N], wb[Max_N], Cnt[Max_N], Rank[Max_N], Height[Max_N],
Log[Max_N], ST[20][Max_N];
char S[Max_N];
void getSA() {
int M = 128, *x = wa, *y = wb;
for (int i = 1; i <= N; ++i) ++Cnt[x[i] = S[i]];
for (int i = 1; i <= M; ++i) Cnt[i] += Cnt[i - 1];
for (int i = N; i >= 1; --i) SA[Cnt[x[i]]--] = i;
for (int k = 1, p; k <= N; k <<= 1) {
p = 0;
for (int i = N - k + 1; i <= N; ++i) y[++p] = i;
for (int i = 1; i <= N; ++i)
if (SA[i] > k) y[++p] = SA[i] - k;
memset(Cnt, 0, sizeof(Cnt));
for (int i = 1; i <= N; ++i) ++Cnt[x[i]];
for (int i = 1; i <= M; ++i) Cnt[i] += Cnt[i - 1];
for (int i = N; i >= 1; --i) SA[Cnt[x[y[i]]]--] = y[i];
swap(x, y), x[SA[1]] = p = 1;
for (int i = 2; i <= N; ++i) {
if (y[SA[i - 1]] != y[SA[i]] || y[SA[i - 1] + k] != y[SA[i] + k]) ++p;
x[SA[i]] = p;
}
if ((M = p) == N) break;
}
for (int i = 1; i <= N; ++i) Rank[SA[i]] = i;
for (int i = 1, j, k = 0; i <= N; ++i) {
if (k) --k;
j = SA[Rank[i] - 1];
while (S[i + k] == S[j + k]) ++k;
Height[Rank[i]] = k;
}
Log[0] = Log[1] = 0;
for (int i = 2; i <= N; ++i) Log[i] = Log[i >> 1] + 1;
for (int i = 1; i <= N; ++i) ST[0][i] = Height[i];
for (int j = 1; (1 << j) <= N; ++j)
for (int i = 1; i + (1 << j) - 1 <= N; ++i)
ST[j][i] = min(ST[j - 1][i], ST[j - 1][i + (1 << (j - 1))]);
}
inline int rmq(int l, int r) {
int k = Log[r - l + 1];
return min(ST[k][l], ST[k][r - (1 << k) + 1]);
}
inline int lcp(int l1, int r1, int l2, int r2) {
return l1 == l2
? min(r1 - l1 + 1, r2 - l2 + 1)
: min(rmq(min(Rank[l1], Rank[l2]) + 1, max(Rank[l1], Rank[l2])),
min(r1 - l1 + 1, r2 - l2 + 1));
}
} // namespace SA
const int Max_N(300050);
int N, Head[Max_N], Total, To[Max_N << 1], Next[Max_N << 1], Father[Max_N],
Deep[Max_N], Size[Max_N], Son[Max_N], Top[Max_N], dfsclock, Pre[Max_N],
ID[Max_N];
char V[Max_N];
inline void Add_Edge(int s, int t) {
++Total, To[Total] = t, Next[Total] = Head[s], Head[s] = Total;
}
void dfs1(int u) {
Size[u] = 1;
for (int i = Head[u], v; i; i = Next[i])
if ((v = To[i]) != Father[u]) {
Father[v] = u, Deep[v] = Deep[u] + 1, dfs1(v), Size[u] += Size[v];
if (Size[v] > Size[Son[u]]) Son[u] = v;
}
}
void dfs2(int u) {
ID[Pre[u] = ++dfsclock] = u;
int v;
if (v = Son[u]) Top[v] = Top[u], dfs2(v);
for (int i = Head[u]; i; i = Next[i])
if ((v = To[i]) != Father[u] && v != Son[u]) Top[v] = v, dfs2(v);
}
int LCA(int u, int v) {
int r1(Top[u]), r2(Top[v]);
while (r1 != r2) {
if (Deep[r1] < Deep[r2]) swap(r1, r2), swap(u, v);
u = Father[r1], r1 = Top[u];
}
if (Deep[u] > Deep[v]) swap(u, v);
return u;
}
struct seg {
int l, r;
void give(int _l, int _r) { l = _l, r = _r; }
void give(int _l, int _r, bool rev) {
if (rev)
give(N + (N - _r + 1), N + (N - _l + 1));
else
give(_l, _r);
}
};
int CX, CY;
seg X[Max_N], Y[Max_N];
void get(int &n, seg *V, int s, int t) {
n = 0;
int lca = LCA(s, t);
for (int r = Top[s]; r != Top[lca]; s = Father[r], r = Top[s])
V[++n].give(Pre[r], Pre[s], true);
V[++n].give(Pre[lca], Pre[s], true);
int _n = n;
for (int r = Top[t]; r != Top[lca]; t = Father[r], r = Top[t])
V[++n].give(Pre[r], Pre[t], false);
if (Pre[lca] + 1 <= Pre[t]) V[++n].give(Pre[lca] + 1, Pre[t], false);
reverse(V + _n + 1, V + n + 1);
}
int main() {
scanf("%d", &N);
scanf("%s", V + 1);
for (int i = 1, u, v; i != N; ++i)
scanf("%d%d", &u, &v), Add_Edge(u, v), Add_Edge(v, u);
dfs1(1), Top[1] = 1, dfs2(1);
for (int i = 1; i <= N; ++i) SA::S[++SA::N] = V[ID[i]];
for (int i = N; i >= 1; --i) SA::S[++SA::N] = V[ID[i]];
SA::getSA();
int M;
scanf("%d", &M);
for (int a, b, c, d, Ans; M--;) {
scanf("%d%d%d%d", &a, &b, &c, &d), get(CX, X, a, b), get(CY, Y, c, d),
Ans = 0;
for (int i = 1, j = 1, p = 0, q = 0, lcp, flag; i <= CX && j <= CY;) {
flag = 0;
lcp = SA::lcp(X[i].l + p, X[i].r, Y[j].l + q, Y[j].r);
Ans += lcp, p += lcp, q += lcp;
if (X[i].l + p > X[i].r) ++i, p = 0, flag = 1;
if (Y[j].l + q > Y[j].r) ++j, q = 0, flag = 1;
if (flag == 0) break;
}
printf("%d\n", Ans);
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 20;
char str[maxn];
void work() {
scanf("%s", str + 1);
int lenstr = strlen(str + 1);
int tdi = (1e9 + 20);
for (int i = 1; str[i]; i++) {
if (str[i] == '.') {
tdi = i;
break;
}
}
int begin = 1, end = lenstr;
if (tdi != (1e9 + 20)) {
while (end >= tdi && str[end] == '0') {
end--;
}
if (end == tdi) {
end--;
}
}
while (begin <= tdi && str[begin] == '0') {
begin++;
}
int di = (1e9 + 20);
for (int i = begin; i <= end; i++) {
if (str[i] == '.') {
di = i;
break;
}
}
if (di == (1e9 + 20)) {
if (begin == end) {
printf("%c", str[begin]);
return;
}
int ans = end - begin;
int tend = end;
while (tend >= begin && str[tend] == '0') {
tend--;
}
if (tend == begin) {
printf("%cE%d\n", str[begin], ans);
} else {
printf("%c.", str[begin]);
for (int i = begin + 1; i <= tend; i++) {
printf("%c", str[i]);
}
printf("E%d\n", ans);
}
} else {
if (begin == di) {
int ans = 1;
for (int i = begin + 1; i <= end; i++) {
if (str[i] != '0') break;
ans++;
}
int t = begin + 1;
while (t <= end && str[t] == '0') ++t;
if (t == end) {
printf("%cE%d\n", str[t], -ans);
} else {
printf("%c.", str[t]);
for (int i = t + 1; i <= end; i++) {
printf("%c", str[i]);
}
printf("E%d\n", -ans);
}
} else if (di - begin == 1) {
for (int i = begin; i <= end; i++) {
printf("%c", str[i]);
}
} else {
int ans = di - begin - 1;
printf("%c.", str[begin]);
for (int i = begin + 1; i <= end; i++) {
if (str[i] == '.') continue;
printf("%c", str[i]);
}
printf("E%d\n", ans);
}
}
}
int main() {
work();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxl = 18;
vector<int> t[maxn];
int par[maxl][maxn], h[maxn];
int n, Time = 1, st[maxn];
struct node {
int mxm;
int mnm;
int sndmxm;
int sndmnm;
node(int mxm_ = 0, int mnm_ = 0) {
mxm = mxm_;
sndmxm = mxm_;
mnm = mnm_;
sndmnm = mnm_;
}
void updatemxm(node a, node b) {
vector<pair<int, int> > t;
t.push_back({st[a.mxm], a.mxm});
t.push_back({st[a.sndmxm], a.sndmxm});
t.push_back({st[b.mxm], b.mxm});
t.push_back({st[b.sndmxm], b.sndmxm});
sort(t.begin(), t.end());
mxm = t[3].second;
sndmxm = t[2].second;
}
void updatemnm(node a, node b) {
vector<pair<int, int> > t;
t.push_back({st[a.mnm], a.mnm});
t.push_back({st[a.sndmnm], a.sndmnm});
t.push_back({st[b.mnm], b.mnm});
t.push_back({st[b.sndmnm], b.sndmnm});
sort(t.begin(), t.end());
mnm = t[0].second;
sndmnm = t[1].second;
}
} seg[4 * maxn];
node merge(node fi, node se) {
node T;
T.updatemxm(fi, se);
T.updatemnm(fi, se);
return T;
}
node get(int id, int L, int R, int l, int r) {
if (r <= L or R <= l) return node(0, n + 1);
if (l <= L and R <= r) return seg[id];
int mid = (L + R) >> 1;
return merge(get(2 * id + 0, L, mid, l, r), get(2 * id + 1, mid, R, l, r));
}
void build(int id, int L, int R) {
if (L + 1 == R) {
seg[id].mxm = seg[id].mnm = L;
seg[id].sndmxm = 0;
seg[id].sndmnm = n + 1;
return;
}
int mid = (L + R) >> 1;
build(2 * id + 0, L, mid);
build(2 * id + 1, mid, R);
seg[id] = merge(seg[2 * id + 0], seg[2 * id + 1]);
}
void dfs(int v, int p = -1) {
st[v] = Time++;
par[0][v] = p;
for (int i = 1; par[i - 1][v] != -1 and i < maxl; i++)
par[i][v] = par[i - 1][par[i - 1][v]];
for (auto u : t[v]) {
h[u] = h[v] + 1;
dfs(u, v);
}
}
int lca(int v, int u) {
if (h[v] < h[u]) return lca(u, v);
for (int i = maxl - 1; i >= 0; i--)
if (h[v] - (1 << i) >= h[u]) v = par[i][v];
if (v == u) return v;
for (int i = maxl - 1; i >= 0; i--) {
if (par[i][v] != par[i][u]) {
v = par[i][v];
u = par[i][u];
}
}
return par[0][v];
}
int main() {
ios_base::sync_with_stdio(false);
int q;
cin >> n >> q;
for (int v = 2; v <= n; v++) {
int u;
cin >> u;
t[u].push_back(v);
}
int root = 1;
memset(par, -1, sizeof par);
st[0] = 0, st[n + 1] = n + 1;
dfs(root);
build(1, 1, n + 1);
for (int query = 1; query <= q; query++) {
int l, r;
cin >> l >> r;
node T = get(1, 1, n + 1, l, r + 1);
int fi = lca(T.sndmxm, T.mnm);
int se = lca(T.sndmnm, T.mxm);
if (h[fi] >= h[se])
cout << T.mxm << " ";
else
cout << T.mnm << " ";
cout << max(h[fi], h[se]) << '\n';
}
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
ostream &operator<<(ostream &o, const vector<T> &v) {
for (size_t i = 0; i < v.size(); i++)
o << v[i] << (i + 1 != v.size() ? " " : "");
return o;
}
template <int n, class... T>
typename enable_if<(n >= sizeof...(T))>::type _ot(ostream &,
tuple<T...> const &) {}
template <int n, class... T>
typename enable_if<(n < sizeof...(T))>::type _ot(ostream &os,
tuple<T...> const &t) {
os << (n == 0 ? "" : ", ") << get<n>(t);
_ot<n + 1>(os, t);
}
template <class... T>
ostream &operator<<(ostream &o, tuple<T...> const &t) {
o << "(";
_ot<0>(o, t);
o << ")";
return o;
}
template <class T, class U>
ostream &operator<<(ostream &o, pair<T, U> const &p) {
o << "(" << p.first << ", " << p.second << ")";
return o;
}
int a[3000], b[3000];
vector<int> v[3001];
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
int n, m;
cin >> m >> n;
ll ans = 1e18;
for (int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
a[i]--;
v[a[i]].emplace_back(b[i]);
}
for (int j = 0; j <= n; j++) {
sort(begin(v[j]), end(v[j]));
}
for (int i = max(1, (int)v[0].size()); i <= m; i++) {
(42);
ll res = 0;
int cnt = v[0].size();
vector<int> rest;
for (int j = 1; j < n; j++) {
for (int k = 0; k < (int)v[j].size() - (i - 1); k++) {
res += v[j][k];
cnt++;
}
for (int k = max(0, (int)v[j].size() - (i - 1)); k < (int)v[j].size();
k++) {
rest.emplace_back(v[j][k]);
}
}
sort(begin(rest), end(rest));
int t = 0;
while (cnt < i) {
res += rest[t];
cnt++;
t++;
}
ans = min(ans, res);
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long a, root=0;
cin >> a;
while(a!=0) {
root += a%10;
a /= 10;
}
root %= 9;
if(root==0)
root = 9;
cout << root << endl;
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
int n, q, m, ans;
int x[100001];
vector<int> v;
int binary(int m) {
int l = 0, r = n - 1, mid, midc;
if (m < x[0]) return 0;
while (l <= r) {
mid = (l + r) / 2;
if (x[mid] > m)
r = mid - 1;
else
l = mid + 1, midc = mid;
}
return midc + 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> x[i];
sort(x, x + n);
cin >> q;
for (int i = 0; i < q; i++) {
cin >> m;
v.push_back(binary(m));
}
for (int i = 0; i < q; i++) cout << v[i] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int nsz = 2e5;
int n, m;
struct data {
int q, w;
data() {}
data(int q, int w) {
this->q = q;
this->w = w;
}
};
data dat[nsz + 5];
bool inline operator<(data a, data b) {
return a.q != b.q ? a.q > b.q : a.w < b.w;
}
struct treap {
int rt, sz, s[nsz + 5][2], val[nsz + 5], key[nsz + 5], cnt[nsz + 5],
siz[nsz + 5], del[nsz + 5][2];
void inline chg(int u, int v1, int v2) {
val[u] += v1;
cnt[u] += v2;
del[u][0] += v1;
del[u][1] += v2;
}
void inline up(int u) { siz[u] = siz[s[u][0]] + siz[s[u][1]] + 1; }
void inline down(int u) {
if (!del[u][0] && !del[u][1]) return;
int ls = s[u][0], rs = s[u][1];
if (ls) {
chg(ls, del[u][0], del[u][1]);
}
if (rs) {
chg(rs, del[u][0], del[u][1]);
}
del[u][0] = del[u][1] = 0;
}
int inline node(int w) {
int u = ++sz;
val[u] = w;
siz[u] = 1;
key[u] = rand();
return u;
}
int merge(int v1, int v2) {
if (!v1 || !v2) return v1 | v2;
if (key[v1] > key[v2]) {
down(v1);
s[v1][1] = merge(s[v1][1], v2);
up(v1);
return v1;
} else {
down(v2);
s[v2][0] = merge(v1, s[v2][0]);
up(v2);
return v2;
}
}
void split(int u, int w, int &v1, int &v2) {
if (!u) {
v1 = v2 = 0;
return;
}
down(u);
if (val[u] <= w) {
v1 = u;
split(s[u][1], w, s[u][1], v2);
} else {
v2 = u;
split(s[u][0], w, v1, s[u][0]);
}
up(u);
}
void ins(int w) {
int v1, v2;
split(rt, w, v1, v2);
rt = merge(merge(v1, node(w)), v2);
}
void ins(int &u, int v) {
int v1, v2;
split(u, val[v], v1, v2);
u = merge(merge(v1, v), v2);
}
};
treap tr;
void print(int u = tr.rt) {
int ls = tr.s[u][0], rs = tr.s[u][1];
cout << u << ": " << tr.val[u] << ", " << tr.cnt[u] << '\n';
if (ls) {
cout << "-> " << ls << '\n';
print(ls);
}
if (rs) {
cout << "-> " << rs << '\n';
print(rs);
}
}
void down(int u = tr.rt) {
int ls = tr.s[u][0], rs = tr.s[u][1];
tr.down(u);
if (ls) {
down(ls);
}
if (rs) {
down(rs);
}
}
void ins(int &to, int u) {
tr.down(u);
int ls = tr.s[u][0], rs = tr.s[u][1];
if (ls) {
ins(to, ls);
}
if (rs) {
ins(to, rs);
}
tr.s[u][0] = tr.s[u][1] = 0;
tr.ins(to, u);
}
void inline upd(int w) {
int v1, v2, v3;
tr.split(tr.rt, w - 1, v1, v2);
if (v2) {
tr.chg(v2, -w, 1);
tr.split(v2, w - 1, v2, v3);
if (v2) {
ins(v1, v2);
}
tr.rt = tr.merge(v1, v3);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> dat[i].w >> dat[i].q;
}
sort(dat + 1, dat + n + 1);
cin >> m;
for (int i = 1; i <= m; ++i) {
int w;
cin >> w;
tr.ins(w);
}
for (int i = 1; i <= n; ++i) {
int w = dat[i].w;
upd(w);
}
down();
for (int i = 1; i <= m; ++i) {
cout << tr.cnt[i] << ' ';
}
cout << '\n';
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double EPS = 1e-7;
long long N;
long long duaPangkat[25];
long long ans[1000005];
long long leftMostBit(long long x) {
long long ans = 0;
while (x > 0) ans++, x /= 2LL;
return ans;
}
int main() {
scanf("%I64d", &N);
memset(ans, -1, sizeof ans);
for (long long i = N; i >= 0; i--) {
if (ans[i] != -1) continue;
ans[i] = i ^ ((1LL << (leftMostBit(i))) - 1);
ans[i ^ ((1LL << (leftMostBit(i))) - 1)] = i;
}
printf("%I64d\n", N * (N + 1));
for (long long i = 0; i <= N; i++) {
printf("%I64d", ans[i]);
if (i <= N - 1) printf(" ");
}
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2410;
int n, l, r, a[N];
vector<int> p;
tuple<int, int, int> tmp[2];
vector<tuple<int, int, int>> ans;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1, x; i <= 3 * n; i++) cin >> x, a[x] = 1;
for (int i = 1; i <= 6 * n; i++) p.push_back(i);
for (int i = 1; i <= 2 * n; i++) {
l = 0, r = p.size() - 1;
while (l < r && a[p[l]] == a[p[l + 1]] && a[p[l]] == a[p[l + 2]])
tmp[a[p[l]]] = {p[l], p[l + 1], p[l + 2]}, l += 3;
while (l < r && a[p[r]] == a[p[r - 1]] && a[p[r]] == a[p[r - 2]])
tmp[a[p[r]]] = {p[r - 2], p[r - 1], p[r]}, r -= 3;
if (l < r) {
for (int j = l; j + 2 <= r; j++)
if ((i & 1) == a[p[j]] && (i & 1) == a[p[j + 1]] &&
(i & 1) == a[p[j + 2]]) {
ans.push_back({p[j], p[j + 1], p[j + 2]});
goto next;
}
}
ans.push_back(tmp[i & 1]);
next:
p.erase(find(p.begin(), p.end(), get<0>(ans.back())));
p.erase(find(p.begin(), p.end(), get<1>(ans.back())));
p.erase(find(p.begin(), p.end(), get<2>(ans.back())));
}
for (const auto &it : ans)
cout << get<0>(it) << " " << get<1>(it) << " " << get<2>(it) << endl;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tot, temps, tempx;
cin >> tot >> temps >> tempx;
if (!tempx && !tot)
cout << "YES\n";
else if (tempx < tot)
cout << "NO\n";
else if (tempx == tot)
cout << "YES\n";
else if (temps == 0) {
if (tempx == tot + 1)
cout << "YES\n";
else
cout << "NO\n";
} else {
if ((tempx - tot) % temps && (tempx - tot - 1) % temps)
cout << "NO\n";
else if (((tempx - tot) / temps + 1) >= 2)
cout << "YES\n";
else if (((tempx - tot - 1) / temps + 1) >= 2)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, i, s[100010], sum[100010], k, conta;
struct bus {
int in, fi;
};
bus v[100010];
bool acompare(bus lhs, bus rhs) { return lhs.fi < rhs.fi; }
int main() {
ifstream in("input.txt");
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> v[i].in;
cin >> v[i].fi;
if (v[i].fi == n) conta++;
}
sort(v, v + m + 1, acompare);
s[0] = sum[0] = 1;
int ciao = 0, x = 1;
for (i = 1; i <= m; i++) {
if (v[i].fi == ciao)
x++;
else {
ciao = v[i].fi;
x = 1;
}
bus tmp = {0, v[i].in};
auto ind = lower_bound(v, v + m + 1, tmp, acompare);
int cel = (int)(ind - v);
if (cel)
s[i] = (sum[i - x] - sum[cel - 1] + 1000000007) % 1000000007;
else
s[i] = sum[i - x];
sum[i] = (sum[i - 1] + s[i]) % 1000000007;
}
cout << (sum[m] - sum[m - conta] + 1000000007) % 1000000007;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int N, M;
cin >> N >> M;
vector<pair<int, int>> ants(N);
for (int i = 0; i < N; ++i) {
cin >> ants[i].first >> ants[i].second;
M = max(M, ants[i].first + ants[i].second);
}
sort(ants.begin(), ants.end());
vector<vector<int>> dp(N + 1, vector<int>(M + 1, 3 * M));
vector<vector<int>> suffix_min(N + 1, vector<int>(M + 1, 3 * M));
for (int i = 0; i < N; ++i) {
int l = ants[i].first - ants[i].second;
int r = ants[i].first + ants[i].second;
;
for (int j = 1; j <= M; ++j) {
dp[i][j] = 3 * M;
if (i > 0) dp[i][j] = dp[i - 1][j];
if (j < r) continue;
int ldelta = max(0, l - 1);
int rdelta = max(0, j - r);
dp[i][j] = min(dp[i][j], max(ldelta, rdelta));
int delta = j - r;
int new_l = max(1, l - delta);
if (i != 0 || new_l == 1) {
dp[i][j] = min(
dp[i][j],
delta + (new_l == 1 || i == 0 ? 0 : suffix_min[i - 1][new_l - 1]));
}
}
for (int j = M; j >= 1; --j) {
suffix_min[i][j] = dp[i][j];
if (j < M) {
suffix_min[i][j] = min(suffix_min[i][j], suffix_min[i][j + 1]);
}
}
}
int answer = 3 * M;
for (int i = 0; i < N; ++i) {
answer = min(answer, dp[i][M]);
}
cout << answer << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int following[1005];
int queueLength[1005];
int okQueue[1005];
int main() {
int n, k;
cin >> n >> k;
int head = k, shift = 1, tmp;
for (int i = 1; i <= n; i++) {
cin >> following[i];
queueLength[i]++;
tmp = i;
while (following[tmp] != 0) {
queueLength[following[tmp]] += queueLength[i];
tmp = following[tmp];
}
}
while (following[head]) {
head = following[head];
shift++;
}
vector<int> queues;
for (int i = 1; i <= n; i++) {
if (following[i] == 0 && i != head) {
queues.push_back(queueLength[i]);
}
}
sort(queues.begin(), queues.end());
okQueue[0] = 1;
for (unsigned i = 0; i < queues.size(); i++) {
for (int j = n - queues[i]; j >= 0; j--) {
if (okQueue[j]) {
okQueue[j + queues[i]] = 1;
}
}
}
for (int i = 0; i < n; i++) {
if (okQueue[i]) printf("%d\n", i + shift);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 120010;
struct node {
int tag, val, times, num;
long long ans;
} tr[N * 4];
int n, a[N];
void build(int v = 0, int l = 0, int r = n) {
tr[v].val = l;
tr[v].num = 1;
if (l + 1 == r) return;
int mid = (l + r) / 2, chl = v * 2 + 1, chr = v * 2 + 2;
build(chl, l, mid);
build(chr, mid, r);
}
void add_val(int v, int x) {
tr[v].val += x;
tr[v].tag += x;
}
void add_times(int v, int x) {
tr[v].times += x;
tr[v].ans += (long long)tr[v].num * x;
}
void push_up(int v) {
int chl = v * 2 + 1, chr = v * 2 + 2;
tr[v].val = min(tr[chl].val, tr[chr].val);
tr[v].ans = tr[chl].ans + tr[chr].ans;
tr[v].num = 0;
if (tr[v].val == tr[chl].val) tr[v].num += tr[chl].num;
if (tr[v].val == tr[chr].val) tr[v].num += tr[chr].num;
}
void push_down(int v) {
int chl = v * 2 + 1, chr = v * 2 + 2;
if (tr[v].tag) {
add_val(chl, tr[v].tag);
add_val(chr, tr[v].tag);
tr[v].tag = 0;
}
if (tr[v].times) {
if (tr[v].val == tr[chl].val) add_times(chl, tr[v].times);
if (tr[v].val == tr[chr].val) add_times(chr, tr[v].times);
tr[v].times = 0;
}
}
void modify(int L, int R, int x, int v = 0, int l = 0, int r = n) {
if (r <= L || R <= l) return;
if (L <= l && r <= R) {
add_val(v, x);
return;
}
push_down(v);
int mid = (l + r) / 2, chl = v * 2 + 1, chr = v * 2 + 2;
modify(L, R, x, chl, l, mid);
modify(L, R, x, chr, mid, r);
push_up(v);
}
long long query(int L, int R, int v = 0, int l = 0, int r = n) {
if (r <= L || R <= l) return 0;
if (L <= l && r <= R) return tr[v].ans;
push_down(v);
int mid = (l + r) / 2, chl = v * 2 + 1, chr = v * 2 + 2;
long long res = query(L, R, chl, l, mid) + query(L, R, chr, mid, r);
push_up(v);
return res;
}
int stack_min[N] = {-1}, stack_max[N] = {-1}, top_min, top_max;
vector<pair<int, int> > queries[N];
long long ans[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
build();
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int l, r;
scanf("%d%d", &l, &r);
--l, --r;
queries[r].push_back(pair<int, int>(l, i));
}
for (int i = 0; i < n; i++) {
add_val(0, -1);
while (top_max > 0 && a[stack_max[top_max]] < a[i]) {
modify(stack_max[top_max - 1] + 1, stack_max[top_max] + 1,
a[i] - a[stack_max[top_max]]);
--top_max;
}
stack_max[++top_max] = i;
while (top_min > 0 && a[stack_min[top_min]] > a[i]) {
modify(stack_min[top_min - 1] + 1, stack_min[top_min] + 1,
a[stack_min[top_min]] - a[i]);
--top_min;
}
stack_min[++top_min] = i;
add_times(0, 1);
for (auto qry : queries[i]) {
ans[qry.second] = query(qry.first, n);
}
}
for (int i = 0; i < q; i++) printf("%lld\n", ans[i]);
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
void printList(list<int>* list) {
cout << "list : ";
for (__typeof((*list).begin()) li = ((*list).begin()); li != (*list).end();
++li) {
cout << *li << ",";
}
cout << endl;
}
void printT_VPII(vector<pair<int, int> > v) {
cout << "list : ";
for (__typeof((v).begin()) li = ((v).begin()); li != (v).end(); ++li) {
cout << " ( " << (*li).first << " , " << (*li).second << " ) ,";
}
cout << endl;
}
unsigned int n, m;
map<int, list<int>*> nodeToListPointer;
set<list<int>*> listPointers;
set<pair<int, int> > oldEdges;
vector<pair<int, int> > validEdges;
bool buildValidEdgeSetFromGraph(set<pair<int, int> >& buildGraph,
vector<int>& graus, int lastUsedEdgeIndex) {
if (buildGraph.size() == m) return true;
for (__typeof(lastUsedEdgeIndex + 1) i = (lastUsedEdgeIndex + 1);
i <= (static_cast<int>(validEdges.size()) - 1); ++i) {
pair<int, int> edge = validEdges[i];
if (graus[edge.first] >= 2 or graus[edge.second] >= 2) continue;
buildGraph.insert(edge);
graus[edge.first]++;
graus[edge.second]++;
bool resolved = buildValidEdgeSetFromGraph(buildGraph, graus, i);
if (resolved) return true;
buildGraph.erase(edge);
graus[edge.first]--;
graus[edge.second]--;
}
return false;
}
void resolveBruteForce() {
set<pair<int, int> > validEdgeSet;
for (__typeof(1) i = (1); i <= (n - 1); ++i)
for (__typeof(i + 1) j = (i + 1); j <= (n); ++j) {
validEdgeSet.insert(pair<int, int>(i, j));
}
for (__typeof(m) i = 0; i < (m); ++i) {
unsigned int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
oldEdges.insert(pair<int, int>(u, v));
validEdgeSet.erase(pair<int, int>(u, v));
}
validEdges =
vector<pair<int, int> >((validEdgeSet).begin(), (validEdgeSet).end());
set<pair<int, int> > result;
vector<int> graus = vector<int>(n + 1, 0);
bool resolved = buildValidEdgeSetFromGraph(result, graus, -1);
if (not resolved)
cout << "-1" << endl;
else {
for (__typeof((result).begin()) e = ((result).begin()); e != (result).end();
++e) {
pair<int, int> edge = *e;
cout << edge.first << " " << edge.second << endl;
}
}
}
int main() {
cin >> n >> m;
if (n < 10) {
resolveBruteForce();
return EXIT_SUCCESS;
}
for (__typeof(m) i = 0; i < (m); ++i) {
unsigned int u, v;
cin >> u >> v;
list<int>* listEdgeNode_u = NULL;
list<int>* listEdgeNode_v = NULL;
if (nodeToListPointer.count(u)) listEdgeNode_u = nodeToListPointer[u];
if (nodeToListPointer.count(v)) listEdgeNode_v = nodeToListPointer[v];
if (listEdgeNode_v == NULL and listEdgeNode_u == NULL) {
listEdgeNode_u = listEdgeNode_v = new list<int>();
listEdgeNode_u->push_back(u);
listEdgeNode_u->push_back(v);
listPointers.insert(listEdgeNode_u);
nodeToListPointer[u] = nodeToListPointer[v] = listEdgeNode_u;
} else if (listEdgeNode_v == listEdgeNode_u) {
} else if (listEdgeNode_v == NULL or listEdgeNode_u == NULL) {
list<int>* listEdgeNode =
listEdgeNode_v == NULL ? listEdgeNode_u : listEdgeNode_v;
if (listEdgeNode->front() == u)
listEdgeNode->push_front(v);
else if (listEdgeNode->front() == v)
listEdgeNode->push_front(u);
else if (listEdgeNode->back() == v)
listEdgeNode->push_back(u);
else if (listEdgeNode->back() == u)
listEdgeNode->push_back(v);
else {
}
nodeToListPointer[u] = nodeToListPointer[v] = listEdgeNode;
} else {
if (listEdgeNode_v->front() == listEdgeNode_u->front()) {
listEdgeNode_u->reverse();
listEdgeNode_u->splice(listEdgeNode_u->end(), *listEdgeNode_v);
delete (listEdgeNode_v);
listPointers.erase(listEdgeNode_v);
nodeToListPointer[v] = listEdgeNode_u;
} else if (listEdgeNode_v->back() == listEdgeNode_u->back()) {
listEdgeNode_v->reverse();
listEdgeNode_u->splice(listEdgeNode_u->end(), *listEdgeNode_v);
delete (listEdgeNode_v);
listPointers.erase(listEdgeNode_v);
nodeToListPointer[v] = listEdgeNode_u;
} else if (listEdgeNode_v->front() == listEdgeNode_u->back()) {
listEdgeNode_u->splice(listEdgeNode_u->end(), *listEdgeNode_v);
delete (listEdgeNode_v);
listPointers.erase(listEdgeNode_v);
nodeToListPointer[v] = listEdgeNode_u;
} else if (listEdgeNode_v->front() == listEdgeNode_u->back()) {
listEdgeNode_v->splice(listEdgeNode_v->end(), *listEdgeNode_u);
delete (listEdgeNode_u);
listPointers.erase(listEdgeNode_u);
nodeToListPointer[u] = listEdgeNode_v;
} else {
}
}
}
list<int>* subgraph = NULL;
{
int numNodes = 0;
for (__typeof((listPointers).begin()) lp = ((listPointers).begin());
lp != (listPointers).end(); ++lp) {
list<int>* g = *lp;
if (g->size() > numNodes) {
numNodes = g->size();
subgraph = g;
}
}
}
if (m / 2 <= subgraph->size()) {
list<int>* oddList = new list<int>();
list<int>* evenList = new list<int>();
bool odd = true;
for (__typeof((*subgraph).begin()) v = ((*subgraph).begin());
v != (*subgraph).end(); ++v) {
if (odd)
oddList->push_back(*v);
else
evenList->push_back(*v);
odd = !odd;
}
oddList->splice(oddList->end(), *evenList);
delete (evenList);
listPointers.erase(subgraph);
delete (subgraph);
subgraph = oddList;
if (subgraph->size() % 2 == 0) {
list<int>::iterator ite1, ite2;
ite1 = ite2 = subgraph->begin();
ite1++;
swap(*ite1, *ite2);
}
} else {
listPointers.erase(subgraph);
}
list<int>::iterator it = subgraph->begin();
for (__typeof((listPointers).begin()) listPointerIte =
((listPointers).begin());
listPointerIte != (listPointers).end(); ++listPointerIte) {
list<int>* listToMergePtr = *listPointerIte;
for (__typeof((*listToMergePtr).begin()) uIte = ((*listToMergePtr).begin());
uIte != (*listToMergePtr).end(); ++uIte) {
if (it == subgraph->end()) it = subgraph->begin();
subgraph->insert(it++, *uIte);
}
delete (listToMergePtr);
}
{
cout << subgraph->back() << " " << subgraph->front() << endl;
int numPrintedEdges = 1;
int lastU = subgraph->front();
subgraph->pop_front();
for (__typeof((*subgraph).begin()) uIte = ((*subgraph).begin());
uIte != (*subgraph).end(); ++uIte) {
if (numPrintedEdges == m) break;
cout << lastU << " " << *uIte << endl;
lastU = *uIte;
numPrintedEdges++;
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int m, k, n, s, req[500010], cnt[500010], a[500010];
int cmp[500010], ans[500010];
void init() {
for (int i = 0; i < 500010; ++i) cmp[i] = -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> m >> k >> n >> s;
init();
for (int i = 0; i < m; ++i) cin >> a[i];
for (int i = 0; i < s; ++i) {
int x;
cin >> x;
req[x]++;
}
int tt = 0;
for (int i = 0; i < 500010; ++i) {
if (req[i] > 0) tt++;
}
int L = 0, R = 0, curr = 0;
while (L < m) {
if (curr == tt) cmp[R - 1] = max(cmp[R - 1], L);
if (curr < tt && R < m) {
cnt[a[R]]++;
if (cnt[a[R]] == req[a[R]] && req[a[R]]) curr++;
R++;
} else {
if (cnt[a[L]] == req[a[L]] && req[a[L]]) curr--;
cnt[a[L]]--;
L++;
}
}
int pos = -1;
for (int i = 0; i < m; ++i) {
if (cmp[i] == -1) continue;
int l = cmp[i];
int t = l / k;
int rm = l % k;
rm += (i - l + 1);
int u = i + max(0, k - rm);
if (u >= m) continue;
t++;
t += (m - 1 - u) / k;
if (t >= n) {
pos = i;
break;
}
}
int p = pos;
if (p == -1) {
cout << -1;
return 0;
}
int l = cmp[p];
for (int i = 0; i < 500010; ++i) cnt[i] = 0;
for (int i = l; i <= p; i++) {
if (cnt[a[i]] < req[a[i]]) {
ans[i] = 1;
cnt[a[i]]++;
}
}
int kk = 0;
for (int i = l; i <= p; i++) {
kk += ans[i];
}
for (int i = l; i <= p; i++) {
if (kk == k) break;
if (ans[i] == 0) {
ans[i] = 1;
kk++;
}
}
int ss = (l / k) * k;
for (int i = ss; i < l; i++) {
if (kk == k) break;
ans[i] = 1;
kk++;
}
int r = p + 1;
while (kk < k) {
ans[r] = 1;
r++;
kk++;
}
int t = min(ss / k, n - 1);
for (int i = 0; i < t * k; ++i) {
ans[i] = 1;
}
int done = t + 1;
done = n - done;
for (int i = r; i < r + k * done; i++) {
ans[i] = 1;
}
int d = 0;
for (int i = 0; i < m; ++i) {
if (ans[i] == 0) d++;
}
cout << d << endl;
for (int i = 0; i < m; ++i) {
if (ans[i] == 0) cout << i + 1 << " ";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int k;
cin >> k;
int l = s.size();
if (l % k == 0) {
int g = l / k;
int cnt = 0;
for (int i = 0; i < s.size(); i++) {
string t = "";
int f = i + g;
for (int j = i; j < f; j++) {
t += s[j];
i = j;
}
string r = t;
reverse(t.begin(), t.end());
if (r == t) {
cnt++;
}
}
if (cnt == k) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
} else {
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ot[2002][2002];
int ob[2002][2002];
int ov[2002][2002];
int oo[2002][2002];
string ma[2002];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> ma[i];
}
for (int i = 0; i < n; i++) {
for (int ii = 0; ii < m; ii++) {
if (ma[i][ii] == '#') break;
ov[i][ii] = 1;
}
for (int ii = m - 1; ii >= 0; ii--) {
if (ma[i][ii] == '#') break;
oo[i][ii] = 1;
}
}
for (int ii = 0; ii < m; ii++) {
for (int i = 0; i < n; i++) {
if (ma[i][ii] == '#') break;
ot[i][ii] = 1;
}
for (int i = n - 1; i >= 0; i--) {
if (ma[i][ii] == '#') break;
ob[i][ii] = 1;
}
}
long long v = 0;
for (int i = 1; i < n - 1; i++) {
long long ok = 0;
long long vi = 0;
for (int ii = 1; ii < m - 1; ii++) {
ok += ot[i][ii];
ok += ob[i][ii];
if (ot[i][ii] && ot[i][ii - 1] && ii - 1 > 0) vi++;
if (ob[i][ii] && ob[i][ii - 1] && ii - 1 > 0) vi++;
if (ot[i][ii] && ob[i][ii]) vi++;
if (ma[i][ii] == '#' || ii == m - 2) {
v += ok * (ok - 1ll) / 2ll;
v -= vi;
ok = 0;
vi = 0;
}
}
}
for (int ii = 1; ii < m - 1; ii++) {
long long ok = 0;
long long vi = 0;
for (int i = 1; i < n - 1; i++) {
ok += ov[i][ii];
ok += oo[i][ii];
if (ov[i][ii] && ov[i - 1][ii] && i - 1 > 0) vi++;
if (oo[i][ii] && oo[i - 1][ii] && i - 1 > 0) vi++;
if (ov[i][ii] && oo[i][ii]) vi++;
if (ma[i][ii] == '#' || i == n - 2) {
v += ok * (ok - 1ll) / 2ll;
v -= vi;
ok = 0;
vi = 0;
}
}
}
for (int i = 1; i < n - 1; i++) {
if (oo[i][0]) v++;
}
for (int i = 1; i < m - 1; i++) {
if (ob[0][i]) v++;
}
for (int i = 1; i < n - 1; i++) {
for (int ii = 1; ii < m - 1; ii++) {
if (ot[i][ii]) {
v += (long long)ov[i][ii];
v += (long long)oo[i][ii];
}
if (ob[i][ii]) {
v += (long long)ov[i][ii];
v += (long long)oo[i][ii];
}
}
}
cout << v << endl;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1100;
vector<int> a[MAXN];
int main() {
int m, k;
cin >> m >> k;
int n = 0;
for (int i = 1; i <= m; i++) {
int y = i + k;
for (int j = i + 1; j <= y; j++) {
if (j > m) {
y = k - (j - i - 1);
j = 1;
if (y + k >= i) {
printf("-1\n");
return 0;
}
}
n++;
a[i].push_back(j);
}
}
cout << n << endl;
for (int i = 1; i <= m; i++)
for (int j = 0; j < a[i].size(); j++) printf("%d %d\n", i, a[i][j]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
cin >> t;
while (t--) {
cin >> n;
int ans = 0;
while (n % 6 == 0 || (2 * n) % 6 == 0) {
if (n % 6 == 0) {
n /= 6;
ans++;
} else {
n /= 3;
ans += 2;
}
}
if (n == 1)
cout << ans << endl;
else
cout << "-1\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string S;
bool check;
int gender;
bool seeA;
bool seeN;
bool seeV;
bool seeS;
int main() {
getline(cin, S, '\n');
for (int i = 0; i < S.size(); i++) {
if (S[i] == ' ' || i == S.size() - 1) {
if (S[i] == ' ') {
seeS = true;
}
if (i == S.size() - 1) {
i = S.size();
}
check = false;
if (S[i - 1] == 'r' && S[i - 2] == 't' && S[i - 3] == 'e') {
check = true;
if (seeN == true || seeV == true) {
check = false;
break;
}
seeN = true;
if (gender == 0) {
gender = 2;
} else {
if (gender != 2) {
check = false;
break;
}
}
} else if (S[i - 1] == 'a' && S[i - 2] == 'r' && S[i - 3] == 't' &&
S[i - 4] == 'e') {
check = true;
if (seeN == true || seeV == true) {
check = false;
break;
}
seeN = true;
if (gender == 0) {
gender = 1;
} else {
if (gender != 1) {
check = false;
break;
}
}
} else if (S[i - 1] == 's' && S[i - 2] == 'o' && S[i - 3] == 'i' &&
S[i - 4] == 'l') {
check = true;
seeA = true;
if (seeN == true || seeV == true) {
check = false;
break;
}
if (gender == 0) {
gender = 2;
} else {
if (gender != 2) {
check = false;
break;
}
}
} else if (S[i - 1] == 'a' && S[i - 2] == 'l' && S[i - 3] == 'a' &&
S[i - 4] == 'i' && S[i - 5] == 'l') {
check = true;
seeA = true;
if (seeN == true || seeV == true) {
check = false;
break;
}
if (gender == 0) {
gender = 1;
} else {
if (gender != 1) {
check = false;
break;
}
}
} else if (S[i - 1] == 's' && S[i - 2] == 'e' && S[i - 3] == 't' &&
S[i - 4] == 'i' && S[i - 5] == 'n' && S[i - 6] == 'i') {
check = true;
seeV = true;
if (seeS == true && seeN == false) {
check = false;
break;
}
if (gender == 0) {
gender = 1;
} else {
if (gender != 1) {
check = false;
break;
}
}
} else if (S[i - 1] == 's' && S[i - 2] == 'i' && S[i - 3] == 't' &&
S[i - 4] == 'i' && S[i - 5] == 'n' && S[i - 6] == 'i') {
check = true;
seeV = true;
if (seeS == true && seeN == false) {
check = false;
break;
}
if (gender == 0) {
gender = 2;
} else {
if (gender != 2) {
check = false;
break;
}
}
} else {
check = false;
break;
}
}
}
if (check == true) {
if (seeS == true && seeN == false) {
cout << "NO";
} else {
cout << "YES";
}
} else {
cout << "NO";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string fun(int a[], int n) {
if (a[n] == 15) return "DOWN";
if (a[n] == 0) return "UP";
if (n == 1) return "-1";
if (n > 1) {
if (a[n - 1] > a[n]) return "DOWN";
return "UP";
}
}
int main() {
int n;
cin >> n;
int a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
cout << fun(a, n);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
string s;
cin >> n >> s;
int a, c, g, t, qm;
a = c = g = t = qm = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'A')
a++;
else if (s[i] == 'C')
c++;
else if (s[i] == 'G')
g++;
else if (s[i] == 'T')
t++;
else
qm++;
}
int mxm = max(a, c);
mxm = max(mxm, g);
mxm = max(mxm, t);
qm -= mxm - a;
qm -= mxm - c;
qm -= mxm - g;
qm -= mxm - t;
if (qm < 0) {
cout << "===" << endl;
return 0;
} else if (qm % 4) {
cout << "===" << endl;
return 0;
}
for (int i = 0; i < n; i++) {
if (s[i] == '?') {
int minim = min(a, min(c, min(g, t)));
if (a == minim) {
s[i] = 'A';
a++;
} else if (c == minim) {
s[i] = 'C';
c++;
} else if (g == minim) {
s[i] = 'G';
g++;
} else {
s[i] = 'T';
t++;
}
}
}
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int x, y, z;
bool operator<(const P &a) const {
if (x != a.x) return x > a.x;
return y > a.y;
}
};
vector<int> v;
int i, n, d, m, k, a, b, c;
long long o[311][111];
long long l[111][111];
int j[111111];
int e;
int dx[10] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[10] = {1, 0, -1, 0, 1, -1, 1, -1},
dz[10] = {0, 0, 0, 0, 1, -1};
long long mod = 998244353, mod2 = 1000000009, mod3 = 2017;
long long x, z, y;
double pi = 3.14159265;
P u[1];
stack<int> s;
queue<int> q;
char r[611];
map<int, int> p;
bool as(P a, P b) { return a.x + a.y > b.x + b.y; }
long long g(long long x, long long y) {
long long p = 1;
for (; y; y /= 2, x *= x, x %= mod)
if (y % 2) p *= x, p %= mod;
return p;
}
void f(int n) {
for (; n; n /= 2) {
if (n % 2) {
long long p[111][111];
for (int t = 1; t <= a; t++)
for (int w = 1; w <= a; w++) p[t][w] = 0;
for (int h = 1; h <= a; h++)
for (int t = 1; t <= a; t++)
for (int w = 1; w <= a; w++)
p[t][w] += o[t][h] * l[h][w], p[t][w] %= mod;
for (int t = 1; t <= a; t++)
for (int w = 1; w <= a; w++) l[t][w] = p[t][w];
}
long long p[111][111];
for (int t = 1; t <= a; t++)
for (int w = 1; w <= a; w++) p[t][w] = 0;
for (int h = 1; h <= a; h++)
for (int t = 1; t <= a; t++)
for (int w = 1; w <= a; w++)
p[t][w] += o[t][h] * o[h][w], p[t][w] %= mod;
for (int t = 1; t <= a; t++)
for (int w = 1; w <= a; w++) o[t][w] = p[t][w];
}
}
int main() {
scanf("%d", &a);
for (int t = 1; t <= a; l[t][t] = 1, t++) scanf("%lld", &o[a - t + 1][a]);
for (int t = 1; t <= a; t++) o[t][t - 1] = 1;
scanf("%d %d", &n, &m);
mod--;
f(n - a);
mod++;
z = g(3, l[a][a]);
k = sqrt(mod) + 1;
x = g(z, k);
for (long long t = 0, n = 1; t <= k; t++, n *= z, n %= mod) p[n] = t + 1;
z = g(x, mod - 2);
d = -1;
for (long long t = 0, n = (long long)m % mod; t <= k; t++, n *= z, n %= mod)
if (p[n]) {
c = t;
d = p[n] - 1;
break;
}
if (d >= 0)
printf("%lld", g(3, (long long)c * k + d));
else
puts("-1");
}
| 16 |
#include <bits/stdc++.h>
const double eps = 1e-9;
long long choose(int a, int b) {
double ret = 1;
for (int i = 0; i < b; i++) {
ret *= (a - i);
ret /= i + 1;
}
return (long long)(ret + eps);
}
int main() {
int n, m, t;
scanf("%d%d%d", &n, &m, &t);
long long ans = 0;
for (int i = 4; i < t; i++) ans += choose(n, i) * choose(m, t - i);
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
long a[5000];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long d = a[0] - a[1];
if (n == 2) {
cout << a[1] - d << endl;
return 0;
} else {
int cnt = 0;
for (int i = 2; i < n; i++) {
if (a[i - 1] - d != a[i]) {
cnt = 1;
}
}
if (cnt == 1) {
cout << a[n - 1] << endl;
return 0;
}
cout << a[n - 1] - d << endl;
return 0;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100100], h[100100], mx[100100];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
}
for (int i = n; i >= 1; i--) {
mx[i] = max(mx[i + 1], a[i]);
}
for (int i = 1; i <= n; i++) {
if (a[i] > mx[i + 1]) continue;
h[i] = mx[i + 1] + 1 - a[i];
}
for (int i = 1; i <= n; i++) cout << h[i] << ' ';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 11, MAXL = 500000 + 10;
struct State {
int len, fa, num[MAXN], tr[26];
State() : len(0), fa(0) {
memset(num, 0, sizeof(num));
memset(tr, 0, sizeof(tr));
}
State(int len, int fa, int numr, int ref) : len(len), fa(fa) {
memset(num, 0, sizeof(num));
memset(tr, 0, sizeof(tr));
num[ref] = numr;
}
} SAM[MAXL * 2];
int n, tot = 1, c[MAXN][2];
string str[MAXN];
void Construct_SAM(const string &str, int ref) {
int ns = str.size();
for (int cp = 1, pre = 1, i = 0, id = str[i] - 'a'; i < ns;
id = str[++i] - 'a', pre = cp) {
if (SAM[cp].tr[id] && SAM[SAM[cp].tr[id]].len == SAM[cp].len + 1) {
cp = SAM[cp].tr[id];
++SAM[cp].num[ref];
continue;
}
cp = ++tot;
SAM[cp] = State(SAM[pre].len + 1, 0, 1, ref);
for (; pre && !SAM[pre].tr[id]; SAM[pre].tr[id] = cp, pre = SAM[pre].fa)
;
if (pre != 0)
if (SAM[pre].len + 1 == SAM[SAM[pre].tr[id]].len)
SAM[cp].fa = SAM[pre].tr[id];
else {
int tp = SAM[pre].tr[id];
SAM[++tot] = State(SAM[pre].len + 1, SAM[tp].fa, 0, 0);
memcpy(SAM[tot].tr, SAM[tp].tr, sizeof(SAM[tp].tr));
SAM[cp].fa = SAM[tp].fa = tot;
for (; pre && SAM[pre].tr[id] == tp;
SAM[pre].tr[id] = tot, pre = SAM[pre].fa)
;
}
else
SAM[cp].fa = 1;
}
}
void init() {
cin >> str[0];
c[0][0] = 1, c[0][1] = MAXL;
Construct_SAM(str[0], 0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> str[i] >> c[i][0] >> c[i][1];
Construct_SAM(str[i], i);
}
}
vector<int> l[MAXL];
void Calc(int id) {
for (int i = MAXL - 1; i >= 0; --i)
for (int j = 0; j < (int)l[i].size(); ++j)
SAM[SAM[l[i][j]].fa].num[id] += SAM[l[i][j]].num[id];
}
bool Check(int x) {
for (int i = 0; i <= n; ++i)
if (!(SAM[x].num[i] >= c[i][0] && SAM[x].num[i] <= c[i][1])) return false;
return true;
}
void solve() {
for (int i = 1; i <= tot; ++i) l[SAM[i].len].push_back(i);
for (int i = 0; i <= n; ++i) Calc(i);
long long CC = 0;
for (int i = 2; i <= tot; ++i)
if (Check(i)) CC += SAM[i].len - SAM[SAM[i].fa].len;
cout << CC << endl;
}
int main() {
init();
solve();
fclose(stdin);
fclose(stdout);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = (1e9) + 7;
int f[1005][1005][6];
int C[1005][1005];
int jc[1005], ans[1005];
int n, m, i, j;
void init() {
for (i = 1, jc[0] = 1; i <= n; i++) jc[i] = (long long)jc[i - 1] * i % Mod;
for (i = 0; i <= n; i++) C[i][0] = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= i; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % Mod;
}
int main() {
scanf("%d%d", &n, &m);
init();
f[1][0][4] = 1;
f[1][1][1] = 1;
f[2][2][5] = 1;
for (i = 1; i < n; i++)
for (j = 0; j <= i; j++) {
if (f[i][j][0]) {
(f[i + 1][j + 1][0] += f[i][j][0]) %= Mod;
(f[i + 1][j + 1][1] += f[i][j][0]) %= Mod;
(f[i + 1][j][2] += f[i][j][0]) %= Mod;
if (i < n - 1) (f[i + 2][j + 2][5] += f[i][j][0]) %= Mod;
}
if (f[i][j][1]) {
(f[i + 1][j + 1][1] += f[i][j][1]) %= Mod;
(f[i + 1][j][3] += f[i][j][1]) %= Mod;
}
if (f[i][j][2]) {
(f[i + 1][j + 1][0] += f[i][j][2]) %= Mod;
(f[i + 1][j + 1][1] += f[i][j][2]) %= Mod;
(f[i + 1][j][4] += f[i][j][2]) %= Mod;
if (i < n - 1) (f[i + 2][j + 2][5] += f[i][j][2]) %= Mod;
}
if (f[i][j][3]) {
(f[i + 1][j + 1][1] += f[i][j][3]) %= Mod;
(f[i + 1][j][4] += f[i][j][3]) %= Mod;
if (i < n - 1) (f[i + 2][j + 2][5] += f[i][j][3]) %= Mod;
}
if (f[i][j][4]) {
(f[i + 1][j + 1][0] += f[i][j][4]) %= Mod;
(f[i + 1][j + 1][1] += f[i][j][4]) %= Mod;
(f[i + 1][j][4] += f[i][j][4]) %= Mod;
if (i < n - 1) (f[i + 2][j + 2][5] += f[i][j][4]) %= Mod;
}
if (f[i][j][5]) {
(f[i + 1][j + 1][1] += f[i][j][5]) %= Mod;
(f[i + 1][j][2] += f[i][j][5]) %= Mod;
if (i < n - 1) (f[i + 2][j + 2][5] += f[i][j][5]) %= Mod;
}
}
for (i = 0; i <= n; i++)
ans[i] = (long long)((f[n][i][0] + f[n][i][2]) % Mod +
((f[n][i][3] + f[n][i][4]) % Mod + f[n][i][5]) % Mod) *
jc[n - i] % Mod;
for (i = n; i >= 0; i--)
for (j = i + 1; j <= n; j++)
(ans[i] -= (long long)ans[j] * C[j][i] % Mod - Mod) %= Mod;
printf("%d\n", ans[m]);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2e3 + 5;
int n;
int c[N], r[N];
int dp[2 * N][2 * N];
int last_right[2 * N][2 * N];
int lobound[2 * N];
vector<int> chose;
map<pair<int, int>, int> encode_intervals;
struct Compare {
bool operator()(const pair<int, int>& a, const pair<int, int>& b) const {
if (a.second != b.second)
return a.second < b.second;
else
return a.first < b.first;
}
};
set<int> endings;
set<pair<int, int>, Compare> ball;
vector<pair<int, int>> ball_vector;
map<int, int> wo;
void chosing(int a, int b) {
if (ball.find({a, b}) != ball.end())
chose.push_back(encode_intervals[{a, b}]);
int t = last_right[a][b];
if (t == 0) return;
if (wo[c[t] - r[t]] == a && wo[c[t] + r[t]] == b) return;
chosing(wo[c[t] - r[t]], wo[c[t] + r[t]]);
chosing(a, wo[c[t] - r[t]]);
}
int main() {
scanf("%d ", &n);
for (int i = 1; i <= n; i++) {
scanf("%d %d", &c[i], &r[i]);
endings.insert(c[i] - r[i]);
endings.insert(c[i] + r[i]);
}
for (auto it = endings.begin(); it != endings.end(); it++) {
int r = wo.size();
wo[(*it)] = r + 1;
}
for (int i = 1; i <= n; i++) {
ball.insert({wo[c[i] - r[i]], wo[c[i] + r[i]]});
encode_intervals[{wo[c[i] - r[i]], wo[c[i] + r[i]]}] = i;
}
for (auto it = ball.begin(); it != ball.end(); it++) {
if (ball_vector.size() > 0) {
int rrrr = ball_vector.size() - 1;
if (ball_vector[rrrr].second < (*it).second) {
lobound[ball_vector[rrrr].second] = rrrr;
}
}
ball_vector.push_back((*it));
}
lobound[ball_vector[ball_vector.size() - 1].second] = ball_vector.size() - 1;
for (int i = 1; i < wo.size(); i++) {
for (int j = 1; j + i <= wo.size(); j++) {
int fn = lobound[i + j];
dp[j][i + j] = dp[j][i + j - 1];
if (last_right[j][i + j] == 0)
last_right[j][i + j] = last_right[j][i + j - 1];
while (ball_vector[fn].second == i + j && ball_vector[fn].first > j) {
int f1 = ball_vector[fn].first;
int f2 = ball_vector[fn].second;
if (dp[j][i + j] < dp[j][f1] + dp[f1][f2]) {
dp[j][i + j] = dp[j][f1] + dp[f1][f2];
last_right[j][i + j] = encode_intervals[{f1, f2}];
}
fn--;
}
if (fn < 0) continue;
if (ball_vector[fn].second == i + j && ball_vector[fn].first == j) {
dp[j][i + j] += 1;
if (last_right[j][i + j] == 0)
last_right[j][i + j] = encode_intervals[{j, i + j}];
last_right[j][i + j + 1] = encode_intervals[{j, i + j}];
}
}
}
chosing(1, wo.size());
printf("%d \n", dp[1][wo.size()]);
for (auto it = chose.begin(); it != chose.end(); it++) {
printf("%d ", (*it));
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-3;
const int MAXN = 5e5 + 10;
const int MAXM = 1e4 + 10;
const long long mod = 1e9;
int a[MAXN], dp[MAXN];
int main() {
int n, k, d;
scanf("%d%d%d", &n, &k, &d);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int l = -1;
for (int i = k - 1; i < n; i++) {
if (a[i] - a[l + 1] <= d) dp[i] = 1;
if (dp[i - k + 1]) l = i - k + 1;
}
if (dp[n - 1])
puts("YES");
else
puts("NO");
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long cnt = 0, x = 1;
for (long long i = n / 2 + 1; i < n; i++) {
cnt = x * (a[i] - a[n / 2]);
if (k - cnt >= 0) {
k -= cnt;
a[n / 2] = a[i];
} else {
cout << a[n / 2] + k / x;
return;
}
x++;
}
cout << a[n / 2] + k / x;
return;
}
int main() {
long long t = 1;
while (t--) {
solve();
cout << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[100][100];
void check_row(int n, int m, vector<pair<char, int> >& vp) {
for (int i = 0; i < n; i++) {
int x = INT_MAX;
for (int j = 0; j < m; j++) {
x = min(x, a[i][j]);
}
int y = x;
if (x != 0)
for (int j = 0; j < m; j++) {
a[i][j] -= x;
}
while (y--) vp.push_back(make_pair('r', i));
}
}
void check_col(int n, int m, vector<pair<char, int> >& vp) {
for (int i = 0; i < m; i++) {
int x = INT_MAX;
for (int j = 0; j < n; j++) {
x = min(x, a[j][i]);
}
int y = x;
if (x != 0)
for (int j = 0; j < n; j++) {
a[j][i] -= x;
}
while (y--) vp.push_back(make_pair('c', i));
}
}
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
int x = INT_MAX;
vector<pair<char, int> > vp;
if (n > m) {
check_col(n, m, vp);
check_row(n, m, vp);
} else {
check_row(n, m, vp);
check_col(n, m, vp);
}
for (int i = 0; i < n; i++) {
x = -1;
for (int j = 0; j < m; j++) {
if (max(a[i][j], x) > 0) {
cout << "-1";
return 0;
}
}
}
cout << vp.size() << endl;
for (int i = 0; i < vp.size(); i++) {
if (vp[i].first == 'r')
cout << "row " << vp[i].second + 1 << endl;
else
cout << "col " << vp[i].second + 1 << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long sum = 0;
vector<long long> a(n);
for (long long i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
vector<long long> prime;
for (long long i = 2; i * i <= sum; ++i) {
if (sum % i == 0) {
prime.push_back(i);
while (sum % i == 0) sum /= i;
}
}
if (sum > 1) prime.push_back(sum);
long long ans = LLONG_MAX;
for (long long i : prime) {
long long now = 0;
long long cnt = 0;
for (long long j = 0; j < n; ++j) {
cnt += a[j];
now += min(cnt % i, i - cnt % i);
}
ans = min(ans, now);
}
cout << (ans == LLONG_MAX ? -1 : ans) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
queue<int> q;
int head[5009], tot, du[5009], n, cnt;
double ans;
int vis[5009];
inline int rd() {
int x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f ? -x : x;
}
struct edge {
int n, to;
} e[5009 << 1];
inline void add(int u, int v) {
e[++tot].n = head[u];
e[tot].to = v;
head[u] = tot;
}
inline void tpsort() {
for (int i = 1; i <= n; ++i)
if (du[i] == 1) q.push(i);
cnt = n;
while (!q.empty()) {
int u = q.front();
q.pop();
cnt--;
for (int i = head[u]; i; i = e[i].n) {
int v = e[i].to;
du[v]--;
if (du[v] == 1) q.push(v);
}
}
}
void dfs(int u, int h, int l) {
if (h <= 1)
ans += (double)1 / (double)l;
else
ans += (double)1 / (double)l + (double)1 / ((double)(cnt - h + 2) + l - h) -
(double)1 / ((double)cnt + l - h);
for (int i = head[u]; i; i = e[i].n)
if (vis[u] != vis[e[i].to]) {
int v = e[i].to;
;
vis[e[i].to] = vis[u];
dfs(v, h + (du[v] > 1), l + 1);
}
}
int main() {
n = rd();
int x, y;
for (int i = 1; i <= n; ++i) {
x = rd() + 1;
y = rd() + 1;
du[x]++;
du[y]++;
add(x, y);
add(y, x);
}
tpsort();
for (int i = 1; i <= n; ++i) {
vis[i] = i;
dfs(i, du[i] > 1, 1);
}
printf("%.12lf", ans);
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
int T, n, m, tot, cnt;
int a[N], b[N], A[N], c[N], li[N], p[N];
void lisan() {
sort(li + 1, li + 1 + tot);
cnt = unique(li + 1, li + 1 + tot) - li - 1;
for (int i = 1; i <= n; i++)
a[i] = lower_bound(li + 1, li + 1 + cnt, a[i]) - li;
for (int i = 1; i <= m; i++)
b[i] = lower_bound(li + 1, li + 1 + cnt, b[i]) - li;
}
int lowbit(int x) { return x & (-x); }
void upd(int x) {
for (; x <= cnt; x += lowbit(x)) c[x]++;
}
long long qry(int x) {
long long summ = 0;
for (; x; x -= lowbit(x)) summ += c[x];
return summ;
}
long long calc() {
long long summ = 0;
for (int i = 1; i <= tot; i++) {
summ += qry(cnt) - qry(A[i]);
upd(A[i]);
}
return summ;
}
void solve(int Lb, int Rb, int La, int Ra) {
if (Lb > Rb) return;
int mid = (Lb + Rb) >> 1;
int val = b[mid];
int minn = 2e9, summ1 = 0, summ2 = 0;
for (int i = Ra - 1; i >= La; i--)
if (a[i] < val) summ2++;
minn = summ2;
p[mid] = La;
for (int i = La + 1; i <= Ra; i++) {
if (a[i - 1] < val) summ2--;
if (a[i - 1] > val) summ1++;
if (summ1 + summ2 < minn) minn = summ1 + summ2, p[mid] = i;
}
solve(Lb, mid - 1, La, p[mid]);
solve(mid + 1, Rb, p[mid], Ra);
}
int main() {
scanf("%d", &T);
while (T--) {
tot = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), li[++tot] = a[i];
for (int i = 1; i <= m; i++) scanf("%d", &b[i]), li[++tot] = b[i];
sort(b + 1, b + 1 + m);
lisan();
for (int i = 1; i <= cnt; i++) c[i] = 0;
solve(1, m, 1, n + 1);
tot = 0;
int nowb = 1;
for (int i = 1; i <= n; i++) {
while (p[nowb] == i && nowb <= m) A[++tot] = b[nowb++];
A[++tot] = a[i];
}
while (nowb <= m) A[++tot] = b[nowb++];
printf("%lld\n", calc());
}
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
string bin(string tt, int k) {
string poch = "";
string ff = tt;
while (k > 0) {
if (k % 2 == 1) poch = poch + ff;
k = k / 2;
ff = ff + ff;
}
return poch;
}
string f(int a1, int a2, int a3, int a4) {
string poch = "";
if (abs(a3 - a4) > 1) return "-1";
if (a3 > a1 || a3 > a2 || a4 > a1 || a4 > a2) return "-1";
if (a3 + a4 >= a1 + a2) return "-1";
int pomoshna = a3;
poch = poch + bin("47", pomoshna);
a1 = a1 - a3;
a2 = a2 - a3;
a4 = a4 - a3 + 1;
if (a4 == 0) {
poch = bin("4", a1) + poch;
poch = poch + bin("7", a2);
return poch;
}
if (a4 == 1) {
if (a1 == 0) {
if (a2 == 0)
return "-1";
else {
poch = "7" + poch;
a2--;
poch = poch + bin("7", a2);
return poch;
}
}
poch = poch + bin("7", a2);
poch = poch + "4";
a1--;
poch = bin("4", a1) + poch;
return poch;
}
if (a2 == 0 || a1 == 0) return "-1";
a1--;
a2--;
poch = bin("4", a1) + poch;
poch = poch + bin("7", a2);
return "7" + poch + "4";
}
int main() {
int a1, a2, a3, a4;
cin >> a1 >> a2 >> a3 >> a4;
cout << f(a1, a2, a3, a4);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, l, x, y, a[100002], u, v, r = 2;
set<int> A;
bool X, Y;
int main() {
scanf("%d%d%d%d", &n, &l, &x, &y);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
A.insert(a[i]);
}
for (int i = 0; i < n; i++) {
if (A.find(a[i] + x) != A.end()) X = true;
if (A.find(a[i] + y) != A.end()) Y = true;
}
if (X && Y) {
printf("0\n");
return 0;
}
if (X) {
printf("%d\n%d\n", 1, y);
return 0;
}
if (Y) {
printf("%d\n%d\n", 1, x);
return 0;
}
u = x;
v = y;
for (int i = 0; i < n; i++) {
if (a[i] + x < l &&
(A.find(a[i] + x - y) != A.end() || A.find(a[i] + x + y) != A.end())) {
r = 1;
u = a[i] + x;
break;
}
if (a[i] - x > 0 &&
(A.find(a[i] - x + y) != A.end() || A.find(a[i] - x - y) != A.end())) {
r = 1;
u = a[i] - x;
break;
}
}
printf("%d\n", r);
(r == 2) ? printf("%d %d\n", u, v) : printf("%d\n", u);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
string S;
int c[26][200009];
int main() {
cin >> S;
for (int i = 0; i < S.size(); i++) {
c[S[i] - 'a'][i + 1] = 1;
}
for (int i = 0; i < 26; i++) {
for (int j = 1; j <= S.size(); j++) c[i][j] += c[i][j - 1];
}
int Q;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
int cl, cr;
scanf("%d%d", &cl, &cr);
int cnts = 0;
for (int j = 0; j < 26; j++) {
if (c[j][cl - 1] != c[j][cr]) cnts++;
}
if (cnts == 1) {
if (cl == cr)
printf("Yes\n");
else
printf("No\n");
}
if (cnts == 2) {
if (S[cl - 1] != S[cr - 1])
printf("Yes\n");
else
printf("No\n");
}
if (cnts >= 3) {
printf("Yes\n");
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = LLONG_MAX, MOD = 1e9 + 7;
const int N = 4e5;
long long t[N * 2];
long long h;
long long dd[N];
long long n, a, b, c, d, start, len;
vector<pair<long long, pair<long long, long long>>> timetype;
void apply(int p, long long value) {
t[p] += value;
if (p < n) dd[p] += value;
}
void build(int p) {
while (p > 1) p >>= 1, t[p] = min(t[p << 1], t[p << 1 | 1]) + dd[p];
}
void push(int p) {
for (int s = h; s > 0; --s) {
int i = p >> s;
if (dd[i] != 0) {
apply(i << 1, dd[i]);
apply(i << 1 | 1, dd[i]);
dd[i] = 0;
}
}
}
void inc(int l, int r, long long value) {
l += n, r += n;
int l0 = l, r0 = r;
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) apply(l++, value);
if (r & 1) apply(--r, value);
}
build(l0);
build(r0 - 1);
}
long long query(int l, int r) {
l += n, r += n;
push(l);
push(r - 1);
long long res = 0;
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, t[l++]);
if (r & 1) res = min(t[--r], res);
}
return res;
}
void puu(long long tim, pair<long long, long long> change) {
if (tim <= 0) return;
timetype.push_back({tim, change});
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> a >> b >> c >> d >> start >> len;
h = sizeof(int) * 8 - __builtin_clz(n);
int x = 0, y = 0;
long long cum = start;
for (int i = 0; i < n; i++) {
long long typ, tim;
cin >> tim >> typ;
long long delta;
if (tim < len) {
y++;
if (typ == 1) {
delta = c;
} else {
delta = -d;
}
} else {
if (typ == 1) {
delta = a;
} else {
delta = -b;
}
}
cum += delta;
inc(i, i + 1, cum);
puu(tim + 1, {0, (typ == 1 ? a - c : d - b)});
puu(tim - len + 1, {1, (typ == 1 ? c - a : b - d)});
}
sort(timetype.begin(), timetype.end());
if (query(0, y) >= 0) {
return cout << 0 << endl, 0;
}
for (int i = 0; i < (int)timetype.size(); i++) {
auto &pr = timetype[i].second;
if (pr.first) {
inc(y, n, pr.second);
y++;
} else {
inc(x, n, pr.second);
x++;
}
if (i < n - 1 && timetype[i + 1].first == timetype[i].first) continue;
if (query(0, y) >= 0) {
return cout << timetype[i].first << endl, 0;
}
}
cout << -1 << endl;
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
struct tree {
int u, v, next, d;
} l[201000];
struct node {
int x, y, fx, fy;
} q[10100];
const int inf = 1 << 30;
int n, m, lian[10100], e = 1, be, en, dep[10100];
void build(int);
void bian(int, int, int);
int dinic();
bool bfs();
int dfs(int, int);
int main() {
scanf("%d%d", &n, &m);
be = n + m + 1;
en = be + 1;
for (int i = 1; i <= m; i++) scanf("%d%d", &q[i].x, &q[i].y);
if (!m) {
printf("0");
return 0;
}
int le = 1, ri = n, ans = 0;
while (le <= ri) {
int mid = (le + ri) >> 1;
build(mid);
if (dinic() == m) {
ans = mid;
ri = mid - 1;
} else
le = mid + 1;
}
printf("%d\n", ans);
build(ans);
dinic();
for (int i = 1; i <= m; i++) {
if (l[q[i].fx].d == 0)
printf("%d %d\n", q[i].x, q[i].y);
else
printf("%d %d\n", q[i].y, q[i].x);
}
return 0;
}
void build(int x) {
e = 1;
memset(lian, 0, sizeof(lian));
for (int i = 1; i <= n; i++) bian(be, i, x);
for (int i = 1; i <= m; i++) {
q[i].fx = e + 1;
bian(q[i].x, i + n, 1);
q[i].fy = e + 1;
bian(q[i].y, i + n, 1);
bian(i + n, en, 1);
}
}
void bian(int x, int y, int z) {
e++;
l[e].u = x;
l[e].v = y;
l[e].d = z;
l[e].next = lian[x];
lian[x] = e;
e++;
l[e].u = y;
l[e].v = x;
l[e].d = 0;
l[e].next = lian[y];
lian[y] = e;
}
int dinic() {
int ans = 0;
while (bfs() == 1) ans += dfs(be, inf);
return ans;
}
bool bfs() {
memset(dep, 0, sizeof(dep));
queue<int> que;
que.push(be);
dep[be] = 1;
while (que.empty() == 0) {
int x = que.front();
que.pop();
for (int i = lian[x]; i; i = l[i].next) {
int v = l[i].v;
if (l[i].d > 0 && !dep[v]) {
dep[v] = dep[x] + 1;
if (v == en) return true;
que.push(v);
}
}
}
return false;
}
int dfs(int x, int y) {
if (x == en || !y) return y;
int ans = 0;
for (int i = lian[x]; i; i = l[i].next) {
int v = l[i].v;
if (dep[v] == dep[x] + 1 && l[i].d > 0) {
int k = dfs(v, (l[i].d < y ? l[i].d : y));
if (!k) {
dep[v] = 0;
continue;
}
ans += k;
y -= k;
l[i].d -= k;
l[i ^ 1].d += k;
if (!y) break;
}
}
return ans;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const long double Eps = 1e-12;
const long double Pi = 4 * atan(1);
int sgn(long double a, long double b = 0) {
a -= b;
return (a > Eps) - (a < -Eps);
}
struct Point {
long double x, y;
Point operator-(Point p) { return {x - p.x, y - p.y}; }
Point operator+(Point p) { return {x + p.x, y + p.y}; }
Point operator*(long double d) { return {x * d, y * d}; }
Point rot(long double d) {
long double rx = x * cos(d) - y * sin(d);
long double ry = x * sin(d) + y * cos(d);
return {rx, ry};
}
long double len2() { return x * x + y * y; }
long double len() { return sqrt(len2()); }
long double arg() {
long double r = atan2(y, x);
return sgn(r) < 0 ? r + 2 * Pi : r;
}
};
vector<Point> circle_inter(Point c1, long double r1, Point c2, long double r2) {
vector<Point> ret;
long double x = (c1 - c2).len2();
long double y = ((r1 * r1 - r2 * r2) / x + 1) / 2;
long double d = r1 * r1 / x - y * y;
if (sgn(d) == -1) return ret;
d = max(d, 0.0L);
Point p1 = c1 + (c2 - c1) * y;
Point p2 = ((c2 - c1) * sqrt(d)).rot(Pi / 2);
ret.push_back(p1 - p2);
ret.push_back(p1 + p2);
return ret;
}
pair<long double, long double> circle_cover(Point c1, long double r1, Point c2,
long double r2, bool &f) {
f = false;
long double d = (c1 - c2).len();
if (sgn(r1 + r2, d) < 0 || sgn(r2 + d, r1) < 0) return {0, 0};
f = true;
if (sgn(r1 + d, r2) <= 0) return {0, 2 * Pi};
auto p = circle_inter(c1, r1, c2, r2);
long double a1 = (p[0] - c1).arg();
long double a2 = (p[1] - c1).arg();
if (sgn(a1 > a2)) a2 += 2 * Pi;
return {a1, a2};
}
bool btw(long double a, pair<long double, long double> b) {
if (sgn(a, 2 * Pi) >= 0) a -= 2 * Pi;
return (sgn(b.first, a) <= 0 && sgn(a, b.second) <= 0) ||
(sgn(b.first, a + 2 * Pi) <= 0 && sgn(a + 2 * Pi, b.second) <= 0);
}
bool check(Point c1, long double r1, Point c2, long double r2, Point c3,
long double r3) {
vector<Point> ch = {c1, c2, c3};
auto v1 = circle_inter(c1, r1, c2, r2);
auto v2 = circle_inter(c2, r2, c3, r3);
auto v3 = circle_inter(c3, r3, c1, r1);
for (auto &p : v1) ch.push_back(p);
for (auto &p : v2) ch.push_back(p);
for (auto &p : v3) ch.push_back(p);
for (auto &p : ch)
if (sgn((p - c1).len(), r1) <= 0 && sgn((p - c2).len(), r2) <= 0 &&
sgn((p - c3).len(), r3) <= 0)
return true;
return false;
}
int main() {
ios ::sync_with_stdio(false);
long double t1, t2;
cin >> t1 >> t2;
Point c, h, s;
cin >> c.x >> c.y;
cin >> h.x >> h.y;
cin >> s.x >> s.y;
cout << fixed << setprecision(6);
if (sgn((c - h).len() + t2, (c - s).len() + (s - h).len()) >= 0)
cout << min((c - s).len() + (s - h).len() + t1, (c - h).len() + t2) << '\n';
else {
long double left = 0;
long double right = min((c - s).len() + t1, (c - h).len() + t2);
for (int _ = 0; _ < 50; _++) {
long double mid = (left + right) / 2;
if (check(c, mid, s, (c - s).len() + t1 - mid, h,
(c - h).len() + t2 - mid))
left = mid;
else
right = mid;
}
cout << left << '\n';
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int a[500004], b[500004] = {};
int main() {
int i, j, po;
int n, c = 0;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
i = n / 2 - 1;
int k = n - 1;
while (i >= 0) {
if (((a[i] * 2) <= a[k]) && b[k] == 0) {
b[k] = 1;
b[i] = 1;
c++;
k--;
i--;
} else
i--;
}
cout << n - c << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int index = 1;
int sum = 0;
for (int i = 1; i < n; i++) {
sum += ((i)*2 + index * 2 + abs(i - index) * 2) * arr[i];
}
cout << sum << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e4;
int n, k, a[mxN], dp[2][mxN + 1], qt, m[mxN], b[mxN], mx[mxN + 1];
void al(int mi, int bi, bool mo) {
if (qt && mi == m[qt - 1]) {
if (bi > b[qt - 1]) return;
--qt;
}
while (qt > 1 && (bi - b[qt - 1]) / (m[qt - 1] - mi) <
(b[qt - 1] - b[qt - 2]) / (m[qt - 2] - m[qt - 1]) ^
mo)
--qt;
m[qt] = mi;
b[qt] = bi;
++qt;
}
int qry(int x) {
while (qt > 1 && m[qt - 2] * x + b[qt - 2] < m[qt - 1] * x + b[qt - 1]) --qt;
return m[qt - 1] * x + b[qt - 1];
}
void cdp(int f[mxN + 1], int t[mxN + 1], int l, int r) {
if (l >= r) return;
int m = (l + r) / 2;
mx[m] = mx[m + 1] = a[m];
for (int i = m - 1; i >= l; --i) mx[i] = max(a[i], mx[i + 1]);
for (int i = m + 2; i <= r; ++i) mx[i] = max(a[i - 1], mx[i - 1]);
for (int il = m + 1, ir = m + 1; ir <= r; ++ir) {
while (il > l && mx[il - 1] <= mx[ir]) {
--il;
al(-il, f[il], 1);
}
t[ir] = min(qry(mx[ir]) + ir * mx[ir], t[ir]);
}
qt = 0;
al(2e4, 1e9, 0);
for (int il = l, ir = r; ir > m; --ir) {
while (il <= m && mx[il] >= mx[ir]) {
al(mx[il], f[il] - il * mx[il], 0);
++il;
}
t[ir] = min(qry(ir), t[ir]);
}
qt = 0;
cdp(f, t, l, m);
cdp(f, t, m + 1, r);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
memset(dp[0], 0x3f, sizeof(dp[0]));
dp[0][0] = 0;
for (int i = 1; i <= k; ++i) {
memset(dp[i & 1], 0x3f, sizeof(dp[0]));
cdp(dp[i & 1 ^ 1], dp[i & 1], 0, n);
}
cout << dp[k & 1][n];
}
| 22 |
#include <bits/stdc++.h>
int main() {
int n, i, s = 0, c = 0, b;
scanf("%d", &n);
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i < n; i++) {
s = s + a[i];
}
s = s / 2 + s % 2;
for (i = 0; i < n; i++) {
c = c + a[i];
if (c >= s) {
b = i;
break;
}
}
printf("%d", b + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MAXN = 4e5 + 5;
int n;
std::vector<int> S;
struct Node {
int l, r, id;
Node(int l = 0, int r = 0, int id = 0) : l(l), r(r), id(id) {}
} a[MAXN];
struct BIT {
int tree[MAXN];
inline void add(int pos, int x) {
for (; pos < MAXN; pos += ((pos) & (-(pos)))) tree[pos] += x;
}
inline int query(int pos) {
int res = 0;
for (; pos; pos -= ((pos) & (-(pos)))) res += tree[pos];
return res;
}
} bit;
int ans[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d%d", &a[i].l, &a[i].r), S.push_back(a[i].l), a[i].id = i;
std::sort(S.begin(), S.end());
S.erase(std::unique(S.begin(), S.end()), S.end());
for (int i = 1; i <= n; ++i)
a[i].l = std::lower_bound(S.begin(), S.end(), a[i].l) - S.begin() + 1;
std::sort(a + 1, a + n + 1,
[&](const Node &a, const Node &b) { return a.r < b.r; });
for (int i = 1; i <= n; ++i) {
ans[a[i].id] = i - 1 - bit.query(a[i].l - 1);
bit.add(a[i].l, 1);
}
for (int i = 1; i <= n; ++i) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
const int N = 200005;
int a[N];
int b[105], data[N * 2], *d = data + 200000;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[a[i]]++;
}
int wc = 0;
for (int i = 1; i <= n; i++) {
if (b[i] > b[wc]) wc = i;
}
for (int i = 1; i <= n; i++) {
if (i != wc && b[i] == b[wc]) {
return printf("%d\n", n), 0;
}
}
int ans = 0;
for (int u = 1; u <= 100; u++) {
if (u == wc) continue;
for (int i = -n; i <= n; i++) d[i] = -1;
int now = 0;
d[now] = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == u) now++;
if (a[i] == wc) now--;
if (d[now] == -1) {
d[now] = i;
} else {
ans = max(ans, i - d[now]);
}
}
}
printf("%d\n", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 5;
int n, x, y, cnt[N];
long long ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
cin >> x >> y;
cnt[x]++;
cnt[y]++;
}
for (int i = 1; i <= n; i++) {
ans += cnt[i] * (cnt[i] - 1) / 2;
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, c;
cin >> n >> k;
vector<int> vector1(k);
set<int> S;
stack<int> stack1;
for (i = 0; i < k; i++) cin >> vector1[i], S.insert(vector1[i]);
c = 1;
while (c <= n) {
if (S.find(c) == S.end()) {
stack1.push(c++);
} else {
c++;
while (!stack1.empty()) vector1.push_back(stack1.top()), stack1.pop();
}
}
while (!stack1.empty()) vector1.push_back(stack1.top()), stack1.pop();
i = 0;
c = 1;
stack<int> s;
while (c <= n) {
if (s.empty() || s.top() != c) {
while (i < n && vector1[i] != c) s.push(vector1[i]), i++;
if (i < n && vector1[i] == c) s.push(vector1[i++]);
}
if (s.top() == c) {
s.pop();
c++;
} else {
cout << "-1\n";
return 0;
}
}
for (i = 0; i < n; i++) cout << vector1[i] << " ";
cout << "\n";
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
string s;
cin >> s;
char current_char = s[0];
std::vector<int> v;
v.push_back(a[0]);
long long int dmg = 0;
for (int i = 1; i < n; ++i) {
if (s[i] == current_char) {
v.push_back(a[i]);
continue;
} else {
if (v.size() <= k) {
for (int j = 0; j < v.size(); ++j) {
dmg += v[j];
}
} else {
sort(v.begin(), v.end(), greater<int>());
for (int j = 0; j < k; ++j) {
dmg += v[j];
}
}
current_char = s[i];
v.clear();
v.push_back(a[i]);
}
}
if (v.size() > 0)
if (v.size() <= k) {
for (int j = 0; j < v.size(); ++j) {
dmg += v[j];
}
} else {
sort(v.begin(), v.end(), greater<int>());
for (int j = 0; j < k; ++j) {
dmg += v[j];
}
}
cout << dmg << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
vector<long long> v;
map<string, int> mp;
long long n, a, b, c, i;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
a = 1;
b = 2;
while (c <= n) {
c = a + b;
a = b;
b = c;
i++;
}
cout << i;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, int> b = {{'0', 1}, {'4', 1}, {'6', 1}, {'8', 2},
{'9', 1}, {'A', 1}, {'B', 2}, {'D', 1}};
long long x;
string hex;
cin >> x;
int ans = 0;
if (x == 0) {
cout << 1;
return 0;
}
while (x) {
if (x % 16 < 10) hex += (char)(x % 16) + '0';
if (x % 16 == 10) hex += 'A';
if (x % 16 == 11) hex += 'B';
if (x % 16 == 12) hex += 'C';
if (x % 16 == 13) hex += 'D';
if (x % 16 == 14) hex += 'E';
if (x % 16 == 15) hex += 'F';
x /= 16;
}
for (int i = 0; i < hex.size(); ++i) ans += b[hex[i]];
cout << ans;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans = 1;
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << int(((a ^ b) && (c || d)) ^ ((b && c) || (a ^ d))) << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, num[300100], tt = 1;
struct Node {
long long ls, rs, lm, rm, mx, ln, rn, len;
};
Node node[300100 << 1];
inline bool lj(long long u, long long v) {
return u > 0 && v || u < 0 && v < 0;
}
inline void up(long long now) {
long long u = node[now].ls, v = node[now].rs;
if (!u || !v) {
node[now] = node[u + v];
return;
}
node[now].ln = node[u].ln;
node[now].rn = node[v].rn;
node[now].len = node[u].len + node[v].len;
node[now].mx = max(node[u].mx, node[v].mx);
if (lj(node[u].rn, node[v].ln)) {
if (node[u].lm == node[u].len)
node[now].lm = node[u].lm + node[v].lm;
else
node[now].lm = node[u].lm;
if (node[v].rm == node[v].len)
node[now].rm = node[v].rm + node[u].rm;
else
node[now].rm = node[v].rm;
node[now].mx = max(node[now].mx, node[u].rm + node[v].lm);
} else {
node[now].lm = node[u].lm;
node[now].rm = node[v].rm;
}
}
void build(long long now, long long l, long long r) {
if (l == r) {
if (num[l]) node[now].lm = node[now].rm = node[now].mx = 1;
node[now].ln = node[now].rn = num[l];
node[now].len = 1;
return;
}
if (l <= ((l + r) >> 1)) {
node[now].ls = ++tt;
build(tt, l, ((l + r) >> 1));
}
if (((l + r) >> 1) < r) {
node[now].rs = ++tt;
build(tt, ((l + r) >> 1) + 1, r);
}
up(now);
}
void chg(long long now, long long l, long long r, long long u) {
if (l == r) {
if (num[u]) node[now].lm = node[now].rm = node[now].mx = 1;
node[now].ln = node[now].rn = num[u];
return;
}
if (u <= ((l + r) >> 1))
chg(node[now].ls, l, ((l + r) >> 1), u);
else
chg(node[now].rs, ((l + r) >> 1) + 1, r, u);
up(now);
}
void out(long long now, long long l, long long r) {
printf("%lld <%lld %lld> {%lld %lld} [%lld %lld] &%lld& |-%lld-|\n", now, l,
r, node[now].ln, node[now].rn, node[now].lm, node[now].rm,
node[now].mx, node[now].len);
if (l == r) return;
if (l <= ((l + r) >> 1)) out(node[now].ls, l, ((l + r) >> 1));
if (((l + r) >> 1) < r) out(node[now].rs, ((l + r) >> 1) + 1, r);
}
int main() {
long long i, j, p, q, o;
cin >> n;
for (i = 0; i < n; i++) {
scanf("%lld", &num[i]);
}
n--;
for (i = n; i >= 1; i--) num[i] -= num[i - 1];
build(1, 1, n);
cin >> m;
for (i = 1; i <= m; i++) {
scanf("%lld%lld%lld", &p, &q, &o);
if (p > 1) num[p - 1] += o, chg(1, 1, n, p - 1);
if (q <= n) num[q] -= o, chg(1, 1, n, q);
printf("%lld\n", node[1].mx + 1);
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
double dp[2][1 << 9][240][2];
int first, k, p;
double pro;
inline double solve() {
memset(dp, 0, sizeof(dp));
int v = (first >> 9);
if (!v) {
dp[0][first][0][0] = 1.;
} else if (v % 2 == 0) {
int add = 0;
while (v % 2 == 0) {
v /= 2;
++add;
}
dp[0][first % (1 << 9)][add][0] = 1.;
} else {
++v;
int add = 0;
while (v % 2 == 0) {
v /= 2;
++add;
}
dp[0][first % (1 << 9)][add][1] = 1.;
}
int cur = 0, nxt = 1;
for (int step = 0; step < k; ++step) {
for (int j = 0; j < (1 << 9); ++j)
for (int l = 0; l < 240; ++l) dp[nxt][j][l][0] = dp[nxt][j][l][1] = 0;
for (int mask = 0; mask < (1 << 9); ++mask) {
int shift = (mask % (1 << 8)) * 2;
for (int add = 0; add < 239; ++add) {
double val;
val = dp[cur][mask][add][0];
if (val > 1e-15) {
if ((mask >> 8) == 1) {
dp[nxt][shift][1][1] += val * pro;
} else {
dp[nxt][shift][add + 1][0] += val * pro;
}
if (mask == (1 << 9) - 1) {
dp[nxt][0][add][1] += val * (1 - pro);
} else {
dp[nxt][mask + 1][add][0] += val * (1 - pro);
}
}
val = dp[cur][mask][add][1];
if (val > 1e-15) {
if ((mask >> 8) == 1) {
dp[nxt][shift][add + 1][1] += val * pro;
} else {
dp[nxt][shift][1][0] += val * pro;
}
if (mask == (1 << 9) - 1) {
dp[nxt][0][add][0] += val * (1 - pro);
} else {
dp[nxt][mask + 1][add][1] += val * (1 - pro);
}
}
}
}
swap(cur, nxt);
}
double ans = 0;
for (int mask = 0; mask < (1 << 9); ++mask) {
int down = 0;
if (mask) {
int first = mask;
while (first % 2 == 0) {
first /= 2;
++down;
}
}
for (int add = 0; add < 240; ++add) {
if (!mask) {
ans += (9 + add) * dp[cur][mask][add][0];
ans += 9 * dp[cur][mask][add][1];
} else {
ans += down * dp[cur][mask][add][0];
ans += down * dp[cur][mask][add][1];
}
}
}
return ans;
}
inline double naive() {
double ans = 0;
for (int mask = 0; mask < (1 << k); ++mask) {
double pr = 1.;
int val = first;
for (int i = 0; i < k; ++i) {
if (mask & (1 << i)) {
++val;
pr *= (1 - pro);
} else {
val *= 2;
pr *= pro;
}
}
int down = 0;
while (val % 2 == 0) {
val /= 2;
++down;
}
ans += down * pr;
}
return ans;
}
int main() {
cin >> first >> k >> p;
pro = p / 100.;
printf("%0.9lf\n", solve());
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 + 10;
int n, k;
int vec[MAXN], sec[MAXN], gec[MAXN], t[MAXN];
bool same() {
for (int i = 0; i < n; i++)
if (vec[i] != sec[i]) return false;
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> vec[i];
vec[i]--;
}
for (int i = 0; i < n; i++) {
cin >> sec[i];
sec[i]--;
}
copy(vec, vec + n, gec);
iota(vec, vec + n, 0);
if (same()) {
cout << "NO\n";
return 0;
}
bool fl = 0, ok = 0;
int ttt = -1;
for (int i = 0; i < k; i++) {
{
for (int j = 0; j < n; j++) t[j] = vec[gec[j]];
bool zoo = 1;
for (int j = 0; j < n; j++)
if (t[j] != sec[j]) zoo = 0;
if (!zoo) ok = 1;
zoo = 1;
for (int j = 0; j < n; j++) t[gec[j]] = vec[j];
for (int j = 0; j < n; j++)
if (t[j] != sec[j]) zoo = 0;
if (!zoo) ok = 1;
}
for (int j = 0; j < n; j++) t[j] = vec[gec[j]];
copy(t, t + n, vec);
if (same()) {
ttt = i + 1;
break;
}
}
if (ttt != -1 && (ttt % 2 == k % 2))
if (ttt == k || ok) {
cout << "YES\n";
return 0;
}
fl = 1;
ok = 0;
iota(vec, vec + n, 0);
ttt = -1;
for (int i = 0; i < k; i++) {
{
for (int j = 0; j < n; j++) t[j] = vec[gec[j]];
bool zoo = 1;
for (int j = 0; j < n; j++)
if (t[j] != sec[j]) zoo = 0;
if (!zoo) ok = 1;
zoo = 1;
for (int j = 0; j < n; j++) t[gec[j]] = vec[j];
for (int j = 0; j < n; j++)
if (t[j] != sec[j]) zoo = 0;
if (!zoo) ok = 1;
}
for (int j = 0; j < n; j++) t[gec[j]] = vec[j];
copy(t, t + n, vec);
if (same()) {
ttt = i + 1;
break;
}
}
if (ttt != -1 && (ttt % 2 == k % 2))
if (ok) {
cout << "YES\n";
return 0;
}
cout << "NO\n";
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, ans = 0;
scanf("%lld", &n);
for (long long i = 3; i <= n; i++) {
ans += (i - 1) * i;
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
template <class T>
T gcd(const T a, const T b) {
return (b ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(const T a, const T b) {
return (a / gcd<T>(a, b) * b);
}
int X[] = {0, 0, 1, 0, 0, -1};
int Y[] = {0, 1, 0, 0, -1, 0};
int Z[] = {1, 0, 0, -1, 0, 0};
struct node {
long long x, y;
node() {}
node(long long x, long long y) : x(x), y(y) {}
bool operator<(const node& p) const { return x < p.x; }
};
bool vis[10007];
vector<long long> v, vec;
void sieve() {
long long mx = 10004, i, j;
for (i = 2; i <= mx; i++) {
if (vis[i]) continue;
for (j = i + i; j <= mx; j += i) {
vis[i] = 1;
}
}
for (i = 2; i <= mx; i++)
if (!vis[i]) v.push_back(i);
}
long long a[10005];
int main() {
long long i, j, k, l, x, y, z, t, m, n;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
vec.push_back(a[1]);
for (i = 2; i <= n; i++) {
if (gcd(a[i], a[i - 1]) != 1) {
vec.push_back(1);
}
vec.push_back(a[i]);
}
deb(vec.size() - n);
for (i = 0; i < vec.size(); i++) printf("%lld ", vec[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 100;
const long long int INF64 = (1LL << 61) + 100;
const long long int MOD = 1000 * 1000 * 1000 + 7;
long long int bpow(long long int a, long long int b) {
if (b == 0) return 1;
if (b == 1) return a % MOD;
long long int r = bpow(a, b >> 1);
r = (r * r) % MOD;
return (r * (((b & 1) ? a : 1) % MOD)) % MOD;
}
long long int multInverse(long long int a) { return bpow(a, MOD - 2); }
long long int modMult(long long int a, long long int b) {
return (a * b) % MOD;
}
long long int modSub(long long int a, long long int b) {
a += MOD;
long long int r = a - b;
if (r >= MOD) return r - MOD;
return r;
}
long long int modAdd(long long int a, long long int b) {
long long int r = a + b;
if (r >= MOD) return r - MOD;
return r;
}
vector<int> poses[30];
int solveTest() {
for (int i = 0; i < 30; i++) poses[i].resize(0);
string s, t;
cin >> s >> t;
int n = s.length(), m = t.length();
s = "#" + s;
t = "#" + t;
for (int i = 1; i <= n; i++) poses[s[i] - 'a'].push_back(i);
for (int i = 1; i <= m; i++)
if (poses[t[i] - 'a'].size() == 0) return -1;
for (int i = 0; i < 30; i++) poses[i].push_back(INF);
int ans = 0;
int curPos = 0;
for (int i = 1; i <= m;) {
curPos = *upper_bound(poses[t[i] - 'a'].begin(), poses[t[i] - 'a'].end(),
curPos);
if (curPos == INF) {
curPos = 0;
ans++;
continue;
}
i++;
}
ans++;
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) {
cout << solveTest() << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, r = 0;
cin >> n;
vector<string> v(n);
map<string, int> m;
for (i = 0; i < n; i++) {
cin >> v[i];
sort(v[i].begin(), v[i].end());
for (j = 1; j < v[i].size(); j++) {
if (v[i][j] == v[i][j - 1]) {
v[i].erase(v[i].begin() + j);
j--;
}
}
m[v[i]]++;
}
for (i = 0; i < n; i++) {
if (m[v[i]] != 0) {
r++;
m[v[i]] = 0;
}
}
cout << r;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long fact(long long n) {
if (n == 0) {
return 1;
}
return (n * fact(n - 1)) % 1000000000000000007;
}
long long power(long long x, long long y) {
long long out = 1;
while (y > 0) {
if (y & 1) out = (out * x) % 1000000000000000007;
y = y >> 1;
x = (x * x) % 1000000000000000007;
}
return out % 1000000000000000007;
}
long long inverse(long long a) { return power(a, 1000000000000000007 - 2); }
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
gcd(b, a % b);
}
long long a[2000000];
void sieve() {
long long i, j;
for (i = 2; i < 1000001; i++) {
if (a[i] == 0) {
for (j = i * i; j < 1000001; j += i) {
a[j] = 1;
}
}
}
}
bool compar(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
if (a.first == b.first)
return (a.second < b.second);
else
return (a.first < b.first);
}
vector<long long> v1;
void comp() {
long long i, j, k, m, x, y, n;
cin >> n >> m;
long long temp = n - m;
long long temp2 = temp / (m + 1);
long long temp1 = temp % (m + 1);
long long c1 = (m + 1 - temp1);
long long sub = ((temp2 * (temp2 + 1)) / 2) * c1 +
temp1 * ((temp2 + 1) * (temp2 + 2)) / 2;
long long ans = (n * (n + 1)) / 2 - sub;
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
long long i = 0, t;
long long n;
cin >> t;
while (t--) {
comp();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> d[2000];
int main() {
int n, m, k, t, i, j, x, y, r;
cin >> n >> m >> k >> t;
for (i = 0; i < k; i++) scanf("%d %d", &d[i].first, &d[i].second);
sort(d, d + k);
pair<int, int> tm;
while (t--) {
scanf("%d %d", &tm.first, &tm.second);
i = int(lower_bound(d, d + k, tm) - d);
if (d[i] == tm)
puts("Waste");
else {
r = ((tm.first - 1) * m + tm.second - 1 - i) % 3;
if (!r)
puts("Carrots");
else if (r == 1)
puts("Kiwis");
else
puts("Grapes");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
char buf[100000], *p1 = buf, *p2 = buf;
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return (f == 1) ? x : -x;
}
inline int min(int a, int b) { return a < b ? a : b; }
inline int max(int a, int b) { return a > b ? a : b; }
const int mod = 1e9 + 7, maxn = 1e6 + 5;
int n, m, a, b;
int fac[maxn], inv[maxn];
inline int qpow(int x, int k) {
if (k < 0) k = -k, x = qpow(x, mod - 2);
int ret = 1;
while (k) {
if (k & 1) ret = 1ll * ret * x % mod;
x = 1ll * x * x % mod, k >>= 1;
}
return ret;
}
inline void init() {
fac[0] = fac[1] = inv[0] = inv[1] = 1;
for (int i = 2; i <= maxn - 1; ++i)
fac[i] = 1ll * fac[i - 1] * i % mod,
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
for (int i = 2; i <= maxn - 1; ++i) inv[i] = 1ll * inv[i - 1] * inv[i] % mod;
}
inline void input() { n = gi(), m = gi(), a = gi(), b = gi(); }
inline int C(int n, int m) {
if (n < m) return 0;
if (n < 0 || m < 0) return 0;
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
inline void solve() {
int ans = 0;
for (int i = 1; i <= n; ++i) {
int sum = C(n - 2, i - 1);
sum = 1ll * sum * fac[i - 1] % mod;
sum = 1ll * sum * C(m - 1, i - 1) % mod;
sum = 1ll * qpow(n, n - i - 2) * sum % mod * (i + 1) % mod;
sum = 1ll * sum * qpow(m, n - i - 1) % mod;
ans = (ans + sum) % mod;
}
printf("%d\n", ans);
}
int main() {
init();
input();
solve();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int module = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, p;
cin >> n >> m >> p;
--p;
string s, q;
cin >> s >> q;
vector<int> r(n);
stack<int> st;
for (int i = 0; i < n; ++i) {
if (s[i] == '(')
st.push(i);
else {
r[st.top()] = i;
r[i] = st.top();
st.pop();
}
}
set<int> pos;
for (int i = 0; i < n; ++i) pos.insert(i);
for (int i = 0; i < m; ++i) {
if (q[i] == 'L') {
auto it = pos.find(p);
--it;
p = *it;
}
if (q[i] == 'R') {
auto it = pos.find(p);
++it;
p = *it;
}
if (q[i] == 'D') {
int begin = min(p, r[p]), end = max(p, r[p]);
for (auto it = pos.lower_bound(begin); it != pos.end() && *it <= end;) {
auto it2 = it;
++it2;
pos.erase(it);
it = it2;
}
auto it = pos.lower_bound(p);
if (it == pos.end())
p = *pos.rbegin();
else
p = *it;
}
}
for (auto it = pos.begin(); it != pos.end(); ++it) cout << s[*it];
cout << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Dinic {
static const int MAXN = 100005, MAXM = 1000005;
struct Edge {
int to, next;
T cap;
} edge[MAXM];
int head[MAXN], tot;
void clear() {
memset(head, -1, sizeof(head));
tot = 0;
}
Dinic() { clear(); }
void add(int u, int v, T c) {
edge[tot] = (Edge){v, head[u], c};
head[u] = tot++;
edge[tot] = (Edge){u, head[v], (T)0};
head[v] = tot++;
}
int dis[MAXN], que[MAXN], id[MAXN];
bool bfs(int s, int t) {
memset(dis, -1, sizeof(dis));
memcpy(id, head, sizeof(id));
int he = 0, ta = 0;
dis[que[ta++] = s] = 0;
while (he < ta) {
int u = que[he++];
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].to;
if (dis[v] < 0 && edge[i].cap) {
dis[que[ta++] = v] = dis[u] + 1;
if (v == t) return true;
}
}
}
return false;
}
T dfs(int u, int t, T f) {
if (u == t) return f;
T flow = 0;
for (int &i = id[u]; ~i; i = edge[i].next) {
int v = edge[i].to;
if (dis[v] > dis[u] && edge[i].cap) {
int d = dfs(v, t, min(f, edge[i].cap));
if (!d) continue;
edge[i].cap -= d, edge[i ^ 1].cap += d;
flow += d, f -= d;
if (f == 0) return flow;
}
}
dis[u] = -1;
return flow;
}
T dinic(int s, int t, T inf = 1E9) {
T flow = 0;
while (bfs(s, t)) flow += dfs(s, t, inf);
return flow;
}
};
const long long INF = 1E15;
Dinic<long long> din;
const int MAXN = 100005;
int dis[105][105], xx[MAXN], aa[MAXN], ff[MAXN], pp[MAXN], qq[MAXN], vis[MAXN],
n, m;
struct Node {
int d, g;
} sh[MAXN];
vector<Node> nd[105];
bool cmp(const Node &a, const Node &b) { return a.d < b.d; }
int main() {
scanf("%d%d", &n, &m);
memset(dis, 0x3f, sizeof(dis));
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
dis[u][v] = dis[v][u] = 1;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++)
dis[j][k] = min(dis[i][j] + dis[i][k], dis[j][k]);
int S, B, K;
scanf("%d%d%d", &S, &B, &K);
for (int i = 1; i <= S; i++) {
scanf("%d%d%d%d", xx + i, aa + i, ff + i, pp + i);
sh[i] = (Node){aa[i], i};
}
sort(sh + 1, sh + 1 + S, cmp);
for (int i = 1; i <= B; i++) {
int x, d, g;
scanf("%d%d%d", &x, &d, &g);
nd[x].push_back((Node){d, g});
}
for (int i = 1; i <= n; i++) {
sort(nd[i].begin(), nd[i].end(), cmp);
int mx = 0;
for (Node &d : nd[i]) {
mx = max(mx, d.g);
d.g = mx;
}
}
fill(qq + 1, qq + 1 + S, -1E9);
for (int i = 1; i <= n; i++) {
int s = nd[i].size();
for (int j = 1, k = 0; j <= S; j++) {
for (; k < s && nd[i][k].d <= sh[j].d; ++k)
;
if (k > 0 && dis[i][xx[sh[j].g]] <= ff[sh[j].g])
qq[sh[j].g] = max(qq[sh[j].g], nd[i][k - 1].g);
}
}
for (int i = 1; i <= S; i++) pp[i] = qq[i] - pp[i];
for (int i = 1; i <= K; i++) {
int u, v;
scanf("%d%d", &u, &v);
din.add(u, v, INF);
vis[u] = vis[v] = 1;
}
long long ans = 0;
int s = S + 1, t = s + 1;
for (int i = 1; i <= S; i++)
if (!vis[i] && pp[i] > 0) ans += pp[i];
for (int i = 1; i <= S; i++)
if (vis[i]) {
if (pp[i] > 0)
din.add(s, i, pp[i]), ans += pp[i];
else
din.add(i, t, -pp[i]);
}
printf("%lld\n", ans - din.dinic(s, t, INF));
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename G>
void dd(map<T, G> &v) {
for (const auto &i : v) cout << i.first << " " << i.second << endl;
cout << endl;
}
template <typename T>
void dd(set<T> &v) {
for (const auto &i : v) cout << i << " ";
cout << endl;
}
template <typename T, typename G>
void dd(vector<pair<T, G>> &v) {
for (const auto &i : v) cout << i.first << " " << i.second << endl;
cout << endl;
}
template <typename T>
void dd(vector<vector<T>> &v) {
long long c = 0;
for (const auto &i : v) {
cout << c << " : ";
for (const auto &j : i) cout << j << " ";
cout << endl;
c++;
}
cout << endl;
}
template <typename T>
void dd(vector<T> v[], long long n) {
for (long long i = 0; i < n; i++) {
cout << i << " : ";
for (const auto &j : v[i]) cout << j << " ";
cout << endl;
}
cout << endl;
}
template <typename T>
void dd(vector<T> &v) {
for (const auto &i : v) cout << i << " ";
cout << endl;
}
template <typename T>
void dd(T a[], T n) {
for (long long i = 0; i < (int32_t)n; i++) cout << a[i] << " ";
cout << endl;
}
template <typename T>
void in(vector<T> &v) {
for (long long i = 0; i < (int32_t)v.size(); i++) cin >> v[i];
}
template <typename T>
void dd(T x) {
cout << x << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
dd(3);
dd("L " + to_string(s.length() - 1));
dd("R " + to_string(s.length() - 1));
dd("R " + to_string(2 * s.length() - 1));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000 + 10;
int mx, n, a, sar = 1;
long long ps[maxn];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
ps[i + 1] = ps[i] + a;
}
sort(ps + 1, ps + n + 1);
for (int i = 2; i <= n; i++) {
if (ps[i] != ps[i - 1]) {
mx = max(mx, i - sar);
sar = i;
}
}
mx = max(mx, n + 1 - sar);
cout << n - mx;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
map<long long, int> mp;
int arr[m];
long long sum = 0;
for (int i = 0; i < m; i++) {
cin >> arr[i];
sum += arr[i];
mp[arr[i]]++;
}
int cnt = 0;
int res = 0;
if (sum < n) {
cout << -1 << endl;
continue;
}
while (n != 0) {
if (1 & n && mp[(1ll << cnt)] > 0) {
mp[(1 << cnt)]--;
} else if (1 & n && mp[1ll << cnt] == 0) {
while (mp[1ll << cnt] == 0) {
int k = cnt;
while (mp[1ll << k] == 0) {
k++;
}
res++;
mp[1ll << k]--;
mp[1ll << (k - 1)] += 2;
}
mp[(1ll << cnt)]--;
}
mp[1ll << (cnt + 1)] += mp[(1ll << cnt)] / 2;
n >>= 1;
cnt++;
}
cout << res << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int cmp(vector<int> &a, vector<int> &b) {
int Min = min(a.size(), b.size());
int flag = 0;
for (int i = 0; i < Min; i++) {
if (a[i] > b[i]) return 1;
if (b[i] > a[i]) return 0;
}
if (a.size() > b.size()) return 1;
if (a.size() == b.size()) return 2;
return 0;
}
int a[222222];
int main() {
int n;
vector<int> q, q1;
long long sum = 0;
long long sum1 = 0;
int t;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &t);
a[i] = t;
if (t > 0)
q.push_back(t), sum += t;
else
q1.push_back(-t), sum1 += -t;
}
if (sum > sum1) {
printf("first\n");
return 0;
}
if (sum1 > sum) {
printf("second\n");
return 0;
}
int gg = cmp(q, q1);
if (gg == 1) printf("first\n");
if (gg == 0) printf("second\n");
if (gg == 2) {
if (a[n - 1] < 0)
printf("second\n");
else
printf("first\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int p[200005];
int main() {
long long int q, h, n;
cin >> q;
while (q--) {
cin >> h >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
int ans = 0;
p[n + 1] = 0;
for (int i = 2; i <= n; i++) {
if (p[i] == p[i + 1] + 1)
i++;
else
ans++;
}
cout << ans << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4005;
int a[maxn], b[maxn], v[maxn];
int p[maxn][maxn];
int main() {
int n, m;
cin >> n >> m;
memset(v, 0, sizeof(v));
memset(p, 0, sizeof(p));
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i];
v[a[i]]++;
v[b[i]]++;
p[a[i]][b[i]] = p[b[i]][a[i]] = 1;
}
bool flag = false;
int ans = 0x3f3f3f3f;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (p[a[i]][j] == 1 && p[b[i]][j] == 1) {
if (v[a[i]] + v[b[i]] + v[j] < ans) {
ans = v[a[i]] + v[b[i]] + v[j];
flag = true;
}
}
}
}
if (flag)
cout << ans - 6 << endl;
else
cout << -1 << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 1;
vector<long long> gaus;
int ans, n;
long long temp, a, b;
void add(long long val) {
int bit = 60, lol = 0;
for (auto i : gaus) {
while (bit && !(val & (1LL << bit)) && !(i & (1LL << bit))) bit--;
if (!(i & (1LL << bit)) && (val & (1LL << bit))) {
gaus.insert(gaus.begin() + lol, val);
return;
}
if ((i & (1LL << bit)) && (val & (1LL << bit))) val ^= i;
lol++;
}
if (val)
gaus.push_back(val);
else
ans++;
}
bool check(long long val) {
int bit = 60;
for (auto i : gaus) {
while (bit && !(val & (1LL << bit)) && !(i & (1LL << bit))) bit--;
if ((i & (1LL << bit)) && (val & (1LL << bit))) val ^= i;
}
return val;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &a, &b);
temp ^= a;
add(a ^ b);
}
if (check(temp)) return puts("1/1"), 0;
n -= ans;
printf("%lld/%lld\n", (1LL << n) - 1, (1LL << n));
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n;
for (k = 2; k * k < n; ++k)
if (n % k == 0) break;
if (n % k) return cout << "NO", 0;
int a = 1, b = n;
for (; b % k == 0; b /= k) a *= k;
if (b == 1) return cout << "NO", 0;
cout << "YES\n2\n";
if (a > b) swap(a, b);
for (int j = 1; j < a; ++j) {
if ((n - 1 - b * j) % a == 0)
return cout << j << " " << a << "\n"
<< (n - 1 - b * j) / a << " " << b,
0;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
vector<long long int> v(n);
map<long long int, long long int> m;
for (long long int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
long long int cnt = 0;
long long int ans = 0;
for (int i = n - 1; i >= 0; i--) {
if (v[i] % 2 == 0 && m[v[i]] == 0) {
long long int num = v[i];
cnt = 0;
while (num % 2 == 0) {
num = num / 2;
cnt++;
}
num = v[i];
m[num] = cnt;
while (num % 2 == 0) {
num = num / 2;
cnt--;
m[num] = cnt;
}
ans += m[v[i]];
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
bool debug = false;
int fa[20][N], deep[N], id[N], p[N];
vector<int> vc[N];
void dfs(int o, int f) {
deep[o] = deep[f] + 1, fa[0][o] = f;
for (int i = 1; i < 20; ++i) fa[i][o] = fa[i - 1][fa[i - 1][o]];
for (auto it : vc[o])
if (it != f) dfs(it, o);
}
int lca(int u, int v) {
if (deep[u] < deep[v]) swap(u, v);
int d = deep[u] - deep[v];
for (int i = 19; i >= 0; --i)
if ((d >> i) & 1) u = fa[i][u];
if (u == v) return u;
for (int i = 19; i >= 0; --i)
if (fa[i][u] != fa[i][v]) u = fa[i][u], v = fa[i][v];
return fa[0][u];
}
struct Node {
int tmp, l, r, _lca;
} node[N << 2];
void mer(Node ls, Node rs, Node &o) {
if (ls.tmp < rs.tmp) swap(ls, rs);
if (ls.tmp == 2) {
o.tmp = 2;
return;
}
o.tmp = 1, o._lca = ls._lca, o.l = 0;
if (rs.tmp) {
if (ls._lca != rs._lca) {
o.tmp = 2;
return;
}
int x = lca(ls.l, rs.l), y = lca(ls.r, rs.r);
if ((x == ls.l || x == rs.l) && (y == ls.r || y == rs.r)) {
o.l = x == ls.l ? rs.l : ls.l;
o.r = y == ls.r ? rs.r : ls.r;
}
x = lca(ls.l, rs.r), y = lca(ls.r, rs.l);
if ((y == ls.r || y == rs.l) && (x == ls.l || x == rs.r)) {
o.l = x == ls.l ? rs.r : ls.l;
o.r = y == ls.r ? rs.l : ls.r;
}
} else if (ls.tmp) {
if (deep[ls._lca] > deep[rs.l]) {
o.tmp = 2;
return;
}
int y = lca(ls.l, rs.r);
if (y == ls.l)
o.l = rs.r, o.r = ls.r;
else if (y == rs.r)
o.l = ls.l, o.r = ls.r;
else {
y = lca(ls.r, rs.r);
if (y == ls.r)
o.l = ls.l, o.r = rs.r;
else if (y == rs.r)
o.l = ls.l, o.r = ls.r;
}
} else {
if (deep[ls.l] > deep[rs.l]) swap(ls, rs);
int x = lca(ls.l, rs.l);
if (deep[x] < deep[ls.l])
o._lca = x, o.l = ls.r, o.r = rs.r;
else {
x = lca(ls.r, rs.r);
if (x == rs.r)
o.tmp = 0, o.l = ls.l, o.r = ls.r;
else if (x == ls.r)
o.tmp = 0, o.l = ls.l, o.r = rs.r;
else if (x == ls.l)
o._lca = ls.l, o.l = ls.r, o.r = rs.r;
}
}
if (!o.l) o.tmp = 2;
}
void build(int l, int r, int o) {
if (l == r) {
node[o].l = node[o].r = id[l], node[o].tmp = 0;
return;
}
int mid = l + r >> 1;
build(l, mid, o << 1);
build(mid + 1, r, o << 1 | 1);
mer(node[o << 1], node[o << 1 | 1], node[o]);
}
void update(int x, int v, int l, int r, int o) {
if (l == r) {
node[o].l = node[o].r = v, node[o].tmp = 0;
return;
}
int mid = l + r >> 1;
if (x <= mid)
update(x, v, l, mid, o << 1);
else
update(x, v, mid + 1, r, o << 1 | 1);
mer(node[o << 1], node[o << 1 | 1], node[o]);
}
int querty(int l, int r, int o) {
if (node[o].tmp < 2) return r - l + 1;
int ret = 0, mid;
Node ans, now;
ans.tmp = -1;
while (l != r) {
now.tmp = 2, mid = l + r >> 1;
if (node[o << 1].tmp <= 1) {
if (ans.tmp == -1)
now = node[o << 1];
else
mer(ans, node[o << 1], now);
}
if (now.tmp < 2) {
ans = now, ret += mid - l + 1;
l = mid + 1, o = o << 1 | 1;
} else
r = mid, o = o << 1;
}
return ret;
}
int main() {
int n, q, x, y, op;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &p[i]), id[p[i] + 1] = i;
for (int i = 2; i <= n; ++i) {
scanf("%d", &x);
vc[x].push_back(i);
}
dfs(1, 0);
build(1, n, 1);
scanf("%d", &q);
while (q--) {
scanf("%d", &op);
if (op == 1) {
scanf("%d%d", &x, &y);
update(p[x] + 1, y, 1, n, 1);
update(p[y] + 1, x, 1, n, 1);
swap(p[x], p[y]);
} else
printf("%d\n", querty(1, n, 1));
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 * 1e5 + 1;
char S[MAXN + 1];
int N, a, b, T, cur = 0, ans = 0;
int main() {
scanf("%d", &N), scanf("%d", &a), scanf("%d", &b), scanf("%d", &T);
scanf("%s", S);
int j = N - 1;
while (j > 0) cur += a + 1 + b * (S[j--] == 'w');
j++;
cur -= a;
for (int i = 0; i < (int)N; i++) {
cur += a + 1 + b * (S[i] == 'w');
while (j <= i) cur -= a + 1 + b * (S[j++] == 'w');
while (j < N && cur + a * min(i, N - j) > T)
cur -= a + 1 + b * (S[j++] == 'w');
if (cur + a * min(i, N - j) <= T) ans = max(ans, i + (N - j) + 1);
}
printf("%d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) { return a > b; }
int main() {
int t;
cin >> t;
while (t--) {
int a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
int pen = a / c;
if (a % c != 0) pen++;
int penc = b / d;
if (b % d != 0) penc++;
if (pen + penc > k)
cout << -1 << endl;
else
cout << pen << " " << k - pen << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int pwr(int a, int b) {
if (b == 0) return 1;
int c = pwr(a, b / 2);
if (b % 2) return c * c * a;
return c * c;
}
int main() {
int q;
cin >> q;
while (q--) {
long long n, cnt = 0;
cin >> n;
while (1) {
if (n % 2 == 0) {
n /= 2;
cnt++;
} else if (n % 3 == 0) {
n /= 3;
cnt += 2;
} else if (n % 5 == 0) {
n /= 5;
cnt += 3;
} else if (n == 1) {
cout << cnt;
break;
} else {
cout << "-1";
break;
}
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int mx = 2e3 + 10;
long long int dp[mx][mx];
const long long int mod = 1e9 + 7;
int main() {
long long int n, k;
cin >> n >> k;
dp[0][1] = 1;
for (long long int len = 1; len <= k; len++) {
for (long long int i = 1; i <= n; i++) {
for (long long int j = i; j <= n; j += i) {
dp[len][j] = (dp[len][j] + dp[len - 1][i]) % mod;
}
}
}
long long int res = 0;
for (long long int i = 1; i <= n; i++) res = (res + dp[k][i]) % mod;
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, k;
cin >> n >> k;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int flag[63];
memset(flag, 0, sizeof(flag));
for (int i = 0; i < n; i++) {
int j = 0;
long long int val = 1;
while (val < a[i]) {
val *= k;
j++;
}
while (val != 0) {
if (a[i] >= val && flag[j] == 0) {
a[i] -= val;
flag[j] = 1;
}
j--;
val /= k;
}
}
for (int i = 0; i < n; i++) {
if (a[i] != 0) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t-- > 0) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > v[500007];
pair<int, int> edge_list[500007];
int diam[2];
class Tree {
int root;
vector<int> ord;
int st[500007], en[500007];
int rev[500007];
int depth[500007], parity[500007];
void dfs(int vertex, int prv) {
ord.push_back(vertex);
st[vertex] = ord.size();
rev[st[vertex]] = vertex;
int sz = v[vertex].size();
for (int i = 0; i < sz; ++i) {
int to, cost;
to = v[vertex][i].first;
cost = v[vertex][i].second;
if (to == prv) {
continue;
}
depth[to] = depth[vertex] + 1;
parity[to] = parity[vertex] ^ cost;
dfs(to, vertex);
}
en[vertex] = ord.size();
}
int tr[4 * 500007][2];
int lazy[4 * 500007];
void unite(int where) {
for (int i = 0; i < 2; ++i) {
tr[where][i] = max(tr[2 * where][i], tr[2 * where + 1][i]);
}
}
void init_segtree(int where, int IL, int IR) {
lazy[where] = 0;
if (IL == IR) {
int x = rev[IL];
tr[where][parity[x]] = depth[x];
tr[where][parity[x] ^ 1] = 0;
return;
}
int mid = (IL + IR) / 2;
init_segtree(2 * where, IL, mid);
init_segtree(2 * where + 1, mid + 1, IR);
unite(where);
}
void push_lazy(int where, int IL, int IR) {
if (lazy[where] == 0) {
return;
}
swap(tr[where][0], tr[where][1]);
if (IL != IR) {
lazy[2 * where] ^= 1;
lazy[2 * where + 1] ^= 1;
}
lazy[where] = 0;
}
void update(int where, int IL, int IR, int CURL, int CURR) {
push_lazy(where, IL, IR);
if (IL > IR || CURL > CURR) {
return;
}
if (CURR < IL || IR < CURL) {
return;
}
if (CURL <= IL && IR <= CURR) {
lazy[where] ^= 1;
push_lazy(where, IL, IR);
return;
}
int mid = (IL + IR) / 2;
update(2 * where, IL, mid, CURL, CURR);
update(2 * where + 1, mid + 1, IR, CURL, CURR);
unite(where);
}
public:
void init(int _root) {
root = _root;
depth[root] = parity[root] = 0;
ord.clear();
dfs(root, -1);
init_segtree(1, 1, n);
}
void handle(int id) {
int x = edge_list[id].first;
int y = edge_list[id].second;
if (st[x] < st[y]) {
swap(x, y);
}
update(1, 1, n, st[x], en[x]);
}
int query() { return tr[1][0]; }
};
Tree w[2];
int len[500007];
int bfs(int ori) {
for (int i = 1; i <= n; ++i) {
len[i] = 500007;
}
len[ori] = 0;
queue<int> q;
q.push(ori);
while (q.empty() == false) {
int x = q.front();
q.pop();
int sz = v[x].size();
for (int i = 0; i < sz; ++i) {
int to = v[x][i].first;
if (len[to] == 500007) {
len[to] = len[x] + 1;
q.push(to);
}
}
}
int mx, id;
mx = id = 0;
for (int i = 1; i <= n; ++i) {
if (mx < len[i]) {
mx = len[i];
id = i;
}
}
return id;
}
void input() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
v[x].push_back({y, z});
v[y].push_back({x, z});
edge_list[i] = {x, y};
}
diam[0] = bfs(1);
diam[1] = bfs(diam[0]);
}
void solve() {
for (int i = 0; i < 2; ++i) {
w[i].init(diam[i]);
}
int q;
scanf("%d", &q);
while (q--) {
int x;
scanf("%d", &x);
w[0].handle(x);
w[1].handle(x);
printf("%d\n", max(w[0].query(), w[1].query()));
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
vector<int> node[10000 + 7 << 2];
bitset<20000 + 7> ans;
int n, k;
void insert(int now, int C, int L, int R, int ll, int rr) {
if (L >= ll && R <= rr) {
node[now].push_back(C);
return;
}
int mid = (L + R) >> 1;
if (mid >= ll) insert(now << 1, C, L, mid, ll, rr);
if (mid < rr) insert(now << 1 | 1, C, mid + 1, R, ll, rr);
}
void update(int L, int R, int now, bitset<20000 + 7> b) {
for (int i = 0; i < node[now].size(); i++) {
b |= (b << node[now][i]);
}
if (L == R) {
ans |= b;
return;
}
int mid = (L + R) >> 1;
update(L, mid, now << 1, b);
update(mid + 1, R, (now << 1) | 1, b);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
int l, r, x;
for (int i = 0; i < k; i++) {
cin >> l >> r >> x;
insert(1, x, 1, n, l, r);
}
update(1, n, 1, 1);
int cnt = 0;
vector<int> Q;
for (int i = 1; i <= n; i++) {
if (ans[i] == 1) {
cnt++;
Q.push_back(i);
}
}
cout << cnt << endl;
for (int i = 0; i < Q.size(); i++) cout << Q[i] << ' ';
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int b, w;
cin >> b >> w;
if (b >= w) {
if (b > 3 * w + 1)
cout << "NO\n";
else {
cout << "YES\n";
int i = 2;
for (int j = 2; j <= 2 * w + 1; ++j) {
cout << i << " " << j << "\n";
}
if (b >= w + 1) cout << 2 << " " << 1 << "\n";
b -= w + 1;
for (int j = 2; j <= 2 * w && b > 0; j += 2) {
cout << i - 1 << " " << j << "\n";
--b;
if (b > 0) {
cout << i + 1 << " " << j << "\n";
--b;
} else
break;
}
}
} else {
if (w > 3 * b + 1)
cout << "NO\n";
else {
cout << "YES\n";
int i = 3;
for (int j = 2; j <= 2 * b + 1; ++j) {
cout << i << " " << j << "\n";
}
if (w >= b + 1) cout << 3 << " " << 1 << "\n";
w -= b + 1;
for (int j = 2; j <= 2 * b && w > 0; j += 2) {
cout << i - 1 << " " << j << "\n";
--w;
if (w > 0) {
cout << i + 1 << " " << j << "\n";
--w;
} else
break;
}
}
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool solve(string x, string y) {
if (x == y) return true;
if (x.size() % 2 || y.size() % 2 || x.size() != y.size()) return false;
string a1, a2, b1, b2;
a1 = x.substr(0, x.size() / 2);
a2 = x.substr(x.size() / 2, x.size() / 2);
b1 = y.substr(0, y.size() / 2);
b2 = y.substr(y.size() / 2, y.size() / 2);
if (solve(a1, b1) && solve(a2, b2)) return true;
if (solve(a2, b1) && solve(a1, b2)) return true;
return false;
}
int main() {
string x, y;
cin >> x;
cin >> y;
if (solve(x, y)) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.