solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long n, cur, kol = 1;
vector<long long> mini, maxi;
vector<long long> arr;
void read_LOOOOL() {
cin >> n;
mini.resize(n);
maxi.resize(n);
arr.resize(n);
for (int i = 0; i < n; i++) cin >> arr[i];
}
void calculate_maxes_KEEEEEEEEk() {
cur = -1;
for (int i = 0; i < n; i++)
if (arr[i] > cur) {
cur = arr[i];
maxi[i] = arr[i];
} else
maxi[i] = maxi[i - 1];
}
void calculate_SINI_minis_CHEBURECK() {
cur = 1000000000 + 7;
for (int i = arr.size() - 1; i >= 0; i--) {
if (arr[i] < cur) {
cur = arr[i];
mini[i] = arr[i];
} else
mini[i] = mini[i + 1];
}
}
void proceed() {
for (int i = 0; i < n - 1; i++) {
if (maxi[i] <= mini[i + 1]) kol++;
}
}
int main() {
read_LOOOOL();
calculate_maxes_KEEEEEEEEk();
calculate_SINI_minis_CHEBURECK();
proceed();
cout << kol;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int p = 1, n, j, a[105];
char c;
int main() {
a[j++] = 1;
while (cin >> c && c != '=') {
if (c == '-') p--, a[j++] = -1;
if (c == '+') p++, a[j++] = 1;
}
cin >> n;
for (int i = 0; i < j; i++) {
if (a[i] > 0)
while (p < n && a[i] < n) a[i]++, p++;
else
while (p > n && a[i] < 0 && a[i] > -n) a[i]--, p--;
}
if (p != n) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
cout << a[0] << " ";
for (int i = 1; i < j; i++)
if (a[i] < 0)
cout << " - " << -a[i];
else
cout << " + " << a[i];
cout << " = " << n;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
const long double EPS = 1E-9;
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double PI = 3.1415926535897932384626433832795;
int ans = 0, n, d[210], p[210];
vector<int> g[210];
bool used[210];
void DFS(int v) {
int pp = 0;
used[v] = true;
d[v] = 0;
vector<int> a;
for (int i = 0; i < (int)(g[v].size()); i++) {
int u = g[v][i];
if (!used[u]) {
DFS(u);
d[v] = max(d[v], d[u] + 1);
pp = max(pp, p[u]);
a.push_back(d[u]);
}
}
sort(a.rbegin(), a.rend());
if (a.size() <= 1)
p[v] = d[v];
else
p[v] = a[0] + a[1] + 2;
p[v] = max(p[v], pp);
}
void solve(int root) {
memset(used, 0, sizeof used);
DFS(root);
multiset<int> st;
for (int i = 0; i < (int)(g[root].size()); i++) {
int v = g[root][i];
st.insert(-p[v]);
}
for (int i = 0; i < (int)(g[root].size()); i++) {
int v = g[root][i];
st.erase(st.find(-p[v]));
for (int j = 0; j < (int)(g[root].size()); j++) {
int u = g[root][j];
if (v == u) continue;
st.erase(st.find(-p[u]));
ans = max(ans, (d[u] + 1) * d[v]);
ans = max(ans, (d[v] + 1) * d[u]);
if (!st.empty()) ans = max(ans, -(d[v] + d[u] + 2) * (*st.begin()));
st.insert(-p[u]);
}
st.insert(-p[v]);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)(n - 1); i++) {
int v, u;
scanf("%d%d", &v, &u);
v--, u--;
g[v].push_back(u);
g[u].push_back(v);
}
for (int i = 0; i < (int)(n); i++) solve(i);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 100;
int n, p, k;
int dp[2][maxn][55][55];
int maks[2][2][maxn][55];
int tmaks[2][maxn];
int question[2][maxn];
int main() {
scanf("%d %d %d", &n, &p, &k);
int cnt, x;
int res = 0;
for (int i = 0; i < 2; ++i) {
scanf("%d", &cnt);
while (cnt--) {
scanf("%d", &x);
question[i][x] = 1;
}
}
if (p > 2 * ceil(n / k)) {
for (int i = 1; i <= n; ++i) res += (question[0][i] || question[1][i]);
cout << res << endl;
return 0;
}
int now = 0;
memset(dp, 0xc0, sizeof dp);
memset(maks, 0xc0, sizeof maks);
memset(tmaks, 0xc0, sizeof tmaks);
maks[1][0][0][0] = maks[1][1][0][0] = tmaks[1][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= p; ++j) {
tmaks[now][j] = -0x3f3f3f3f;
for (int r = 0; r <= k; ++r) {
maks[now][0][j][r] = maks[now][1][j][r] = -0x3f3f3f3f;
for (int r1 = 0; r1 <= k; ++r1) dp[now][j][r][r1] = -0x3f3f3f3f;
}
}
for (int j = 0; j <= p; ++j) {
for (int r1 = 0; r1 <= k; ++r1) {
for (int r2 = 0; r2 <= k; ++r2) {
int &cur = dp[now][j][r1][r2];
if (r1 > 1 && r2 > 1 && j >= 2)
cur = max(cur, dp[!now][j][r1 - 1][r2 - 1] +
(question[0][i] || question[1][i]));
if ((r1 == 0 || r1 == 1) && j >= r1 && !(r2 == 0 || r2 == 1))
cur = max(cur, maks[!now][0][j - r1][r2 - 1] +
(question[1][i] || (question[0][i] && r1)));
if ((r2 == 0 || r2 == 1) && j >= r2 && !(r1 == 0 || r1 == 1))
cur = max(cur, maks[!now][1][j - r2][r1 - 1] +
((question[1][i] && r2) || question[0][i]));
if ((r1 == 0 || r1 == 1) && (r2 == 0 || r2 == 1) && j >= r1 + r2)
cur = max(cur, tmaks[!now][j - r1 - r2] + ((question[0][i] && r1) ||
(question[1][i] && r2)));
tmaks[now][j] = max(tmaks[now][j], cur);
maks[now][0][j][r2] = max(maks[now][0][j][r2], cur);
maks[now][1][j][r1] = max(maks[now][1][j][r1], cur);
res = max(res, cur);
}
}
}
now = !now;
}
printf("%d\n", res);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int L[220], R[220];
int n;
bool vis[7];
double f(int k) {
double ret = 1;
for (int i = 0; i < n; ++i) {
if (vis[i]) continue;
if (L[i] >= k) return 0;
if (R[i] < k) continue;
ret *= (k - L[i]) / (R[i] - L[i] + 1.0);
}
return ret;
}
double g(int k) {
double ret = 0;
int a[6];
int cnt = 0;
for (int i = 0; i < n; ++i)
if (!vis[i]) a[cnt++] = i;
for (int i = 0; i < (1 << cnt); ++i) {
int c = 0;
double pp = 1;
for (int j = 0; j < cnt; ++j)
if (i >> j & 1) {
++c;
}
if (c == 0) continue;
for (int j = 0; j < cnt; ++j) {
if (i >> j & 1) {
if (R[a[j]] < k || L[a[j]] > k) {
pp = 0;
break;
}
vis[a[j]] = 1;
pp *= 1.0 / (R[a[j]] - L[a[j]] + 1);
}
}
if (pp > 0) {
ret += pp * f(k);
}
for (int j = 0; j < cnt; ++j)
if (i >> j & 1) vis[a[j]] = 0;
}
return ret;
}
int main() {
while (cin >> n) {
for (int i = 0; i < n; ++i) {
cin >> L[i] >> R[i];
}
double ans = 0;
for (int i = 1; i <= 10000; ++i) {
double p = 0;
for (int j = 0; j < (1 << n); ++j) {
int cnt = 0;
for (int k = 0; k < n; ++k)
if (j >> k & 1) ++cnt;
if (cnt == 1 || cnt == 0) continue;
double pp = 1;
for (int k = 0; k < n; ++k) {
if (j >> k & 1) {
vis[k] = 1;
if (R[k] < i || L[k] > i)
pp = 0;
else
pp *= 1.0 / (R[k] - L[k] + 1);
}
}
if (pp > 0) p += pp * f(i);
memset(vis, 0, sizeof vis);
}
for (int j = 0; j < n; ++j) {
double pp = 0;
if (R[j] > i) {
if (L[j] > i)
pp = 1;
else
pp = (R[j] - i + 0.0) / (R[j] - L[j] + 1);
vis[j] = 1;
p += pp * g(i);
vis[j] = 0;
}
}
ans += i * p;
}
printf("%.12lf\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long x, y;
scanf("%lld%lld", &x, &y);
long long ans = 0;
long long a, b, c, d, e, f;
scanf("%lld%lld%lld%lld%lld%lld", &a, &b, &c, &d, &e, &f);
a = min(a, f + b), b = min(b, a + c), c = min(c, b + d);
d = min(d, c + e), e = min(e, d + f), f = min(f, e + a);
if (x * y > 0) {
if (x < 0) {
x = abs(x), y = abs(y);
long long mi = min(x, y);
if (d < c + e) x -= mi, y -= mi, ans += mi * d;
ans += x * c + y * e;
} else {
long long mi = min(x, y);
if (a < b + f) x -= mi, y -= mi, ans += mi * a;
ans += x * f + y * b;
}
} else {
if (x > 0)
ans += x * f;
else
ans += abs(x) * c;
if (y > 0)
ans += y * b;
else
ans += abs(y) * e;
}
printf("%lld\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename Int>
Int gcd(Int a, Int b) {
while (a != 0) {
b %= a;
if (b == 0) return a;
a %= b;
}
return b;
}
template <typename Int, typename RInt = Int>
Int lcm(Int a, Int b) {
return a / gcd(a, b) * static_cast<RInt>(b);
}
template <typename Int, typename XInt>
Int extended_gcd(Int a, Int b, XInt &x, XInt &y) {
static_assert(std::numeric_limits<XInt>::is_signed, "x, y must be signed");
if (b == 0) {
x = 1;
y = 0;
return a;
}
Int g = extended_gcd(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
template <typename Int, typename TInt = int64_t>
Int mul_mod(Int a, Int b, Int m) {
TInt p = a;
p = (p * b) % m;
return p;
}
template <typename Int, typename PInt, typename TInt = int64_t>
Int pow_mod(Int a, PInt p, Int m) {
Int r;
a %= m;
for (r = 1; p; p >>= 1) {
if (p & 1) r = mul_mod(r, a, m);
a = mul_mod(a, a, m);
}
return r;
}
template <typename Int, typename XInt = typename std::make_signed<Int>::type>
Int inv_mod(Int a, Int m) {
XInt x, y;
extended_gcd(a, m, x, y);
if (x < 0) return x + m;
return x;
}
template <typename Int>
Int div_pos_r(Int a, Int b, Int &r) {
Int q = a / b;
r = a % b;
if (r < 0) {
if (b < 0)
q += 1, r -= b;
else
q -= 1, r += b;
}
return q;
}
template <typename Int, typename TInt = int64_t>
TInt crt2(Int a1, Int m1, Int a2, Int m2) {
Int k1, k2;
Int g = extended_gcd(m1, m2, k1, k2);
Int r1, r2;
a1 = div_pos_r(a1, g, r1);
a2 = div_pos_r(a2, g, r2);
if (r1 != r2) throw 0;
m1 /= g;
m2 /= g;
TInt m12 = static_cast<TInt>(m1) * m2;
return (static_cast<TInt>(a2) * k1 % m2 * m1 +
static_cast<TInt>(a1) * k2 % m1 * m2) %
m12 * g +
r1;
}
template <typename Int>
Int counting(Int L, Int R, Int x0, Int dx) {
Int tmp;
return div_pos_r(R - x0, dx, tmp) - div_pos_r(L - 1 - x0, dx, tmp);
}
template <typename Int>
Int crtn(const std::vector<Int> &as, const std::vector<Int> &ms) {
Int r = 1;
Int m = 1;
for (int i = 0; i < as.size(); ++i) {
r = crt2(r, m, as[i], ms[i]);
m *= ms[i];
}
return r;
}
template <typename Int>
Int factorial_exp(Int n, Int p) {
Int r = 0;
while (n) {
n = n / p;
r += n;
}
return r;
}
template <typename Int>
std::pair<Int, bool> log(Int n, Int b) {
if (n <= 0) return {-1, true};
Int ans = 0;
bool frac = false;
while (n >= b) {
frac = frac || (n % b != 0);
ans += 1;
n /= b;
}
if (n != 1) frac = true;
return {ans, frac};
}
struct int_iterator {
int i;
explicit int_iterator(int i = 0) : i(i) {}
int operator*() const { return i; }
int_iterator &operator++() {
++i;
return *this;
}
bool operator==(const int_iterator &that) const { return i == that.i; }
bool operator!=(const int_iterator &that) const { return !(*this == that); }
};
struct range {
int b, e;
range(int bp, int ep) : b(bp), e(ep) {
if (e < b) e = b;
}
range(int e) : b(0), e(e) {}
int_iterator begin() const { return int_iterator(b); }
int_iterator end() const { return int_iterator(e); }
};
range nrange(int n) { return range(1, n + 1); }
range inrange(int b, int e) { return range(b, e + 1); }
template <typename T>
T &chmax(T &m, const T &v) {
if (v > m) m = v;
return m;
}
template <typename T>
T &chmin(T &m, const T &v) {
if (v < m) m = v;
return m;
}
template <typename T>
struct pos_checker {
static bool check(const T &v) { return v >= 0; }
};
template <typename T, typename Checker = pos_checker<T> >
T &chmax_s(T &m, const T &v) {
if (!Checker::check(v)) return m;
if (!Checker::check(m)) return m = v;
return chmax(m, v);
}
template <typename T, typename Checker = pos_checker<T> >
T &chmin_s(T &m, const T &v) {
if (!Checker::check(v)) return m;
if (!Checker::check(m)) return m = v;
return chmin(m, v);
}
const int MOD = 1000000007;
vector<int> C(int k, int t) {
vector<int> cur = {1};
for (int i : range(t)) {
vector<int> next(cur.size() + k - 1);
int v = 0;
for (int j : range(next.size())) {
if (j < cur.size()) v = (v + cur[j]) % MOD;
if (j - k >= 0) v = ((v - cur[j - k]) % MOD + MOD) % MOD;
next[j] = v;
}
swap(cur, next);
}
return cur;
}
vector<int> acc(vector<int> v) {
vector<int> r;
int x = 0;
for (int c : v) {
x = (x + c) % MOD;
r.push_back(x);
}
return r;
}
int main() {
int a, b, k, t;
cin >> a >> b >> k >> t;
vector<int> cnt = C(2 * k + 1, t);
vector<int> sum = acc(cnt);
int ans = 0;
for (int i : range(cnt.size())) {
int s = a + i - b - 1;
if (s < 0)
continue;
else if (s >= cnt.size())
ans = (ans + mul_mod(cnt[i], sum.back(), MOD)) % MOD;
else
ans = (ans + mul_mod(cnt[i], sum[s], MOD)) % MOD;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf64 = 1e18;
enum TokenType { RESERVED, NUMBER, WORD };
struct Token {
TokenType tokenType;
string value;
void print() { cout << tokenType << " " << value << "\n"; }
};
bool is_good_for_word(char c) {
if ('a' <= c && c <= 'z') return true;
if ('A' <= c && c <= 'Z') return true;
if (isdigit(c)) return true;
if (c == '_' || c == '$') return true;
return false;
}
bool is_good_for_word(string s) {
for (char c : s) {
if (!is_good_for_word(c)) {
return false;
}
}
return true;
}
string get_next(string t) {
for (int i = (int)t.size() - 1; i >= 0; i--) {
if (t[i] != 'z') {
t[i]++;
for (int j = i + 1; j < (int)t.size(); j++) {
t[j] = 'a';
}
return t;
}
}
return string(t.size() + 1, 'a');
}
bool is_number_f(string s) {
for (char c : s) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
set<string> reserved;
vector<Token> parse(string codeline) {
vector<Token> tokens;
for (int i = 0; i < (int)codeline.size(); i++) {
if (codeline[i] == '#') {
codeline = codeline.substr(0, i);
}
}
for (int i = 0; i < (int)codeline.size(); i++) {
if (codeline[i] == ' ') continue;
int reserved_j;
{
int j = -1;
for (int q = i; q < (int)codeline.size(); q++) {
if (reserved.count(codeline.substr(i, q - i + 1))) {
j = q;
}
}
reserved_j = j;
}
int number_j;
{
int j = i;
while (j < (int)codeline.size() && isdigit(codeline[j])) {
j++;
}
number_j = j - 1;
}
int word_j;
{
int j = i;
while (is_good_for_word(codeline[j])) {
j++;
}
word_j = isdigit(codeline[i]) ? -1 : j - 1;
}
if (reserved_j >= number_j && reserved_j >= word_j) {
tokens.push_back({RESERVED, codeline.substr(i, reserved_j - i + 1)});
i = reserved_j;
} else if (word_j >= number_j) {
tokens.push_back({WORD, codeline.substr(i, word_j - i + 1)});
i = word_j;
} else {
tokens.push_back({NUMBER, codeline.substr(i, number_j - i + 1)});
i = number_j;
}
}
return tokens;
}
bool check(const vector<Token> &a, const vector<Token> &b) {
if (a.size() != b.size()) {
return false;
}
for (int i = 0; i < (int)a.size(); i++) {
if (a[i].value != b[i].value) {
return false;
}
if (a[i].tokenType != b[i].tokenType) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string buf;
int n;
cin >> n;
getline(cin, buf);
for (int i = 0; i < n; i++) {
cin >> buf;
reserved.insert(buf);
}
getline(cin, buf);
int m;
cin >> m;
getline(cin, buf);
vector<string> code(m);
for (int i = 0; i < m; i++) {
getline(cin, code[i]);
}
vector<Token> tokens, add_tokens;
for (const string &codeline : code) {
add_tokens = parse(codeline);
for (const auto &token : add_tokens) {
tokens.push_back(token);
}
}
unordered_map<string, string> for_words;
string cur_short_word;
for (Token &token : tokens) {
if (token.tokenType == WORD) {
if (!for_words.count(token.value)) {
while (true) {
cur_short_word = get_next(cur_short_word);
if (!reserved.count(cur_short_word)) {
break;
}
}
for_words[token.value] = cur_short_word;
}
token.value = for_words[token.value];
}
}
vector<int> sp(tokens.size());
for (int i = 1; i < (int)tokens.size(); i++) {
if (is_number_f(tokens[i - 1].value) && is_number_f(tokens[i].value))
sp[i - 1] = 1;
if (!isdigit(tokens[i - 1].value.front()) &&
is_good_for_word(tokens[i - 1].value) &&
is_good_for_word(tokens[i].value.front()))
sp[i - 1] = 1;
if (is_number_f(tokens[i - 1].value) && isdigit(tokens[i].value.front()))
sp[i - 1] = 1;
}
string total_string = "";
for (const auto &token : tokens) {
total_string += token.value;
}
vector<pair<int, int> > segs;
for (const string &r : reserved) {
int sum = 0;
for (int i = 0; i + 1 < (int)tokens.size();
sum += (int)tokens[i].value.size(), i++) {
if ((int)r.size() <= (int)tokens[i].value.size()) continue;
if (total_string.substr(sum, (int)r.size()) == r) {
int acc = (int)tokens[i].value.size();
int j = i;
while (j + 1 < (int)tokens.size() &&
acc + (int)tokens[j + 1].value.size() < (int)r.size()) {
acc += (int)tokens[j + 1].value.size();
j++;
}
segs.emplace_back(i, j);
}
}
}
sort(segs.begin(), segs.end(),
[&](const pair<int, int> &p1, const pair<int, int> &p2) {
return p1.second < p2.second;
});
int last = -inf;
for (const pair<int, int> &p : segs) {
if (p.first > last) {
last = p.second;
sp[p.second] = 1;
}
}
for (int i = 0; i < (int)tokens.size(); i++) {
cout << tokens[i].value;
if (sp[i]) {
cout << ' ';
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, t;
cin >> t;
while (t--) {
cin >> n;
cout << (360 % (180 - n) ? "NO\n" : "YES\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int calc(vector<int> a) {
int m;
int ans = 0;
for (int i = 0; i < a.size(); i++) {
for (int j = i; j < a.size(); j++) {
m = a[j];
for (int k = i; k <= j; k++) m = min(m, a[k]);
ans += m;
}
}
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) a[i] = i + 1;
vector<vector<int> > ans;
do {
ans.push_back(a);
} while (next_permutation(a.begin(), a.end()));
int max = -1000;
vector<int> cValue;
for (int i = 0; i < ans.size(); i++) {
int xx = calc(ans[i]);
cValue.push_back(xx);
if (xx >= max) max = xx;
}
vector<int> F;
for (int i = 0; i < cValue.size(); i++)
if (cValue[i] == max) F.push_back(i);
for (int i = 0; i < n; i++) cout << ans[F[m - 1]][i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
const int mod = 1e9 + 7;
int cnt1[N], cnt2[N];
int main() {
string s;
cin >> s;
int i;
s = " " + s;
int n = (int)s.size() - 1;
for (i = 1; i < (int)s.size(); i++) {
if (s[i] >= 'a' && s[i] <= 'z')
cnt1[i] = cnt1[i - 1] + 1;
else
cnt1[i] = cnt1[i - 1];
if (s[i] >= 'A' && s[i] <= 'Z')
cnt2[i] = cnt2[i - 1] + 1;
else
cnt2[i] = cnt2[i - 1];
}
int ans = 1e9;
for (i = 0; i <= n; i++) {
ans = min(ans, cnt1[i] + cnt2[n] - cnt2[i]);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 111;
struct T {
long long k, c;
T() {}
T(long long _k, long long _c) {
k = _k;
c = _c;
}
bool operator<(const T &b) const { return c < b.c; }
};
T a[maxN];
long long p[maxN];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
long long k, c;
cin >> k >> c;
a[i] = T(k, c);
}
int t;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> p[i + 1];
}
long long f = 1;
long long score = 0;
long long d = 0;
sort(a, a + n);
for (int i = 0; i < n; i++) {
while (f <= t && a[i].k > 0) {
if (a[i].k + d >= p[f]) {
long long diff = p[f] - d;
a[i].k -= diff;
score += diff * f * a[i].c;
d += diff;
f++;
} else {
long long diff = a[i].k;
a[i].k = 0;
d += diff;
score += diff * f * a[i].c;
}
}
if (a[i].k > 0) {
score += f * a[i].k * a[i].c;
}
}
cout << score << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int first = 0, second = 0, draw = 0;
for (int i = 1; i <= 6; ++i) {
if (abs(a - i) < abs(b - i)) {
++first;
continue;
}
if (abs(b - i) < abs(a - i)) {
++second;
continue;
}
++draw;
}
cout << first << ' ' << draw << ' ' << second;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int _a, int _b) {
if (_a < 0) _a = -_a;
if (_b < 0) _b = -_b;
while (_a != 0 && _b != 0)
if (_a > _b)
_a %= _b;
else
_b %= _a;
return _a + _b;
}
int main() {
int n, m, mas[100500], i, j, a, d1, d2;
scanf("%d%d", &n, &m);
for (i = 0; i < n; ++i) scanf("%d", &mas[i]);
int g = mas[0] - 1;
for (i = 1; i < n; ++i) g = gcd(g, mas[i] - 1);
map<int, int> d;
map<int, int>::iterator it;
a = g;
for (j = 1; j * j <= a; ++j) {
if (a % j == 0) {
d1 = j;
d2 = a / j;
if (d1 == d2) d2 = 0;
if (d1 & 1) {
it = d.find(d1);
if (it != d.end())
it->second++;
else
d[d1] = 1;
}
if (d2 & 1) {
it = d.find(d2);
if (it != d.end())
it->second++;
else
d[d2] = 1;
}
}
}
int k, t;
long long res = 0;
for (it = d.begin(); it != d.end(); ++it) {
a = it->first + 1;
t = m / (a - 1);
k = 0;
while ((1 << k) * (a - 1) < m) ++k;
res += m * 1LL * k - (a - 1) * 1LL * ((1LL << k) - 1);
}
cout << res;
return 0;
}
int cpp4cf_main() {
freopen("E.cpp", "r", stdin);
char s[99];
bool f;
while (true) {
cin >> s;
if (cin.eof()) break;
if (strstr(s, "/*")) {
cin >> s;
if (strstr(s, "Test")) {
cin >> s;
if (strstr(s, "on")) {
cout << "Output: ";
cpp4cf_main();
cout << "\nAnswer: ";
f = false;
while (true) {
cin >> s;
if (strstr(s, "*/")) break;
if (strstr(s, "//")) {
if (f)
cout << endl;
else
f = true;
} else
cout << s << " ";
}
cout << "\n\n";
}
}
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace ::std;
const long double PI = acos(-1);
const long long MOD = 1000000000 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long add(long long a, long long b, long long m = MOD) {
if (a >= m) a %= m;
if (b >= m) b %= m;
if (a < 0) a += m;
if (b < 0) b += m;
long long res = a + b;
if (res >= m or res <= -m) res %= m;
if (res < 0) res += m;
return res;
}
long long mul(long long a, long long b, long long m = MOD) {
if (a >= m) a %= m;
if (b >= m) b %= m;
if (a < 0) a += m;
if (b < 0) b += m;
long long res = a * b;
if (res >= m or res <= -m) res %= m;
if (res < 0) res += m;
return res;
}
long long pow_mod(long long a, long long b, long long m = MOD) {
long long res = 1LL;
a = a % m;
while (b) {
if (b & 1) res = mul(res, a, m);
b >>= 1;
a = mul(a, a, m);
}
return res;
}
long long fastexp(long long a, long long b) {
long long res = 1LL;
while (b) {
if (b & 1) res = res * a;
b >>= 1;
a *= a;
}
return res;
}
int gcdExtendido(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtendido(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
int modInverso(int a, int m) {
int x, y;
int g = gcdExtendido(a, m, &x, &y);
if (g != 1)
return -1;
else
return (x % m + m) % m;
}
const int N = 200000 + 5;
const long long inf = 1e5;
int n, m, k;
int a[N];
int b[N];
int t[N];
int len;
int pos[N];
long long st[4 * N];
int cnt[4 * N];
bool none[N];
vector<int> justA, justB, both, extras;
void build(int pos = 1, int l = 0, int r = len) {
if (l == r) {
st[pos] = (l and none[extras[l - 1]]) ? t[extras[l - 1]] : 0;
cnt[pos] = (st[pos] > 0);
return;
}
int mi = (l + r) / 2;
build(2 * pos, l, mi);
build(2 * pos + 1, mi + 1, r);
st[pos] = st[2 * pos] + st[2 * pos + 1];
cnt[pos] = cnt[2 * pos] + cnt[2 * pos + 1];
}
void update(int x, int y, int pos = 1, int l = 0, int r = len) {
if (l == r) {
st[pos] = y;
cnt[pos] = (y > 0);
return;
}
int mi = (l + r) / 2;
if (l <= x and x <= mi)
update(x, y, 2 * pos, l, mi);
else
update(x, y, 2 * pos + 1, mi + 1, r);
st[pos] = st[2 * pos] + st[2 * pos + 1];
cnt[pos] = cnt[2 * pos] + cnt[2 * pos + 1];
}
long long query(int x, int y, int pos = 1, int l = 0, int r = len) {
if (y < l or r < x or x > y) return 0LL;
if (x <= l and r <= y) return st[pos];
int mi = (l + r) / 2;
return query(x, y, 2 * pos, l, mi) + query(x, y, 2 * pos + 1, mi + 1, r);
}
int solve(int k, int pos = 1, int l = 0, int r = len) {
if (cnt[pos] < k) return -1;
if (l == r) return l;
int mi = (l + r) / 2;
if (cnt[2 * pos] >= k)
return solve(k, 2 * pos, l, mi);
else
return solve(k - cnt[2 * pos], 2 * pos + 1, mi + 1, r);
}
vector<long long> getPrefix(vector<int> &v) {
vector<long long> ans(1, 0LL);
for (int i = 0; i < v.size(); i++) {
ans.emplace_back(ans.back() + t[v[i]]);
}
return ans;
}
vector<int> merge(vector<int> &a, vector<int> &b) {
vector<int> ans;
int p1 = 0, p2 = 0;
while (p1 < a.size() and p2 < b.size()) {
if (t[a[p1]] < t[b[p2]]) {
ans.emplace_back(a[p1]);
p1 += 1;
} else {
ans.emplace_back(b[p2]);
p2 += 1;
}
}
while (p1 < a.size()) {
ans.emplace_back(a[p1]);
p1 += 1;
}
while (p2 < b.size()) {
ans.emplace_back(b[p2]);
p2 += 1;
}
return ans;
}
vector<int> getAnswer(int bestid) {
vector<int> ans;
for (int i = 0; i < bestid; i++) {
ans.emplace_back(both[i]);
}
int wantA = max(0, k - bestid);
int wantB = max(0, k - bestid);
for (int i = 0; i < wantA; i++) {
ans.emplace_back(justA[i]);
}
for (int i = 0; i < wantB; i++) {
ans.emplace_back(justB[i]);
}
build();
for (int i = wantA; i < justA.size(); i++) {
int x = justA[i];
update(pos[x] + 1, t[x]);
}
for (int i = wantB; i < justB.size(); i++) {
int x = justB[i];
update(pos[x] + 1, t[x]);
}
int extra = m - bestid - wantB - wantA;
for (int i = 0; i < extra; i++) {
int p = solve(1);
ans.emplace_back(extras[p - 1]);
update(p, 0);
}
return ans;
}
int main() {
scanf("%d %d %d", &(n), &(m), &(k));
for (int i = 1; i <= n; i++) {
scanf("%d %d %d", &(t[i]), &(a[i]), &(b[i]));
if (a[i] and !b[i]) justA.emplace_back(i);
if (!a[i] and b[i]) justB.emplace_back(i);
if (a[i] and b[i]) both.emplace_back(i);
if (!a[i] and !b[i]) {
extras.emplace_back(i);
none[i] = true;
}
}
sort((justA).begin(), (justA).end(),
[&](int i, int j) { return t[i] < t[j]; });
sort((justB).begin(), (justB).end(),
[&](int i, int j) { return t[i] < t[j]; });
sort((both).begin(), (both).end(), [&](int i, int j) { return t[i] < t[j]; });
sort((extras).begin(), (extras).end(),
[&](int i, int j) { return t[i] < t[j]; });
extras = merge(extras, justA);
extras = merge(extras, justB);
len = extras.size();
for (int i = 0; i < extras.size(); i++) {
pos[extras[i]] = i;
}
build();
vector<long long> bothP = getPrefix(both);
vector<long long> justAP = getPrefix(justA);
vector<long long> justBP = getPrefix(justB);
long long best = LLONG_MAX;
int bestid = -1;
int posA = justA.size() - 1;
int posB = justB.size() - 1;
for (int i = 0; i < bothP.size(); i++) {
int wantA = max(0, k - i);
int wantB = max(0, k - i);
if (wantA >= justAP.size()) continue;
if (wantB >= justBP.size()) continue;
while (posA >= wantA) {
int x = justA[posA];
update(pos[x] + 1, t[x]);
posA -= 1;
}
while (posB >= wantB) {
int x = justB[posB];
update(pos[x] + 1, t[x]);
posB -= 1;
}
int suma = i + wantA + wantB;
if (suma > m) continue;
int need = solve(m - suma);
if (need == -1) continue;
long long cur = bothP[i] + justAP[wantA] + justBP[wantB] + query(0, need);
if (cur < best) {
best = cur;
bestid = i;
}
}
if (best == LLONG_MAX) best = -1;
printf("%lld\n", best);
if (best >= 0) {
vector<int> ans = getAnswer(bestid);
for (int i = 0; i < ans.size(); i++) {
printf("%d%c", ans[i], " \n"[i + 1 == ans.size()]);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &x, T y) {
return (y < x) ? (x = y, 1) : 0;
}
template <typename T>
inline bool chkmax(T &x, T y) {
return (y > x) ? (x = y, 1) : 0;
}
inline int read() {
int x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-') f = -1, c = getchar();
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ '0');
return x * f;
}
inline long long readll() {
long long x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-') f = -1, c = getchar();
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1ll) + (x << 3ll) + (c ^ '0');
return x * f;
}
const int maxn = 5000 + 10, mod = 1e9 + 7;
int dp[maxn], a[maxn];
inline int ksm(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = (long long)res * x % mod;
x = (long long)x * x % mod;
y >>= 1;
}
return res;
}
int main() {
int n = read(), m = read(), sum = 1;
dp[0] = 1;
for (register int i = 1, iend = n; i <= iend; ++i)
a[i] = read(), sum = (long long)sum * a[i] % mod;
for (register int i = 1, iend = n; i <= iend; ++i)
for (register int j = i, jend = 0; j >= jend; --j) {
if (j > 0)
dp[j] =
((long long)dp[j] * a[i] + (long long)dp[j - 1] * (mod - 1)) % mod;
else
dp[j] = ((long long)dp[j] * a[i]) % mod;
}
int Fac = 1, ans = 0;
for (register int i = 0, iend = min(n, m); i <= iend; ++i) {
ans = (ans + (long long)Fac * dp[i] % mod * ksm(n, m - i)) % mod;
Fac = (long long)Fac * (m - i) % mod;
}
ans = (long long)ans * ksm(ksm(n, m), mod - 2) % mod;
ans = (sum - ans + mod) % mod;
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,tree-vectorize")
#pragma GCC target("popcnt,sse3,sse4.1,sse4.2,avx,tune=native")
using namespace std;
using namespace rel_ops;
using ll = int64_t;
using Pii = pair<int, int>;
using ull = uint64_t;
using Vi = vector<int>;
void run();
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
run();
return 0;
}
ll modInv(ll a, ll m) {
if (a == 1) return 1;
return ((a - modInv(m % a, a)) * m + 1) / a;
}
constexpr int MOD = 998244353;
int n, m, q;
struct Query {
int begin, end, k, answer, ord;
bool operator<(const Query& r) const {
if (k != r.k) return k < r.k;
return ord < r.ord;
}
};
vector<Query> queries;
Vi pattern, inPattern, counts;
int ansUp, ansDown, mult1;
int lastK = -1, lastBegin, lastEnd;
void addElem(int e) {
ansUp = (ll(ansUp) * counts[e]--) % MOD;
ansDown = (ll(ansDown) * mult1--) % MOD;
}
void delElem(int e) {
ansUp = (ll(ansUp) * ++mult1) % MOD;
ansDown = (ll(ansDown) * ++counts[e]) % MOD;
}
int handle(int begin, int end, int k) {
if (lastK != k) {
lastK = k;
lastBegin = begin;
lastEnd = begin;
ansDown = ansUp = 1;
mult1 = (ll(m) * k) % MOD;
for (int i = (0); i < (n); i++) {
mult1 += 1;
ansUp = (ll(ansUp) * mult1) % MOD;
}
for (int i = (0); i < (m); i++) counts[i] = (inPattern[i] + k) % MOD;
}
while (lastBegin > begin) addElem(pattern[--lastBegin]);
while (lastEnd < end) addElem(pattern[lastEnd++]);
while (lastBegin < begin) delElem(pattern[lastBegin++]);
while (lastEnd > end) delElem(pattern[--lastEnd]);
ll ans = (ll(ansUp) * modInv(ansDown, MOD)) % MOD;
if (ans < 0) ans += MOD;
return ans;
}
ll hilbert(ll first, ll second, ll s, ll c = 0) {
if (s <= 1) return c;
s /= 2;
c *= 4;
if (second < s)
return hilbert(first & (s - 1), second, s, c + (first >= s) + 1);
if (first < s) return hilbert(2 * s - second - 1, s - first - 1, s, c);
return hilbert(second - s, first - s, s, c + 3);
}
void run() {
cin >> n >> m >> q;
int moSize = 1;
while (moSize < n) moSize *= 2;
pattern.resize(n);
inPattern.resize(m);
counts.resize(m);
for (auto& p : (pattern)) {
cin >> p;
p--;
inPattern[p]++;
}
queries.resize(q);
for (auto& p : (queries)) {
cin >> p.begin >> p.end >> p.k;
p.begin--;
p.ord = hilbert(p.begin, p.end, moSize);
}
Vi sorted(q);
iota((sorted).begin(), (sorted).end(), 0);
sort((sorted).begin(), (sorted).end(),
[](ll l, ll r) { return queries[l] < queries[r]; });
for (auto& i : (sorted)) {
auto& p = queries[i];
p.answer = handle(p.begin, p.end, p.k);
}
for (auto& p : (queries)) cout << p.answer << '\n';
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int inf = 2147483647;
const long long ll = 9223372036854775807, ninf = 1000000000;
const double eps = 1e-6;
const long long nll = 223372036854775807;
int key[] = {1, 2, 9, 64, 625, 7776, 117649, 2097152};
int main() {
int mod = 1000000007;
int a, b;
while (cin >> a >> b) {
long long ans = key[b - 1];
long long n = a - b;
for (int i = 0; i < a - b; i++) {
ans *= n;
ans %= mod;
}
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <iostream>
#include <vector>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tests;
cin >> tests;
int n, k, r;
string s;
for (int test = 0; test < tests; test++) {
cin >> n >> k >> s;
r = 0;
while (s[r] == s[n - r - 1] && r < k){
r += 1;
}
if (r >= k && n != 2 * k)
cout << "YES\n";
else cout << "NO\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string arr, brr;
void solve() {
vector<int> f1(26, 0), f2(26, 0);
for (int i = 0; i < arr.size(); i++) f1[arr[i] - 'a']++;
for (int i = 0; i < brr.size(); i++) f2[brr[i] - 'a']++;
long long ans = 0;
for (int i = 0; i < 26; i++) {
if (f2[i] == 0) continue;
if (f1[i] == 0) {
cout << "-1" << endl;
return;
}
if (f2[i] <= f1[i])
ans += f2[i];
else
ans += f1[i];
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> arr >> brr;
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> adj;
int n, m;
bool ok, en;
int vis[122];
void DFS(int v, int u, int c) {
vis[v] = 1;
if (v == u) {
ok = 1;
return;
}
for (int i = 0; i < adj[v].size(); ++i) {
if (!vis[adj[v][i].first] && adj[v][i].second == c)
DFS(adj[v][i].first, u, adj[v][i].second);
}
}
int main() {
cin >> n >> m;
adj.resize(n + 10);
for (int i = 0; i < m; ++i) {
int x, y, z;
cin >> x >> y >> z;
adj[x].push_back(make_pair(y, z));
adj[y].push_back(make_pair(x, z));
}
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int x, y;
cin >> x >> y;
int res = 0;
for (int i = 1; i <= m; ++i) {
en = 0;
ok = 0;
fill(vis, vis + n + 10, 0);
DFS(x, y, i);
if (ok) res++;
}
cout << res << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[33];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int last = 1111111111;
long long ans = 0;
for (int i = n - 1; i >= 0; i--) {
int v = a[i];
if (v >= last) v = last - 1;
v = max(0, v);
ans += v;
last = v;
}
printf("%I64d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long d1, d2, d3;
cin >> d1 >> d2 >> d3;
long long mn = 0, sum = 0, ans = 0, cnt = 0, ser = 0;
sum = d1 + d1 + d2 + d2;
ans = d1 + d2 + d3;
cnt = d2 + d3 + d3 + d2;
ser = d1 + d3 + d3 + d1;
mn = min(min(min(sum, ans), cnt), ser);
cout << mn << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b) {
if (b == 1) return a;
long long int temp = 1;
temp = power(a, b / 2) % 1000000007;
temp = (temp * temp) % 1000000007;
if (b & 1) {
temp *= a;
temp %= 1000000007;
}
return temp % 1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m;
cin >> n >> m;
long long int poss = power(2, m);
poss = (poss + 1000000007 - 1) % 1000000007;
long long int ans = power(poss, n);
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
cin >> a >> b >> n;
a = a * 10;
int f = 0;
for (int i = 0; i < 10; i++) {
if ((a + i) % b == 0) {
cout << a + i;
string s(n - 1, '0');
cout << s << endl;
f = 1;
break;
}
}
if (!f) cout << -1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void jpg() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
jpg();
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long a[n + 3];
memset(a, -1, sizeof a);
for (long long i = 1; i <= n; i++) cin >> a[i];
long long flag = 0, flag2 = 0;
if (n == 1 && a[1] == k) {
cout << "yes"
<< "\n";
continue;
}
for (long long i = 1; i <= n; i++) {
if (a[i] == k) flag2 = 1;
if (a[i] >= k) {
if (a[i + 1] >= k || a[i + 2] >= k) {
flag = 1;
}
}
}
if (flag && flag2) {
cout << "yes"
<< "\n";
} else
cout << "no"
<< "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
struct Edge {
int v, next;
} edge[N * 2];
int head[N], e;
void erase() {
e = 0;
memset(head, -1, sizeof(head));
}
void increase(int u, int v) {
edge[e].v = v;
edge[e].next = head[u];
head[u] = e++;
}
set<int> st[N];
set<pair<int, int> > pst;
int tris[N][3];
int rd[N];
int q[N], l, r;
int ans[N];
bool visit[N];
void topologicalSort(int n) {
l = r = 0;
int i, j;
for (i = 1; i <= n; i++)
if (rd[i] == 1) q[r++] = *(st[i].begin());
int id = 0;
while (l < r) {
int k = q[l++];
ans[id++] = k;
for (i = 0; i < 3; i++) {
rd[tris[k][i]]--;
st[tris[k][i]].erase(k);
if (rd[tris[k][i]] == 1) q[r++] = *(st[tris[k][i]].begin());
}
}
}
void dfs(int k) {
visit[k] = 1;
cout << k << " ";
for (int t = head[k]; t != -1; t = edge[t].next) {
int v = edge[t].v;
if (!visit[v]) dfs(v);
}
}
int main() {
ios::sync_with_stdio(false);
int z;
cin >> z;
while (z--) {
int n, i, j;
cin >> n;
for (i = 1; i <= n; i++) st[i].clear();
memset(rd, 0, 4 * n + 4);
int tri[3];
for (i = 1; i <= n - 2; i++) {
for (j = 0; j < 3; j++) {
cin >> tris[i][j];
st[tris[i][j]].insert(i);
rd[tris[i][j]]++;
}
}
topologicalSort(n);
pst.clear();
for (i = 0; i < n - 2; i++) {
for (j = 0; j < 3; j++) {
int a = tris[ans[i]][j];
int b = tris[ans[i]][(j + 1) % 3];
if (a > b) swap(a, b);
pair<int, int> pr = make_pair(a, b);
if (pst.find(pr) == pst.end())
pst.insert(pr);
else
pst.erase(pr);
}
}
erase();
for (set<pair<int, int> >::iterator itr = pst.begin(); itr != pst.end();
itr++) {
auto pr = *itr;
increase(pr.first, pr.second);
increase(pr.second, pr.first);
}
memset(visit, 0, sizeof(visit));
dfs(1);
cout << endl;
for (i = 0; i < n - 2; i++) cout << ans[i] << " ";
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long Maxn = 2e5 + 10;
const long long Inf = 0x7f7f7f7f;
const long long Inf_ll = 1ll * Inf * Inf;
const long long Mod = 998244353;
const double eps = 1e-7;
struct Hex {
long long a, b, pos;
bool operator<(const Hex &rhs) const { return b < rhs.b; }
} h[Maxn];
long long n, m, a[Maxn], pos, Ans[Maxn];
long long mypow(long long a, long long b) {
long long inv = 1;
while (b > 0) {
if (b & 1) inv = inv * a % Mod;
a = a * a % Mod;
b >>= 1;
}
return inv;
}
signed main() {
scanf("%lld %lld", &n, &m);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + 1 + n);
for (long long i = 1; i <= m; i++) {
scanf("%lld %lld", &h[i].a, &h[i].b);
h[i].pos = i;
}
sort(h + 1, h + 1 + m);
long long tmp1 = 0, tmp2 = 0, Sum = 0, inv_n = mypow(n, Mod - 2);
for (long long i = 1; i <= n; i++) {
if (a[i] < h[1].b) tmp1 += a[i], pos = i;
Sum += a[i];
}
tmp2 = Sum - tmp1;
for (long long i = 1; i <= m; i++) {
while (pos + 1 <= n && a[pos + 1] < h[i].b)
pos++, tmp1 += a[pos], tmp2 -= a[pos];
tmp1 %= Mod;
tmp2 = (tmp2 % Mod + Mod) % Mod;
if (h[i].a > n - pos) {
Ans[h[i].pos] = 0;
continue;
}
long long cnt = n - pos - h[i].a;
long long p = mypow(n - pos + 1, Mod - 2) * (n - pos + 1 - h[i].a) % Mod;
long long ans = 1ll * tmp1 * p % Mod;
ans = (ans + mypow(n - pos, Mod - 2) * cnt % Mod * tmp2 % Mod) % Mod;
Ans[h[i].pos] = ans;
}
for (long long i = 1; i <= m; i++) printf("%lld\n", Ans[i] % Mod);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101 * 2;
int a[N][N];
void solve() {
int n;
cin >> n;
memset(a, 0, sizeof a);
auto lose = [&](int i, int j) {
if (a[i][j]) return a[i][j];
cout << "? " << i << ' ' << j << endl;
string s;
cin >> s;
return a[i][j] = a[j][i] = s[0] == '<' ? i : j;
};
set<int> s, t, rem;
for (int i = 1; i <= 2; i++) {
s.insert(i);
}
for (int i = 3; i <= n + 1; i++) {
t.insert(i);
}
for (int i = n + 2; i <= 2 * n; i++) {
rem.insert(i);
}
auto get_lose = [&](set<int>& group) {
int res = *group.begin();
for (int x : group) {
if (x != res) {
res = lose(x, res);
}
}
return res;
};
int cnt = 0;
while (cnt < n) {
int nxt = -1;
if (!rem.empty()) {
nxt = *rem.begin();
rem.erase(nxt);
}
int l0 = get_lose(s);
int l1 = get_lose(t);
if (lose(l0, l1) == l0) {
s.erase(l0);
s.insert(nxt);
} else {
t.erase(l1);
t.insert(nxt);
}
cnt++;
}
cout << '!' << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) solve();
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const double eps = 1e-8;
const double PI = acos(-1.);
const double E = 2.71828182845904523536;
const int MOD = (int)1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x7f7f7f7f;
const int N = 1e5 + 7;
const int M = 2000000 + 5;
inline int popcnt(int x) { return __builtin_popcount(x); }
inline int clz(int x) { return __builtin_clz(x); }
inline int clz(long long x) { return __builtin_clzll(x); }
inline int lg2(int x) { return !x ? -1 : 31 - clz(x); }
inline int lg2(long long x) { return !x ? -1 : 63 - clz(x); }
int n, a[222222], fa[222222], tot = 0, as[222222];
vector<pair<long long, int> > dd;
vector<pair<int, long long> > G[222222];
void dfs(int u, int p, long long d) {
dd.push_back(make_pair(d, u));
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first;
long long w = G[u][i].second;
if (v == p) continue;
dfs(v, u, d + w);
}
int idx = lower_bound(dd.begin(), dd.end(),
make_pair(dd[dd.size() - 1].first - a[u], -1)) -
dd.begin();
as[fa[u]] += 1;
as[fa[dd[idx].second]] -= 1;
as[fa[u]] += as[u];
dd.pop_back();
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 2; i <= n; i++) {
int p, v;
scanf("%d%d", &p, &v);
fa[i] = p;
G[p].push_back(make_pair(i, v));
}
dfs(1, -1, 0);
for (int i = 1; i <= n; i++) printf("%d%c", as[i], i == n ? '\n' : ' ');
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<double, double>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<double>;
using vs = vector<string>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
const int di[4] = {-1, 0, 1, 0}, dj[4] = {0, 1, 0, -1};
const int di8[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
dj8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const ld PI = acos((ld)-1);
const ll INF = 1e18;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) { return uniform_int_distribution<ll>(a, b)(rng); }
bool pow2(int i) { return i && (i & -i) == i; }
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
ll half(ll x) { return fdiv(x, 2); }
bool inc(ll a, ll b, ll c) { return a <= b && b <= c; }
template <class T>
bool chmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool chmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
void remDup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), end(v));
}
template <class T, class U>
void remAll(vector<T>& v, U a) {
v.erase(remove((v).begin(), (v).end(), a), v.end());
}
template <class T, class U>
T fstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi);
f(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi + 1);
f(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p);
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p);
string to_string(char c) { return string(1, c); }
string to_string(bool b) { return to_string((int)b); }
string to_string(const char* s) { return (string)s; }
string to_string(string s) { return s; }
template <class T>
string to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
string to_string(vb v) {
string res = "{";
for (int i = (0); i < (((int)(v).size())); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
string to_string(bitset<SZ> b) {
string res = "";
for (int i = (0); i < (((int)(b).size())); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
string to_string(pair<T, U> p);
template <class T>
string to_string(T v) {
bool fst = 1;
string res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
string to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p));
}
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p)) + " " + to_string(get<3>(p));
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p);
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p);
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& d) {
string t;
re(t);
d = stod(t);
}
void re(ld& d) {
string t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(array<T, SZ>& x) {
for (auto& a : x) re(a);
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p) {
re(get<0>(p), get<1>(p), get<2>(p));
}
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p) {
re(get<0>(p), get<1>(p), get<2>(p), get<3>(p));
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
struct chash {
const uint64_t C = ll(2e18 * PI) + 71;
const int RANDOM = rng();
ll operator()(ll x) const { return __builtin_bswap64((x ^ RANDOM) * C); }
};
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using mpq = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T, class U>
using um = unordered_map<T, U, chash>;
template <class T>
using us = unordered_set<T, chash>;
template <class T>
using PR = pair<T, T>;
const int MOD = 998244353;
template <int MOD, int RT>
struct mint {
static const int mod = MOD;
static constexpr mint rt() { return RT; }
int v;
explicit operator int() const { return v; }
mint() { v = 0; }
mint(ll _v) {
v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
if (v < 0) v += MOD;
}
friend bool operator==(const mint& a, const mint& b) { return a.v == b.v; }
friend bool operator!=(const mint& a, const mint& b) { return !(a == b); }
friend bool operator<(const mint& a, const mint& b) { return a.v < b.v; }
friend void re(mint& a) {
ll x;
re(x);
a = mint(x);
}
friend string to_string(mint a) { return to_string(a.v); }
mint& operator+=(const mint& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this;
}
mint& operator-=(const mint& m) {
if ((v -= m.v) < 0) v += MOD;
return *this;
}
mint& operator*=(const mint& m) {
v = (ll)v * m.v % MOD;
return *this;
}
mint& operator/=(const mint& m) { return (*this) *= inv(m); }
friend mint pow(mint a, ll p) {
mint ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend mint inv(const mint& a) {
assert(a.v != 0);
return pow(a, MOD - 2);
}
mint operator-() const { return mint(-v); }
mint& operator++() { return *this += 1; }
mint& operator--() { return *this -= 1; }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
};
typedef mint<MOD, 5> mi;
vector<vector<mi>> scmb;
void genComb(int SZ) {
scmb.assign(SZ, vector<mi>(SZ));
scmb[0][0] = 1;
for (int i = (1); i < (SZ); ++i)
for (int j = (0); j < (i + 1); ++j)
scmb[i][j] = scmb[i - 1][j] + (j ? scmb[i - 1][j - 1] : 0);
}
vi invs, fac, ifac;
void genFac(int SZ) {
invs.resize(SZ), fac.resize(SZ), ifac.resize(SZ);
invs[1] = fac[0] = ifac[0] = 1;
for (int i = (2); i < (SZ); ++i)
invs[i] = MOD - (ll)MOD / i * invs[MOD % i] % MOD;
for (int i = (1); i < (SZ); ++i) {
fac[i] = (ll)fac[i - 1] * i % MOD;
ifac[i] = (ll)ifac[i - 1] * invs[i] % MOD;
}
}
mi comb(int a, int b) {
if (a < b || b < 0) return 0;
return (ll)fac[a] * ifac[b] % MOD * ifac[a - b] % MOD;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
using ul = unsigned long long;
ul modMul(ul a, ul b, const ul mod) {
ll ret = a * b - mod * (ul)((ld)a * b / mod);
return ret + ((ret < 0) - (ret >= (ll)mod)) * mod;
}
ul modPow(ul a, ul b, const ul mod) {
if (b == 0) return 1;
ul res = modPow(a, b / 2, mod);
res = modMul(res, res, mod);
return b & 1 ? modMul(res, a, mod) : res;
}
bool prime(ul n) {
if (n < 2 || n % 6 % 4 != 1) return n - 2 < 2;
ul A[] = {2, 325, 9375, 28178, 450775, 9780504, 1795265022},
s = __builtin_ctzll(n - 1), d = n >> s;
for (auto& a : A) {
ul p = modPow(a, d, n), i = s;
while (p != 1 && p != n - 1 && a % n && i--) p = modMul(p, p, n);
if (p != n - 1 && i != s) return 0;
}
return 1;
}
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void IOS(int n = 10, string s = "") {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.precision(n);
cerr.precision(n);
cerr << fixed;
cout << fixed;
if (((int)(s).size())) {
setIn(s + ".in"), setOut(s + ".out");
}
}
const int mxN = 3e5 + 5;
void solve(int tt) {
int n;
ll ans = 0;
re(n);
um<int, int> m;
for (int i = (0); i < (n); ++i) {
str s;
re(s);
int x = 0;
for (auto& j : s) x ^= 1 << (j - 'a');
ans += m[x];
for (int j = (0); j < (26); ++j) ans += m[x ^ (1 << j)];
m[x]++;
}
ps(ans);
}
int main() {
IOS();
int t = 1;
for (int i = (0); i < (t); ++i) {
solve(i + 1);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int n;
const int nMax = 3000 + 9;
int A[nMax];
int main() {
read_file();
while (scanf("%d", &n) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", &A[i]), A[i] -= i;
priority_queue<pair<int, long long> > PQ;
PQ.push(make_pair(-(1000000000), 0));
int last = A[0];
long long cost = 1;
long long ans = 0;
for (int i = 1; i < n; i++) {
if (A[i] == last) {
cost++;
} else if (A[i] > last) {
PQ.push(make_pair(last, cost));
last = A[i];
cost = 1;
} else {
while (true) {
if (cost > 1) {
cost--;
ans += last - A[i];
PQ.push(make_pair(A[i], 2));
break;
}
pair<int, long long> top = PQ.top();
int mxH = top.first;
long long delta = top.second;
if (mxH < A[i]) {
ans += (last - A[i]) * cost;
last = A[i];
cost++;
break;
} else {
ans += (last - mxH) * cost;
last = mxH;
cost += delta;
PQ.pop();
while (true) {
pair<int, long long> top = PQ.top();
if (top.first != last) break;
cost += top.second;
PQ.pop();
}
if (last == A[i]) {
cost++;
break;
}
}
}
}
}
printf("%lld\n", ans);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int N, Q, num[200011];
int low[200011], to[200011];
vector<pair<int, int> > adj[200011];
vector<pair<int, pair<int, int> > > edgelist;
class MinSegTree {
private:
long long st[4 * 200011], lazy[4 * 200011];
void push(int w, int L, int R) {
if (!lazy[w])
return;
else if (L != R) {
lazy[w * 2] += lazy[w];
lazy[w * 2 + 1] += lazy[w];
}
if (st[w] < 0) st[w] = 0;
st[w] += lazy[w];
lazy[w] = 0;
}
public:
void init() { memset(st, -1, sizeof(st)); }
void update(int w, int L, int R, int a, int b, long long v) {
push(w, L, R);
if (b < L || a > R)
return;
else if (a <= L && b >= R) {
lazy[w] += v;
push(w, L, R);
} else {
update(w * 2, L, (L + R) / 2, a, b, v);
update(w * 2 + 1, (L + R) / 2 + 1, R, a, b, v);
st[w] = min(st[w * 2], st[w * 2 + 1]);
}
}
long long query(int w, int L, int R, int a, int b) {
push(w, L, R);
if (b < L || a > R || st[w] < 0)
return ((1LL << 60) + 123);
else if (a <= L && b >= R)
return st[w];
else {
long long q1 = query(w * 2, L, (L + R) / 2, a, b);
long long q2 = query(w * 2 + 1, (L + R) / 2 + 1, R, a, b);
return min(q1, q2);
}
}
} minst;
struct BIT {
long long ft[200011];
void update(int x, long long v) {
while (x <= N) {
ft[x] += v;
x += (x & -x);
}
}
long long query(int x) { return x > 0 ? ft[x] + query(x - (x & -x)) : 0; }
} sum;
void dfs(int x, int p) {
static int cnt = 0;
num[x] = low[x] = (++cnt);
for (int i = 0; i < (int)adj[x].size(); i++) {
int w = adj[x][i].first;
int n = adj[x][i].second;
if (n != p) {
dfs(n, x);
sum.update(num[n], w);
sum.update(low[n] + 1, -w);
}
}
low[x] = cnt;
}
int main() {
if (fopen("data.in", "r")) freopen("data.in", "r", stdin);
scanf("%d", &N);
scanf("%d", &Q);
for (int i = 1; i < N; i++) {
int a, b, w;
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &w);
adj[a].push_back(make_pair(w, b));
edgelist.push_back(make_pair(w, make_pair(a, b)));
}
for (int i = 2; i <= N; i++) {
int a, b, w;
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &w);
to[a] = w;
edgelist.push_back(make_pair(w, make_pair(a, b)));
}
dfs(1, 1);
for (int i = 1; i <= N; i++)
minst.update(1, 1, N, num[i], num[i], to[i] + sum.query(num[i]));
for (int i = 0; i < Q; i++) {
int a, b, t;
scanf("%d", &t);
scanf("%d", &a);
scanf("%d", &b);
if (t == 1) {
int prev = edgelist[a - 1].first;
edgelist[a - 1].first = b;
if (a > N - 1) {
int c = edgelist[a - 1].second.first;
minst.update(1, 1, N, num[c], num[c],
-minst.query(1, 1, N, num[c], num[c]));
minst.update(1, 1, N, num[c], num[c], sum.query(num[c]) + b);
} else {
int c = edgelist[a - 1].second.second;
sum.update(num[c], -prev + b);
sum.update(low[c] + 1, prev - b);
minst.update(1, 1, N, num[c], low[c], -prev + b);
}
} else {
if (num[b] <= low[a] && num[b] >= num[a]) {
printf("%I64d\n", sum.query(num[b]) - sum.query(num[a]));
} else {
long long toRoot =
minst.query(1, 1, N, num[a], low[a]) - sum.query(num[a]);
printf("%I64d\n", toRoot + sum.query(num[b]));
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, p;
cin >> n;
vector<long> v;
for (long i = 0; i < n; i++) {
cin >> p;
v.push_back(p);
}
sort(v.begin(), v.end());
long long sum = 0;
for (long i = 0; i < ceil(n / 2); i++) {
sum = sum + pow(v[i] + v[n - i - 1], 2);
}
cout << sum;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, count = 0, max = 0;
char *str;
cin >> n;
str = new char[n];
scanf("%c", &str[0]);
for (int i = 0; i < n; i++) {
scanf("%c", &str[i]);
if (str[i] == ' ') {
if (count > max) {
max = count;
count = 0;
}
count = 0;
} else if (isupper(str[i])) {
count++;
if (count > max) {
max = count;
}
}
}
cout << max;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long powi(long long base, int p) {
long long res = 1;
while (p--) res *= base;
return res;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
bool is_vowel(char c) {
c = tolower(c);
return c == 'a' || c == 'e' || c == 'o' || c == 'i' || c == 'u' || c == 'y';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> a(4 * n);
for (int i = 0; i < 4 * n; i++) cin >> a[i];
sort(a.begin(), a.end());
int s = -1;
bool res = true;
for (int i = 0; i < n; i++) {
int l1, l2, l3, l4;
l1 = a[i * 2];
l2 = a[i * 2 + 1];
l3 = a[4 * n - i * 2 - 1];
l4 = a[4 * n - i * 2 - 2];
if (s == -1) {
if (l1 == l2 && l3 == l4)
s = l1 * l3;
else {
res = false;
break;
}
} else if (l1 != l2 || l3 != l4 || l1 * l3 != s) {
res = false;
break;
}
}
cout << (res ? "YES\n" : "NO\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
constexpr long long int mod = 1e9 + 7;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
vector<long long int> a(6);
for (int i = 0; i < 6; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int n;
cin >> n;
vector<long long int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
n = v.size();
if (n == 1) {
printf("0\n");
return 0;
}
long long int res = v.back() - v[0];
vector<pair<long long int, long long int>> vv;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 6; j++) {
vv.push_back({v[i] - a[j], i});
}
}
sort(vv.begin(), vv.end());
vector<int> cnt(n, 0);
int r = 0;
for (int l = 0; l < vv.size(); l++) {
if (l == 0) {
set<int> st;
while (st.size() < n and r < vv.size()) {
cnt[vv[r].second]++;
st.insert(vv[r].second);
r++;
}
res = min(res, vv[r - 1].first - vv[l].first);
} else {
int id = vv[l - 1].second;
cnt[id]--;
if (cnt[id] > 0) {
res = min(res, vv[r - 1].first - vv[l].first);
} else {
while (r < vv.size() and cnt[id] == 0) {
cnt[vv[r].second]++;
r++;
}
if (cnt[id] == 0) break;
res = min(res, vv[r - 1].first - vv[l].first);
}
}
}
cout << res << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
while (cin >> n >> k) {
if (n <= k) {
cout << 1 << endl;
cout << n << endl;
continue;
}
int mi = k + 1;
int ma = k * 2 + 1;
int cnt = n / ma;
int sy = n % ma;
vector<int> res;
if (sy < mi && sy != 0) {
cnt--;
int mix = sy + ma;
int x = mix - mi;
x -= k;
x--;
res.push_back(1);
res.push_back(n - x);
int ins = 1 + 2 * k + 1;
for (int i = 1; i <= cnt; i++) {
res.push_back(ins);
ins += (2 * k + 1);
}
} else if (sy >= mi) {
int x = sy - k;
x--;
int ins = 1 + x;
res.push_back(ins);
ins += (2 * k + 1);
for (int i = 1; i <= cnt; i++) {
res.push_back(ins);
ins += (2 * k + 1);
}
} else if (sy == 0) {
int ins = k + 1;
for (int i = 1; i <= cnt; i++) {
res.push_back(ins);
ins += (2 * k + 1);
}
}
cout << res.size() << endl;
for (int i = 0; i < (int)res.size(); i++) {
cout << res[i] << ' ';
}
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
if (n.size() > 1 &&
((n[n.size() - 2] - '0') * 10 + (n[n.size() - 1] - '0')) % 4 == 0 ||
(n.size() == 1 && (n[n.size() - 1] - '0') % 4 == 0))
cout << 4;
else
cout << 0;
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
mt19937_64 rnd;
const int N = 2e5 + 5;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
map<int, int> mp;
set<pair<int, int> > recent;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (mp.find(x) == mp.end()) {
mp[x] = 1;
if (int(recent.size()) == k) {
mp.erase(recent.begin()->second);
recent.erase(recent.begin());
}
recent.insert(make_pair(i, x));
};
}
cout << int(recent.size()) << '\n';
for (auto x = recent.rbegin(); x != recent.rend(); x++) {
cout << x->second << ' ';
}
cout << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
double fRand(double fMin, double fMax) {
double f = (double)rand() / RAND_MAX;
return fMin + f * (fMax - fMin);
}
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
int n, a[100005], d[100005], S;
vector<int> c[2], g[100005];
void DFS(int u) {
if ((int)g[u].size() == 0)
d[u] = 1;
else {
for (__typeof(g[u].begin()) it = g[u].begin(); it != g[u].end(); it++) {
int v = *it;
DFS(v);
d[u] = (d[v] + 1) % 2;
}
}
c[d[u]].push_back(a[u]);
if (d[u] == 1) S ^= a[u];
}
long long Tri(long long x) { return x * (x - 1) / 2; }
int Count(const vector<int> &v, const int &x) {
return upper_bound(v.begin(), v.end(), x) -
lower_bound(v.begin(), v.end(), x);
}
int main() {
scanf("%d", &n);
for (int u = (1); u <= (n); ++u) scanf("%d", &a[u]);
for (int u = (2); u <= (n); ++u) {
int p;
scanf("%d", &p);
g[p].push_back(u);
}
DFS(1);
for (int i = (0); i <= ((int)c[0].size() - 1); ++i) c[0][i] ^= S;
sort(c[0].begin(), c[0].end());
long long ans = 0;
for (__typeof(c[1].begin()) it = c[1].begin(); it != c[1].end(); it++)
ans += Count(c[0], *it);
if (S == 0) ans += Tri((int)c[0].size()) + Tri((int)c[1].size());
printf("%lld", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int inf = 0x3f3f3f3f;
string s[maxn];
int dp[maxn][10];
int cnt[maxn][10];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, x, y;
cin >> n >> m >> x >> y;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m - 1; j++) {
if (s[i][j] == '#')
cnt[j + 1][0]++;
else if (s[i][j] == '.')
cnt[j + 1][1]++;
}
}
for (int i = 2; i <= m; i++) {
cnt[i][0] += cnt[i - 1][0];
cnt[i][1] += cnt[i - 1][1];
}
memset(dp, inf, sizeof(dp));
dp[0][0] = dp[0][1] = 0;
for (int i = 1; i <= m; i++) {
for (int j = x; j <= min(y, i); j++) {
dp[i][0] = min(dp[i - j][1] + (cnt[i][0] - cnt[i - j][0]), dp[i][0]);
dp[i][1] = min(dp[i - j][0] + (cnt[i][1] - cnt[i - j][1]), dp[i][1]);
}
}
cout << min(dp[m][0], dp[m][1]) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int work() {
int n, x, y, myc;
cin >> n >> x >> y;
set<int> nm;
for (int i = 0; i <= n; ++i) nm.emplace(i);
vector<int> ar(n);
for (auto &i : ar) cin >> i, i--;
vector<vector<int>> col(n + 1);
for (int i = 0; i < n; ++i) col[ar[i]].emplace_back(i), nm.erase(ar[i]);
myc = *nm.begin();
vector<int> ans(n, -1);
set<pair<int, int>, greater<pair<int, int>>> findb;
vector<bool> sovp(n, false);
for (int i = 0; i <= n; ++i) {
findb.emplace((int)col[i].size(), i);
}
for (int i = 0; i < x; ++i) {
auto it = findb.begin();
pair<int, int> p = *it;
findb.erase(it);
int ind = col[p.second].back();
col[p.second].pop_back();
ans[ind] = ar[ind];
sovp[ind] = true;
findb.emplace(p.first - 1, p.second);
}
vector<int> swp(n - x);
int cyc = (n - x) / 2;
int cnt = 0;
for (auto &list : col) {
for (auto &val : list) {
swp[(cnt + cyc) % (n - x)] = val;
cnt++;
}
}
assert(cnt == n - x);
cnt = 0;
int cntcol = 0;
for (auto &list : col) {
for (auto &val : list) {
ans[swp[cnt]] = cntcol;
cnt++;
}
cntcol++;
}
int k = n - y;
for (int i = 0; i < n; ++i) {
if (ans[i] == ar[i] && !sovp[i]) {
if (k == 0) return cout << "NO" << endl, 0;
k--;
ans[i] = myc;
}
}
for (int i = 0; i < n && k > 0; ++i) {
if (ans[i] != ar[i] && ans[i] != myc) ans[i] = myc, k--;
}
if (k != 0) return cout << "NO" << endl, 0;
cout << "YES" << endl;
for (auto i : ans) cout << i + 1 << ' ';
cout << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t;
cin >> t;
while (t--) {
work();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
inline pair<pair<int, int>, pair<int, int> > make(int x, int y, int g, int s) {
return pair<pair<int, int>, pair<int, int> >(pair<int, int>(g, s),
pair<int, int>(x, y));
}
int n, m;
int G, S;
pair<pair<int, int>, pair<int, int> > r[1 << 17];
inline void init() {
int x, y, g, s;
scanf("%d%d", &n, &m);
scanf("%d%d", &G, &S);
int tm = 0;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d%d", &x, &y, &g, &s);
if (x == y) continue;
--x;
--y;
r[tm++] = make(x, y, g, s);
}
m = tm;
sort(r, r + m);
}
int CNT;
pair<int, int> p[201];
vector<vector<pair<int, int> > > a;
int was[201];
int MX;
void dfs(int x) {
was[x] = 1;
++CNT;
int k = (int)a[x].size();
for (int i = 0; i < k; ++i) {
int y = a[x][i].first;
int w = a[x][i].second;
if (was[y]) continue;
MX = max(MX, w);
p[y] = pair<int, int>(x, w);
dfs(y);
}
}
inline void remove(int x, int y) {
int k = (int)a[x].size();
for (int i = 0; i < k; ++i) {
if (a[x][i].first != y) continue;
swap(a[x][i], a[x][k - 1]);
a[x].pop_back();
break;
}
}
int main() {
init();
long long res = -1;
a.resize(n);
for (int i = 0; i < m; ++i) {
int x = r[i].second.first;
int y = r[i].second.second;
int g = r[i].first.first;
int s = r[i].first.second;
memset(was, 0, sizeof was);
dfs(x);
if (!was[y]) {
a[x].push_back(pair<int, int>(y, s));
a[y].push_back(pair<int, int>(x, s));
} else {
int from, to, w;
int z = y;
from = p[z].first;
to = z;
w = p[z].second;
while (z != x) {
if (p[z].second > w) {
from = p[z].first;
to = z;
w = p[z].second;
}
z = p[z].first;
}
if (s > w) continue;
a[x].push_back(pair<int, int>(y, s));
a[y].push_back(pair<int, int>(x, s));
remove(from, to);
remove(to, from);
}
memset(was, 0, sizeof was);
CNT = 0;
MX = 0;
dfs(x);
if (CNT != n) continue;
long long cur = (long long)MX * (long long)S + (long long)G * (long long)g;
if (res == -1) res = cur;
res = min(res, cur);
}
printf("%lld\n", res);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int getMax(long long int n) {
string s = "";
while (n > 0) {
s += to_string(n % 10);
n = n / 10;
}
long long int maxN = 0;
for (char c : s) {
maxN = max(maxN, (long long int)(c - '0'));
}
return maxN;
}
long long int getMin(long long int n) {
string s = "";
while (n > 0) {
s += to_string(n % 10);
n = n / 10;
}
long long int minN = 9;
for (char c : s) {
minN = min(minN, (long long int)(c - '0'));
}
return minN;
}
void solve() {
long long int a, k;
cin >> a >> k;
long long int ans = a;
for (long long int i = 0; i < k - 1; i++) {
long long int mn = getMin(ans);
long long int mx = getMax(ans);
if (mn == 0) {
break;
}
ans = ans + mn * mx;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int num[1000005], l[1000005];
long long ans, limit = 1;
string s[1000005];
void init() {
for (int i = 1; i <= 32; i++) limit *= 2;
limit--;
}
int main() {
init();
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> s[i];
if (s[i] == "for") cin >> num[i];
}
long long now = 1;
int tail = 0, yichu = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == "for") {
if (now <= limit) {
now *= num[i];
l[++tail] = num[i];
} else
yichu++;
}
if (s[i] == "add") {
ans += now;
if (ans > limit) break;
}
if (s[i] == "end") {
if (!yichu)
now /= l[tail--];
else
yichu--;
}
}
if (ans > limit)
printf("OVERFLOW!!!");
else
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
int n, k;
char ch[N], m;
bool ok[N][N];
queue<pair<int, int> > q;
int main() {
int i, j, l, o, t;
scanf("%s", ch + 1);
ch[0] = '_';
n = strlen(ch) - 1;
i = 2;
while (i <= n) {
k++;
i <<= 1;
}
l = n - (1 << k) + 1;
ok[0][0] = 1;
for (o = 0; o < l; o = o + 1) {
m = 'z' + 1;
for (i = o; i + (l - o) <= n; i = i + 1) {
j = i - o;
if (ok[i][j]) {
m = min(m, ch[i + 1]);
for (t = 0; t < k; t = t + 1) {
if (j & (1 << t)) continue;
ok[i + (1 << t)][j | (1 << t)] = 1;
}
}
}
cout << m;
for (i = o; i + (l - o) <= n; i = i + 1) {
j = i - o;
if (ok[i][j]) {
if (ch[i + 1] == m) ok[i + 1][j] = 1;
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, b;
scanf("%d%d", &r, &b);
if (r == b)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string a, b;
cin >> a >> b;
int answer = 0;
for (int i = 0; i + b.size() <= a.size();) {
if (string(a.begin() + i, a.begin() + i + b.size()) == b) {
i += b.size();
++answer;
} else
++i;
}
cout << answer << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int min(int a, int b) {
if (a > b)
return b;
else
return a;
}
int min3(int a, int b, int c) { return min(min(a, b), c); }
int main() {
int n, k, l, c, d, p, nl, np;
scanf("%d%d%d%d%d%d%d%d", &n, &k, &l, &c, &d, &p, &nl, &np);
int total = min3((k * l) / nl, c * d, p / np);
int each = total / n;
printf("%d", each);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int hell = 1000000007;
const long long int maxn = 5e3 + 5;
long long int g[maxn][maxn];
bool vis[maxn];
long long int n;
void dfs(long long int v, long long int p) {
vis[v] = 1;
for (long long int i = 1; i <= n; i++) {
if (!g[v][i]) continue;
if (g[i][p]) {
cout << p << ' ' << v << ' ' << i;
exit(0);
}
if (!vis[i]) dfs(i, v);
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= n; j++) {
char x;
cin >> x;
g[i][j] = x - '0';
}
}
for (long long int i = 1; i <= n; i++) {
dfs(i, 0);
}
cout << -1;
cerr << "Time elapsed : " << clock() * 1000.0 / CLOCKS_PER_SEC << "ms"
<< '\n';
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:336777216")
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using ui = unsigned int;
ll const mod = 1000000007;
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
set<int> v;
for (int d1 = 0; d1 <= 9; d1++) {
for (int d2 = d1; d2 <= 9; d2++) {
for (int len = 1; len <= 10; len++) {
for (int i = 0; i < (1 << len); i++) {
int num = 0;
for (int j = 0; j < len; j++) {
if (i & (1 << j))
num += d1 * pow(10, j);
else
num += d2 * pow(10, j);
}
v.insert(num);
}
}
}
}
v.erase(v.begin());
v.erase(0);
int ans = 0;
int n;
cin >> n;
for (auto& x : v) {
if (x <= n)
ans++;
else
break;
}
cout << ans << '\n';
return 0;
}
| 4 |
#include "bits/stdc++.h"
using namespace std;
signed main() {
ios_base :: sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while(t--) {
int n, k;
cin >> n >> k;
vector<long long> a(n);
for(auto& x : a) cin >> x;
long long s = 0, ans = 0;
for(int i = 1; i < n; ++i) {
s += a[i - 1];
if(100 * a[i] > k * s) {
auto x = (100 * a[i] + k - 1) / k;
ans += x - s;
s = x;
}
}
cout << ans << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100500, INF = 1000 * 1000 * 1000;
const long double eps = 1e-9;
int n, m, s;
int a[N];
int b[N];
int c[N];
int pa[N], pb[N];
bool cmpa(int ia, int ib) { return a[ia] > a[ib]; }
bool cmpb(int ia, int ib) { return b[ia] > b[ib]; }
int ans[N];
bool ok(int st, bool ANS = false) {
set<pair<int, int> > k;
int curs = s;
for (int i = 0, j = 0; i < m; i += st) {
int up = a[pa[i]];
for (; j < n; j++) {
int cur = b[pb[j]];
if (cur < up) {
break;
}
k.insert(make_pair(c[pb[j]], j));
}
if (k.empty() || k.begin()->first > curs) {
return false;
}
if (ANS) {
for (int t = i; t < m && t < i + st; t++)
ans[pa[t]] = pb[k.begin()->second];
}
curs -= k.begin()->first;
k.erase(k.begin());
}
return true;
}
bool solve() {
if (scanf("%d%d%d", &n, &m, &s) != 3) return false;
for (int i = 0; i < m; ++i) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
for (int i = 0; i < n; ++i) scanf("%d", &c[i]);
for (int i = 0; i < m; ++i) pa[i] = i;
for (int i = 0; i < n; ++i) pb[i] = i;
sort(pa, pa + m, cmpa);
sort(pb, pb + n, cmpb);
int l = 1;
int r = m;
while (l != r) {
int mid = (l + r) >> 1;
if (ok(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
int yes = ok(l, true);
puts(yes ? "YES" : "NO");
if (yes) {
for (int i = 0; i < m; ++i) {
printf("%d ", ans[i] + 1);
}
}
return true;
}
int main() {
while (solve()) puts("");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, dp[320000];
map<int, int> a, b;
vector<int> s;
void solve() {
s.clear();
int ans = 1e8;
a.clear();
b.clear();
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (!a.count(x)) {
a[x] = i;
}
b[x] = i;
}
int pre = -1;
for (auto& x : a) {
s.push_back(x.first);
}
for (int i = s.size() - 1; i >= 0; i--) {
if (i + 1 == s.size() || b[s[i]] >= a[s[i + 1]]) {
dp[i] = 1;
} else {
dp[i] = dp[i + 1] + 1;
}
ans = min(ans, (int)s.size() - dp[i]);
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void input(int n, int a[]) {
for (int i = 0; i < n; ++i) cin >> a[i];
}
long long bin_expo(long long A, long long B, long long M) {
long long res = 1LL;
while (B > 0) {
if (B % 2 == 1) {
res = (res * A) % M;
}
A = (A * A) % M;
B = B / 2;
}
return res;
}
long long ql = 0, qr = 0, qd = 0, qu = 0;
int n;
int lle[100000 + 5] = {0}, rre[100000 + 5] = {0}, up[100000 + 5] = {0},
down[100000 + 5] = {0}, l = 0, r = 0, u = 0, d = 0;
int find(long long days) {
long long turn = days / n;
long long le = days % n;
long long cl = turn * l + lle[le - 1], cr = turn * r + rre[le - 1],
cu = turn * u + up[le - 1], cd = turn * d + down[le - 1];
if (cl >= cr) {
cl -= cr;
cr = 0;
} else {
cr -= cl;
cl = 0;
}
if (cu >= cd) {
cu -= cd;
cd = 0;
} else {
cd -= cu;
cu = 0;
}
cl = abs(ql - cl);
cr = abs(qr - cr);
cd = abs(qd - cd);
cu = abs(qu - cu);
if (cl + cr + cd + cu > days) return 0;
return 1;
}
int main() {
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'U') {
u++;
up[i]++;
}
if (s[i] == 'D') {
d++;
down[i]++;
}
if (s[i] == 'L') {
l++;
lle[i]++;
}
if (s[i] == 'R') {
r++;
rre[i]++;
}
if (i != 0) {
up[i] += up[i - 1];
down[i] += down[i - 1];
lle[i] += lle[i - 1];
rre[i] += rre[i - 1];
}
}
if (x2 > x1) {
qr = x2 - x1;
} else {
ql = x1 - x2;
}
if (y2 > y1) {
qu = y2 - y1;
} else {
qd = y1 - y2;
}
long long start = 0, end = 1000000000000000, mid = (start + end) / 2;
while (start <= end) {
int x = find(mid), y = find(mid + 1);
if (x == 0 && y == 1) break;
if (x == 1) end = mid;
if (y == 0) start = mid + 1;
mid = (start + end) / 2;
}
if (mid >= 1000000000000000)
cout << -1;
else
cout << mid + 1 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0};
int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0};
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
template <typename T>
inline bool isLeap(T y) {
return (y % 400 == 0) || (y % 100 ? y % 4 == 0 : false);
}
template <typename T>
inline T GCD(T a, T b) {
a = abs(a);
b = abs(b);
if (a < b) swap(a, b);
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
template <typename T>
inline T EGCD(T a, T b, T &x, T &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
T x1, y1;
T d = EGCD(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
template <typename T>
inline T LCM(T x, T y) {
T tp = GCD(x, y);
if ((x / tp) * 1. * y > 9e18) return 9e18;
return (x / tp) * y;
}
template <typename T>
inline T BigMod(T A, T B, T M = MOD) {
T ret = 1;
while (B) {
if (B & 1) ret = (ret * A) % M;
A = (A * A) % M;
B = B >> 1;
}
return ret;
}
template <typename T>
inline T InvMod(T A, T M = MOD) {
return BigMod(A, M - 2, M);
}
template <typename T>
T scani(T &n) {
n = 0;
bool negative = false;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') negative = true;
c = getchar();
}
while (c >= '0' && c <= '9') {
n = n * 10 + c - 48;
c = getchar();
}
if (negative) n = ~(n - 1);
return n;
}
template <typename T>
void write(T n, int type = true) {
if (n < 0) {
putchar('-');
n = -n;
}
if (!n) {
putchar('0');
if (type == 32)
putchar(' ');
else if (type)
putchar('\n');
return;
}
char buff[22];
int len = 0;
while (n) buff[len++] = n % 10 + 48, n /= 10;
for (int i = len - 1; i >= 0; i--) putchar(buff[i]);
if (type == 32)
putchar(' ');
else if (type)
putchar('\n');
}
int scans(char *a) {
int i = 0;
char c = 0;
while (c < 33) c = getchar();
while (c > 33) {
a[i++] = c;
c = getchar();
}
a[i] = 0;
return i;
}
template <typename T>
inline T SqrDis(T x1, T y1, T x2, T y2) {
return ((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2));
}
template <typename T>
inline T Area2(T Ax, T Ay, T Bx, T By, T Cx, T Cy) {
T ret = Ax * (By - Cy) + Bx * (Cy - Ay) + Cx * (Ay - By);
if (ret < 0) return ret = -ret;
return ret;
}
const int N = 2000006;
const int M = 44444;
const unsigned long long hs = 3797;
int a[N], b[N], na, nb, p;
int dp[2222][2222];
int main() {
scani(na), scani(nb), scani(p);
for (int i = (1); i < (na + 1); ++i) scani(a[i]);
for (int i = (1); i < (nb + 1); ++i) scani(b[i]);
sort(a + 1, a + 1 + na);
sort(b + 1, b + 1 + nb);
for (int i = (1); i < (na + 1); ++i)
for (int j = (0); j < (nb + 1); ++j) dp[i][j] = 0x3f3f3f3f * 2;
for (int i = (1); i < (na + 1); ++i)
for (int j = (1); j < (nb + 1); ++j) {
dp[i][j] = dp[i][j - 1];
dp[i][j] = min(dp[i][j],
max(dp[i - 1][j - 1], abs(a[i] - b[j]) + abs(b[j] - p)));
}
write(dp[na][nb]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long mod = 1e9 + 7;
const long long linf = 1LL << 62;
const double EPS = 1e-7;
template <class T>
void chmin(T& x, T y) {
if (x > y) x = y;
}
template <class T>
void chmax(T& x, T y) {
if (x < y) x = y;
}
int n, m, k;
vector<pair<long long, long long> > g[4];
int solve(int mode, int pos) {
if (pos == -1) {
cout << -1 << endl;
return 0;
}
int mx = min((int)g[0].size(), m);
int ones = max(k - mx, 0);
if (ones > min(g[1].size(), g[2].size()) || mx + ones * 2 > m) {
return -1;
}
long long sum = 0;
for (int i = 0; i < mx; i++) sum += g[0][i].first;
set<pair<int, int> > fr, mn;
for (int i = 0; i < ones; i++) sum += g[1][i].first + g[2][i].first;
for (int i = ones; i < g[1].size(); i++) fr.insert(g[1][i]);
for (int i = ones; i < g[2].size(); i++) fr.insert(g[2][i]);
for (auto u : g[3]) fr.insert(u);
for (int i = 0; i < m - (ones * 2 + mx); i++) {
sum += fr.begin()->first;
mn.insert(*fr.begin());
fr.erase(fr.begin());
}
long long res = mx, val = sum;
for (int sz11 = mx - 1; sz11 >= 0; sz11--) {
if (mode == 1 && pos > sz11) break;
if (fr.empty()) break;
sum -= g[0][sz11].first;
sum += fr.begin()->first;
mn.insert(*fr.begin());
fr.erase(fr.begin());
if (sz11 < k) {
if (ones < g[1].size() && ones < g[2].size()) {
if (mn.size() < 2) break;
auto f = [&](int num) {
if (mn.find(g[num][ones]) != mn.end()) {
mn.erase(g[num][ones]);
} else {
sum += g[num][ones].first;
auto it = mn.end();
it--;
sum -= it->first;
mn.erase(it);
}
};
f(1), f(2);
ones++;
} else {
break;
}
}
if (val > sum) {
res = sz11;
val = sum;
}
}
if (mode == 1) {
cout << val << endl;
for (int i = 0; i < pos; i++) cout << g[0][i].second << " ";
for (int i = 0; i < ones; i++) cout << g[1][i].second << " ";
for (int i = 0; i < ones; i++) cout << g[2][i].second << " ";
for (auto u : mn) cout << u.second << " ";
cout << endl;
}
return res;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
int t, a, b;
cin >> t >> a >> b;
if (a == 1 && b == 1)
g[0].push_back({t, i});
else if (a == 1)
g[1].push_back({t, i});
else if (b == 1)
g[2].push_back({t, i});
else
g[3].push_back({t, i});
}
for (int i = 0; i < 4; i++) sort(g[i].begin(), g[i].end());
solve(1, solve(0, 0));
}
| 4 |
#include <bits/stdc++.h>
long long n, k;
int l;
int m;
long long pow(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long ret = pow(a, b / 2);
ret = ret * ret % m;
if (b & 1) ret = ret * a % m;
return ret;
}
long long modgood(long long x) { return ((x % m) + 2 * m) % m; }
struct mat {
int a, b;
int c, d;
mat(int p, int q, int r, int s) {
a = p % m;
b = q % m;
c = r % m;
d = s % m;
}
mat operator*(const mat& other) {
return mat((1LL * a * other.a % m + 1LL * b * other.c % m) % m,
(1LL * a * other.b % m + 1LL * b * other.d % m) % m,
(1LL * c * other.a % m + 1LL * d * other.c % m) % m,
(1LL * c * other.b % m + 1LL * d * other.d % m) % m);
}
};
mat pow(mat a, long long b) {
if (b == 0) return mat(1, 0, 0, 1);
if (b == 1) return a;
mat ret = pow(a, b / 2);
ret = ret * ret;
if (b & 1) ret = ret * a;
return ret;
}
long long getFibo(long long th) {
mat base(0, 1, 0, 0);
mat trans(0, 1, 1, 1);
return (base * pow(trans, th + 2)).a;
}
int main() {
scanf("%I64d%I64d%d%d", &n, &k, &l, &m);
if (l == 0) {
if (k || m == 1)
puts("0");
else
puts("1");
return 0;
}
if (l != 64 && ((unsigned long long)k) >= (1uLL << l)) {
puts("0");
return 0;
}
int i;
long long ans = 1 % m;
for (i = 0; i < l; ++i) {
if (k & (1LL << i)) {
ans = modgood(ans * modgood(pow(2, n) - getFibo(n)));
} else {
ans = modgood(ans * getFibo(n));
}
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10005;
int n;
int Read() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x * 10) + (c ^ 48);
c = getchar();
}
return x * f;
}
void Put1(int x) {
if (x > 9) Put1(x / 10);
putchar(x % 10 ^ 48);
}
void Put(int x, char c = -1) {
if (x < 0) putchar('-'), x = -x;
Put1(x);
if (c >= 0) putchar(c);
}
template <typename T>
T Max(T x, T y) {
return x > y ? x : y;
}
template <typename T>
T Min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T Abs(T x) {
return x < 0 ? -x : x;
}
int fan(int x) {
if (x > n / 2)
return x - n / 2;
else
return x + n / 2;
}
int ask(int x) {
printf("? %d\n", x);
fflush(stdout);
return Read();
}
int t(int x) { return ask(x) - ask(fan(x)); }
int main() {
n = Read();
if (n % 4) {
printf("! -1\n");
fflush(stdout);
return 0;
}
int l = 1, r = 1 + n / 2, L = t(l), R = t(r);
if (!L) {
printf("! 1\n");
fflush(stdout);
return 0;
}
while (l < r) {
int mid = (l + r) >> 1;
int MID = t(mid);
if (!MID) {
printf("! %d\n", mid);
return 0;
}
if (MID * L > 0)
l = mid, L = MID;
else
r = mid, R = MID;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
if (a.length() != b.length()) {
cout << "No";
return 0;
}
for (int i = 0; i < a.length(); i++) {
if (a[i] == 'a' || a[i] == 'e' || a[i] == 'i' || a[i] == 'o' ||
a[i] == 'u') {
if (b[i] == 'a' || b[i] == 'e' || b[i] == 'i' || b[i] == 'o' ||
b[i] == 'u')
continue;
cout << "No";
return 0;
}
if (b[i] == 'a' || b[i] == 'e' || b[i] == 'i' || b[i] == 'o' ||
b[i] == 'u') {
cout << "No";
return 0;
}
}
cout << "Yes";
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:50000000")
using namespace std;
long long n, m, k;
long long A[10000];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) cin >> A[i];
if (n % 2 == 0) {
cout << 0 << endl;
return 0;
}
long long res = 0, c, o;
c = A[0];
for (int i = 0; i < n; ++i)
if (i % 2 == 0 && (n - i - 1) % 2 == 0) c = min(c, A[i]);
o = ((n - 1) / 2) + 1;
long long can = m / o;
res = min(c, can * k);
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1000000], f[1000000];
int k(int w) {
if (f[w] != w) f[w] = k(f[w]);
return f[w];
}
int main() {
int q, w, r, t, ans = 0;
long long c, v, e, pw;
cin >> q >> c;
if (c == 0) ans = q - 1;
for (w = 0; w < q; w++) {
a[w] = -1;
f[w] = w;
}
for (w = 0; w < q; w++) {
v = 1;
if (a[w] >= 0) continue;
a[w] = 1;
pw = 1;
for (e = (w * c) % q;; e = (e * c) % q) {
pw = (pw * c) % q;
if (a[e] < 0) {
a[e] = pw;
f[e] = w;
continue;
}
if (k(e) == k(w)) {
if (pw == a[e]) ans++;
break;
}
f[k(w)] = k(e);
break;
}
}
v = 1;
for (w = 0; w < ans; w++) v = (v * q) % 1000000007;
cout << v;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <int MOD_>
struct modnum {
static constexpr int MOD = MOD_;
static_assert(MOD_ > 0, "MOD must be positive");
private:
using ll = long long;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0) v += MOD;
}
explicit operator int() const { return v; }
friend std::ostream& operator<<(std::ostream& out, const modnum& n) {
return out << int(n);
}
friend std::istream& operator>>(std::istream& in, modnum& n) {
ll v_;
in >> v_;
n = modnum(v_);
return in;
}
friend bool operator==(const modnum& a, const modnum& b) {
return a.v == b.v;
}
friend bool operator!=(const modnum& a, const modnum& b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return modnum(*this); }
modnum& operator++() {
v++;
if (v == MOD) v = 0;
return *this;
}
modnum& operator--() {
if (v == 0) v = MOD;
v--;
return *this;
}
modnum& operator+=(const modnum& o) {
v += o.v;
if (v >= MOD) v -= MOD;
return *this;
}
modnum& operator-=(const modnum& o) {
v -= o.v;
if (v < 0) v += MOD;
return *this;
}
modnum& operator*=(const modnum& o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum& operator/=(const modnum& o) { return *this *= o.inv(); }
friend modnum operator++(modnum& a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum& a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum& a, const modnum& b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum& a, const modnum& b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum& a, const modnum& b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum& a, const modnum& b) {
return modnum(a) /= b;
}
};
using num = modnum<998244353>;
const int MAXN = 3e5;
int N;
int P[MAXN];
vector<int> ch[MAXN];
num dp[MAXN][2];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> N;
P[1] = 0;
for (int i = 2; i <= N; i++) {
cin >> P[i];
}
for (int i = 1; i <= N; i++) {
ch[P[i]].push_back(i);
}
for (int i = N; i >= 1; i--) {
if (ch[i].empty()) {
dp[i][0] = dp[i][1] = num(1);
} else {
num tot = 1;
for (int j : ch[i]) {
tot *= dp[j][0] + dp[j][1];
}
int numZero = 0;
num useNone = 1;
for (int j : ch[i]) {
if (dp[j][0] == 0) {
numZero++;
} else {
useNone *= dp[j][0];
}
}
dp[i][1] = tot - useNone * (numZero ? num(0) : num(1));
num useOne = 0;
for (int j : ch[i]) {
if (dp[j][0] == 0) {
useOne += dp[j][1] * ((numZero - 1) ? num(0) : num(1)) * useNone;
} else {
useOne +=
dp[j][1] * (numZero ? num(0) : num(1)) * (useNone / dp[j][0]);
}
}
dp[i][0] = tot - useOne;
}
}
cout << dp[1][0] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int m, n, p, now, ans, x, y, t;
int f[N], g[N];
void up(int k, int w, int x, int y) {
int t;
if ((t = w + (y - x) / p) > f[k])
f[k] = t, g[k] = x + (y - x) / p * p;
else if (t == f[k])
g[k] = min(g[k], x + (y - x) / p * p);
}
int main() {
scanf("%d%d%d%d", &m, &n, &p, &t);
g[0] = -t;
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &x, &y);
if (now) now--;
for (; now < i && g[now] + t <= y; ++now)
if (g[now] + t <= x)
up(i, f[now], x, y);
else
up(i, f[now], g[now] + t, y);
ans = max(ans, f[i]);
if (f[i - 1] > f[i])
f[i] = f[i - 1], g[i] = g[i - 1];
else if (f[i - 1] == f[i])
g[i] = min(g[i], g[i - 1]);
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(false);
long long n, i;
cin >> n;
long long arr[n];
long long flag = 0;
for (i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] == 1) {
flag = 1;
}
}
if (flag == 0) {
cout << "1" << endl;
} else {
long long ans;
cout << "-1" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50000;
int n, m, p, k;
int x[MAXN], y[MAXN];
pair<int, int> a[MAXN];
long long f[MAXN];
int t;
pair<pair<int, int>, int> g[MAXN];
int dfs(int x1, int y1, int x2, int y2) {
int xx = x2 - x1, yy = y2 - y1;
int l = xx + yy;
if (l == 1) {
a[k++] = make_pair(x1, y1);
return 0;
}
int d = l / 2;
for (int i = 0; i <= yy; i++) f[i] = 0;
t = 0;
for (int i = 0; i <= xx; i++)
for (int j = 0; j <= yy && i + j <= d; j++) {
if (j) f[j] = max(f[j], f[j - 1]);
f[j] += (x[i + x1] + y[j + y1]) % p;
if (i + j == d) g[t++] = make_pair(make_pair(x1 + i, y1 + j), f[j]);
}
for (int i = 0; i <= yy; i++) f[i] = 0;
int tt = t;
for (int i = xx; i >= 0; i--)
for (int j = yy; j >= 0 && i + j >= d; j--) {
if (j < yy) f[j] = max(f[j], f[j + 1]);
if (i + j == d) g[--tt].second += f[j];
f[j] += (x[i + x1] + y[j + y1]) % p;
}
int xa, ya;
long long ans = -1;
for (int i = 0; i < t; i++) {
if (g[i].second > ans) {
xa = g[i].first.first;
ya = g[i].first.second;
ans = g[i].second;
}
}
dfs(x1, y1, xa, ya);
dfs(xa, ya, x2, y2);
return 0;
}
int main() {
scanf("%d %d %d", &n, &m, &p);
for (int i = 0; i < n; i++) scanf("%d", &x[i]);
for (int i = 0; i < m; i++) scanf("%d", &y[i]);
if (n > 1 || m > 1) dfs(0, 0, n - 1, m - 1);
a[k++] = make_pair(n - 1, m - 1);
long long ans = 0;
for (int i = 0; i < k; i++) ans += (x[a[i].first] + y[a[i].second]) % p;
printf("%I64d\n", ans);
for (int i = 1; i < k; i++)
printf("%c", a[i].first == a[i - 1].first ? 'S' : 'C');
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int seed = 999983;
inline int read() {
int n = 0, f = 1;
char c;
for (c = getchar(); c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; c = getchar()) n = n * 10 + c - '0';
return n * f;
}
int sz[105], bj[105], n;
unsigned long long val[105];
vector<unsigned long long> tmp[105], Tmp;
bool vis[105];
multiset<unsigned long long> MP;
struct Tree {
vector<int> to[105];
int r1, r2, num;
unsigned long long vl;
void predfs(int x, int fa) {
sz[x] = 1;
for (int i = 0; i <= (int)to[x].size() - 1; i++)
if (to[x][i] != fa && !vis[to[x][i]])
predfs(to[x][i], x), sz[x] += sz[to[x][i]];
}
void findrt(int x, int fa, int size) {
bj[x] = 0;
for (int i = 0; i <= (int)to[x].size() - 1; i++)
if (to[x][i] != fa && !vis[to[x][i]])
findrt(to[x][i], x, size), bj[x] = max(bj[x], sz[to[x][i]]);
bj[x] = max(bj[x], size - sz[x]);
if (!r1 || bj[x] < bj[r1])
r1 = x, r2 = 0;
else if (r1 && bj[x] == bj[r1])
r2 = x;
}
unsigned long long dfs(int x, int fa) {
vector<unsigned long long>().swap(tmp[x]);
vis[x] = 1;
for (int i = 0; i <= (int)to[x].size() - 1; i++) {
int t = to[x][i];
if (t == fa || vis[t]) continue;
tmp[x].push_back(dfs(t, x));
}
sort(tmp[x].begin(), tmp[x].end());
unsigned long long ans = 1;
for (int i = 0; i <= (int)tmp[x].size() - 1; i++)
ans = ans * seed + tmp[x][i];
return ans;
}
unsigned long long cal_hash(int x) {
predfs(x, 0);
r1 = r2 = 0;
findrt(x, 0, sz[x]);
if (!r2) return dfs(r1, 0);
unsigned long long a1 = dfs(r1, r2), a2 = dfs(r2, r1);
if (a1 > a2) swap(a1, a2);
return a1 * seed + a2;
}
void init() {
for (int i = 1; i <= n; i++) vector<int>().swap(to[i]);
for (int m = read(); m--;) {
int x = read(), y = read();
to[x].push_back(y);
to[y].push_back(x);
}
for (int i = 1; i <= n; i++) vis[i] = 0;
num = 0;
vector<unsigned long long>().swap(Tmp);
for (int i = 1; i <= n; i++)
if (!vis[i]) {
++num;
Tmp.push_back(cal_hash(i));
}
sort(Tmp.begin(), Tmp.end());
vl = 0;
for (int i = 0; i <= (int)Tmp.size() - 1; i++) vl = vl * seed + Tmp[i];
}
bool check(int fo) {
MP.clear();
for (int i = 1; i <= n; i++) MP.insert(val[i]);
for (int i = 1; i <= n; i++) {
vector<unsigned long long>().swap(Tmp);
Tmp.push_back(1);
for (int j = 1; j <= n; j++) vis[j] = 0;
vis[i] = 1;
for (int j = 0; j <= (int)to[i].size() - 1; j++) {
Tmp.push_back(cal_hash(to[i][j]));
}
sort(Tmp.begin(), Tmp.end());
unsigned long long _vl = 0;
for (int j = 0; j <= (int)Tmp.size() - 1; j++) _vl = _vl * seed + Tmp[j];
if (MP.find(_vl) == MP.end())
return 0;
else
MP.erase(MP.find(_vl));
}
return 1;
}
void print() {
for (int i = 1; i <= n; i++)
for (int j = 0; j <= (int)to[i].size() - 1; j++) {
int t = to[i][j];
if (t < i) printf("%d %d\n", t, i);
}
}
} T[105];
void solve() {
n = read(), n = read();
for (int i = 1; i <= n; i++) T[i].init(), val[i] = T[i].vl;
for (int i = 1; i <= n; i++)
if (T[i].num == 2) {
for (int j = 1; j <= n; j++)
if (T[i].to[j].empty()) {
for (int k = 1; k <= n; k++)
if (k ^ j) {
T[i].to[j].push_back(k);
T[i].to[k].push_back(j);
if (T[i].check(j)) {
puts("YES");
T[i].print();
return;
}
T[i].to[j].pop_back();
T[i].to[k].pop_back();
}
}
break;
}
puts("NO");
}
int main() {
for (int cas = read(); cas--;) solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, s, a[100005], p, w[100005], ans;
multiset<long long> st;
int main() {
cin >> n >> s;
for (int k = 1; k <= n; k++) cin >> a[k];
cin >> p;
for (int k = 1; k <= n; k++) cin >> w[k];
for (int k = 1; k <= n; k++) {
st.insert(w[k]);
while (s < a[k]) {
if (st.size() == 0) {
cout << -1;
return 0;
}
ans += *st.begin();
st.erase(st.begin());
s += p;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int v[200005], w[200005], p[200005], sub[200005];
map<int, int> freq, loc;
set<int> st;
int root(int u) {
while (p[u] != u) {
p[u] = p[p[u]];
u = p[u];
}
return u;
}
void unite(int uu, int vv) {
int u = root(uu), v = root(vv);
if (u == v) return;
if (sub[u] < sub[v]) swap(u, v);
freq[sub[u]]--;
freq[sub[v]]--;
if (freq[sub[u]] == 0) st.erase(sub[u]);
if (freq[sub[v]] == 0) st.erase(sub[v]);
sub[u] += sub[v];
freq[sub[u]]++;
st.insert(sub[u]);
p[v] = u;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, i, j, jj;
cin >> n;
for (i = 0; i < n; i++) cin >> v[i];
for (i = 0; i < n; i++) w[i] = v[i];
sort(w, w + n);
for (i = 0; i < n; i++) loc[v[i]] = i;
for (i = 0; i < n; i++) {
p[i] = i;
sub[i] = 1;
}
int ans = w[n - 1] + 1, sol = -1;
for (i = 0; i < n; i++) {
if (st.size() == 1) {
if (sol < freq[*st.begin()]) {
sol = freq[*st.begin()];
ans = w[i - 1] + 1;
}
}
j = loc[w[i]];
freq[1]++;
st.insert(1);
if (j > 0 && v[j - 1] < v[j]) {
unite(j - 1, j);
}
if (j < n - 1 && v[j + 1] < v[j]) unite(j, j + 1);
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void fileIO() {}
bool sortbysecdesc(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second > b.second;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fileIO();
long long T;
T = 1;
while (T--) {
string s;
cin >> s;
char last = s[0];
long long index = 0;
long long n = s.size();
string ans = "";
for (long long i = 1; i < n; i++) {
if (s[i] > last) {
last = s[i];
index = i;
}
}
for (long long i = index; i < n; i++) {
if (s[i] == last) ans += s[i];
}
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double _pi = acos(-1.0);
int main() {
string s;
getline(cin, s);
vector<int> res(s.size(), 0);
int c = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'b') {
if (i > 0 && s[i - 1] == 'a') res[i - 1] = 1;
} else {
if (i > 0 && s[i - 1] == 'b') res[i - 1] = 1;
}
}
if (s[s.size() - 1] == 'a') res[res.size() - 1] = 1;
for (int i = 0; i < res.size(); i++) {
if (i == res.size() - 1)
printf("%d\n", res[i]);
else
printf("%d ", res[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t-- > 0) {
long long int n, k;
cin >> n >> k;
long long int a[n];
long long int s = 0;
for (long long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (long long int i = 1; i < n; i++) {
s += (k - a[i]) / a[0];
}
cout << s << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[305];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int j = 0; j < n; j++) {
int k = 0;
while (a[j] > 0) {
if (k) {
if (j == n - 1)
cout << "LR";
else
cout << "RL";
}
cout << "P";
a[j]--;
k++;
}
if (j < n - 1) cout << "R";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5 + 10;
const int LOG = 20;
string s;
int n;
int rnk[LOG][Max];
pair<pair<int, int>, int> sorter[Max];
int L[Max];
int R[Max];
int pos[Max];
int lcp[Max];
void build() {
for (int i = 0; i < n; i++) rnk[0][i] = s[i];
for (int lg = 1, sz = 1; lg < LOG; lg++, sz <<= 1) {
for (int i = 0; i < n; i++)
sorter[i] = make_pair(
make_pair(rnk[lg - 1][i], i + sz < n ? rnk[lg - 1][i + sz] : -1), i);
sort(sorter, sorter + n);
for (int i = 0, j = 0; i < n; i++)
rnk[lg][sorter[i].second] = j =
j + (i > 0 && sorter[i].first != sorter[i - 1].first);
}
for (int i = 0; i < n; i++) pos[rnk[LOG - 1][i]] = i;
for (int lg = LOG; lg--;)
for (int i = 0; i < n; i++)
if (max(pos[i], pos[i + 1]) + lcp[i] < n &&
rnk[lg][pos[i] + lcp[i]] == rnk[lg][pos[i + 1] + lcp[i]])
lcp[i] |= (1 << lg);
}
int main() {
cin >> s;
n = s.size();
build();
vector<pair<int, int> > vec;
for (int i = 0; i < n - 1; i++) {
while (vec.size() && vec.back().first >= lcp[i]) vec.pop_back();
if (vec.size())
L[i] = vec.back().second + 1;
else
L[i] = 0;
vec.push_back(make_pair(lcp[i], i));
}
vec.clear();
for (int i = n - 1; i--;) {
while (vec.size() && vec.back().first > lcp[i]) vec.pop_back();
if (vec.size())
R[i] = vec.back().second;
else
R[i] = n - 1;
vec.push_back(make_pair(lcp[i], i));
}
long long ANS = 0;
for (int i = 0; i < n - 1; i++)
ANS += 1ll * lcp[i] * (i - L[i] + 1) * (R[i] - i);
ANS += 1ll * n * (n + 1) / 2;
cout << ANS << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x[500010], y[500010];
bitset<4010> B[2010];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &x[i], &y[i]);
B[x[i]][y[i]] = 1;
}
for (int i = 1; i <= n; i++) B[i][i + n] = 1;
for (int i = 1; i <= n; i++) {
int o = i;
for (int j = i; j <= n; j++)
if (B[j][i]) o = j;
swap(B[i], B[o]);
for (int j = i + 1; j <= n; j++)
if (B[j][i]) B[j] ^= B[i];
}
for (int i = n; i >= 1; i--)
for (int j = i - 1; j >= 1; j--)
if (B[j][i]) B[j] ^= B[i];
for (int i = 1; i <= m; i++) {
if (B[y[i]][n + x[i]])
puts("NO");
else
puts("YES");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, k = 0;
cin >> n;
if (n % 4 == 1 || n % 4 == 2)
cout << "1";
else
cout << "0";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int n;
vector<long long int> v;
long long int l, r;
void solve() {
vector<long long int> bits(31, 0);
long long int n;
cin >> n;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) {
cin >> v[i];
long long int temp = v[i];
long long int x = 0;
while (temp > 0) {
if ((temp & 1)) bits[x]++;
x++;
temp = temp >> 1;
}
}
long long int b = -1;
for (long long int i = 0; i < 31; i++) {
if (bits[i] == 1) b = i;
}
long long int ind = -1;
for (long long int i = 0; i < n; i++) {
if (((v[i] >> b) & 1)) ind = i;
}
if (ind != -1) cout << v[ind] << " ";
for (long long int i = 0; i < n; i++) {
if (i != ind) cout << v[i] << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int i = 0; i < t; i++) {
solve();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const double dinf = inf;
const int N = 1e6 + 10;
const int M = 18 + 10;
const int mod = 998244353;
const double eps = 1e-10;
char a[N], b[N];
int main() {
int n, m;
scanf("%s%s", a, b);
n = strlen(a);
m = strlen(b);
int cnt1 = 0, cnt2 = 0, ans = 0;
for (int i = 0; i < (m); i++)
if (a[i] & 1) cnt1 ^= 1;
for (int i = 0; i < (m); i++)
if (b[i] & 1) cnt2 ^= 1;
if (cnt1 % 2 == cnt2 % 2) ans++;
for (int i = m; i < n; i++) {
cnt1 ^= a[i] ^ a[i - m];
if (cnt1 % 2 == cnt2 % 2) ans++;
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int v[N][N];
int n;
int main() {
for (int i = 0; i < N; i++) {
if (i < 2) {
v[i][i] = 1;
continue;
}
int sig = 1;
for (int j = 1; j <= i; j++)
if (v[i - 1][j - 1] + v[i - 2][j] < -1 ||
v[i - 1][j - 1] + v[i - 2][j] > 1) {
sig = -1;
continue;
}
for (int j = 0; j <= i; j++)
if (j)
v[i][j] = v[i - 1][j - 1] + sig * v[i - 2][j];
else
v[i][j] = sig * v[i - 2][j];
for (int j = 0; j <= i; j++) assert(v[i][j] <= 1 && v[i][j] >= -1);
}
scanf("%d", &n);
printf("%d\n", n);
for (int i = 0; i <= n; i++) printf("%d%c", v[n][i], i < n ? ' ' : '\n');
printf("%d\n", n - 1);
for (int i = 0; i <= n - 1; i++)
printf("%d%c", v[n - 1][i], i < n - 1 ? ' ' : '\n');
return 0;
}
| 7 |
#include <bits/stdc++.h>
inline int sbt(int x) { return __builtin_popcount(x); }
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
bool ok;
inline int mul(int a, int b, int m = 1000000007) { return (a * b) % m; }
inline int add(int a, int b, int m = 1000000007) { return (a + b) % m; }
inline int sub(int a, int b, int m = 1000000007) { return (a - b + m) % m; }
int dx[][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
int fastpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b >>= 1;
}
return res;
}
int modinv(int a) { return fastpow(a, 1000000007 - 2); }
int n, m, a[100013];
int dp[10002][1002];
int g, r;
pair<int, int> adj[10002][1002][2];
deque<pair<int, int> > dq;
pair<int, int> node, pnei;
int wt, cyc;
int32_t main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i];
}
cin >> g >> r;
sort(a, a + m);
memset(dp, -1, sizeof dp);
for (int i = 0; i < m; i++) {
for (int j = 0; j < g; j++) {
adj[i][j][0] = adj[i][j][1] = make_pair(-1, -1);
}
adj[i][g][0] = make_pair(i, 0);
adj[i][g][1] = make_pair(-1, -1);
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < g; j++) {
for (int d = -1; d <= 1; d += 2) {
int k = i + d;
if (k < 0) continue;
if (k >= m) continue;
int diff = abs(a[k] - a[i]);
int till = diff + j;
if (till <= g) {
adj[i][j][min(1, d + 1)] = make_pair(k, till);
}
}
}
}
dq.push_back(make_pair(0, 0));
ok = 0;
dp[0][0] = 0;
int res = -1;
while (!dq.empty()) {
node = dq.front();
dq.pop_front();
if (node.first == m - 1) {
if (res == -1)
res = (r + g) * dp[m - 1][node.second] + node.second;
else
res = min(res, (r + g) * dp[m - 1][node.second] + node.second);
}
for (int i = 0; i < 2; i++) {
pnei = adj[node.first][node.second][i];
if (pnei == make_pair(-1, -1)) continue;
wt = (node.second == g);
if ((dp[pnei.first][pnei.second] == -1) or
dp[pnei.first][pnei.second] > (wt + dp[node.first][node.second])) {
dp[pnei.first][pnei.second] = wt + dp[node.first][node.second];
if (wt)
dq.push_back(pnei);
else
dq.push_front(pnei);
}
}
}
cout << res;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int xp, dich, lv[int(1e5 + 2)];
bool ok[int(1e5 + 2)];
void in() { cin >> dich >> xp; }
void BFS(int i) {
queue<int> q;
int j;
q.push(i);
ok[i] = 1;
lv[i] = 1;
while (!q.empty()) {
i = q.front();
q.pop();
if (ok[i + 1] == 0) {
j = i + 1;
q.push(j);
ok[j] = 1;
lv[j] = lv[i] + 1;
}
if (i % 2 == 0 && i >= (dich / 2) && ok[i / 2] == 0) {
j = i / 2;
q.push(j);
ok[j] = 1;
lv[j] = lv[i] + 1;
}
if (lv[dich] > 0) return;
}
}
void ou() { cout << lv[dich] - 1; }
int main() {
ios::sync_with_stdio(0);
in();
BFS(xp);
ou();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long s[100010][6];
long long sum[400010][6];
long long num[400010];
long long ans[6];
int n, m;
int x, k;
char ch[3];
int l, r;
long long calc(int l, int r, int k) {
return ((s[r][k] - s[l - 1][k]) % 1000000007 + 1000000007) % 1000000007;
}
void pushup(int rt) {
for (int i = 0; i <= 5; i++) {
sum[rt][i] = sum[rt << 1][i] + sum[rt << 1 | 1][i];
}
}
void pushdown(int rt, int l, int r) {
if (num[rt] != -1) {
int mid = (l + r) >> 1;
num[rt << 1] = num[rt];
num[rt << 1 | 1] = num[rt];
for (int i = 0; i <= 5; i++) {
sum[rt << 1][i] = num[rt] * calc(l, mid, i) % 1000000007;
sum[rt << 1 | 1][i] = num[rt] * calc(mid + 1, r, i) % 1000000007;
}
num[rt] = -1;
}
}
void build(int rt, int l, int r) {
num[rt] = -1;
if (l == r) {
scanf("%d", &x);
for (int i = 0; i <= 5; i++) {
sum[rt][i] = 1ll * x * calc(l, l, i) % 1000000007;
}
return;
}
int mid = (l + r) >> 1;
build(rt << 1, l, mid);
build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void change(int rt, int l, int r, int L, int R, int k) {
if (L <= l && r <= R) {
num[rt] = 1ll * k;
for (int i = 0; i <= 5; i++) {
sum[rt][i] = 1ll * k * calc(l, r, i) % 1000000007;
}
return;
}
pushdown(rt, l, r);
int mid = (l + r) >> 1;
if (L <= mid) {
change(rt << 1, l, mid, L, R, k);
}
if (R > mid) {
change(rt << 1 | 1, mid + 1, r, L, R, k);
}
pushup(rt);
}
void query(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) {
for (int i = 0; i <= 5; i++) {
ans[i] += sum[rt][i];
ans[i] %= 1000000007;
}
return;
}
pushdown(rt, l, r);
int mid = (l + r) >> 1;
if (L <= mid) {
query(rt << 1, l, mid, L, R);
}
if (R > mid) {
query(rt << 1 | 1, mid + 1, r, L, R);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
s[i][0] = 1ll;
for (int j = 1; j <= 5; j++) {
s[i][j] = s[i][j - 1] * i % 1000000007;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 5; j++) {
s[i][j] += s[i - 1][j];
s[i][j] %= 1000000007;
}
}
build(1, 1, n);
while (m--) {
scanf("%s%d%d%d", ch, &l, &r, &k);
if (ch[0] == '=') {
change(1, 1, n, l, r, k);
} else {
memset(ans, 0, sizeof(ans));
query(1, 1, n, l, r);
long long res = 0;
if (k == 0) {
res += ans[0], res %= 1000000007;
} else if (k == 1) {
res += ans[1], res %= 1000000007;
res -= 1ll * (l - 1) * ans[0] % 1000000007, res %= 1000000007;
} else if (k == 2) {
res += ans[2], res %= 1000000007;
res -= 2ll * (l - 1) * ans[1] % 1000000007, res %= 1000000007;
res += 1ll * (l - 1) * (l - 1) % 1000000007 * ans[0] % 1000000007,
res %= 1000000007;
} else if (k == 3) {
res += ans[3], res %= 1000000007;
res -= 3ll * (l - 1) * ans[2] % 1000000007, res %= 1000000007;
res += 3ll * (l - 1) * (l - 1) % 1000000007 * ans[1] % 1000000007,
res %= 1000000007;
res -= 1ll * (l - 1) * (l - 1) % 1000000007 * (l - 1) % 1000000007 *
ans[0] % 1000000007,
res %= 1000000007;
} else if (k == 4) {
res += ans[4], res %= 1000000007;
res -= 4ll * (l - 1) * ans[3] % 1000000007, res %= 1000000007;
res += 6ll * (l - 1) * (l - 1) % 1000000007 * ans[2] % 1000000007,
res %= 1000000007;
res -= 4ll * (l - 1) * (l - 1) % 1000000007 * (l - 1) % 1000000007 *
ans[1] % 1000000007,
res %= 1000000007;
res += 1ll * (l - 1) * (l - 1) % 1000000007 * (l - 1) % 1000000007 *
(l - 1) % 1000000007 * ans[0] % 1000000007,
res %= 1000000007;
} else {
res += ans[5], res %= 1000000007;
res -= 5ll * (l - 1) * ans[4] % 1000000007, res %= 1000000007;
res += 10ll * (l - 1) * (l - 1) % 1000000007 * ans[3] % 1000000007,
res %= 1000000007;
res -= 10ll * (l - 1) * (l - 1) % 1000000007 * (l - 1) % 1000000007 *
ans[2] % 1000000007,
res %= 1000000007;
res += 5ll * (l - 1) * (l - 1) % 1000000007 * (l - 1) % 1000000007 *
(l - 1) % 1000000007 * ans[1] % 1000000007,
res %= 1000000007;
res -= 1ll * (l - 1) * (l - 1) % 1000000007 * (l - 1) % 1000000007 *
(l - 1) % 1000000007 * (l - 1) % 1000000007 * ans[0] %
1000000007,
res %= 1000000007;
}
res = (res % 1000000007 + 1000000007) % 1000000007;
printf("%lld\n", res);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int E[411][411];
int V[411];
int bfs(int state) {
memset(V, 0, sizeof(V));
int ans = -1;
queue<pair<int, int> > q;
q.push({1, 0});
while (q.size() > 0) {
pair<int, int> pt = q.front();
q.pop();
int node = pt.first;
int t0 = pt.second + 1;
if (node == n) {
ans = t0 - 1;
}
for (int i = 1; i <= n; i++) {
if (E[node][i] == state && V[i] == 0) {
q.push({i, t0});
V[i] = 1;
}
}
}
return ans;
}
int main(int argc, char const *argv[]) {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
E[a][b] = E[b][a] = 1;
}
cout << bfs(0) * bfs(1) << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dp[201][201][201];
int solve(string& s, string t, int allowed, int n, int byet) {
if (dp[allowed][n][byet] != -1) return dp[allowed][n][byet];
if (n == 0) return 0;
int res = 0;
if (allowed > 0) {
if (s[n - 1] == t[1]) {
res = max(byet + solve(s, t, allowed - 1, n - 1, byet),
solve(s, t, allowed, n - 1, byet + 1));
} else if (s[n - 1] == t[0]) {
res = max(byet + solve(s, t, allowed, n - 1, byet),
solve(s, t, allowed - 1, n - 1, byet + 1));
} else {
res = max(max(byet + solve(s, t, allowed - 1, n - 1, byet),
solve(s, t, allowed - 1, n - 1, byet + 1)),
solve(s, t, allowed, n - 1, byet));
}
} else {
if (s[n - 1] == t[1]) {
res = solve(s, t, allowed, n - 1, byet + 1);
} else if (s[n - 1] == t[0]) {
res = byet + solve(s, t, allowed, n - 1, byet);
} else {
res = solve(s, t, allowed, n - 1, byet);
}
}
return dp[allowed][n][byet] = res;
}
int main() {
int n, k;
string s, t;
cin >> n >> k >> s >> t;
memset(dp, -1, sizeof(dp));
if (t[0] == t[1]) {
int counter = 0;
for (int i = 0; i < n; i++) {
if (s[i] == t[0]) counter++;
}
int maxAvail = min(n, counter + k);
cout << maxAvail * (maxAvail - 1) / 2;
} else
cout << solve(s, t, k, n, 0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int main(int argc, char const *argv[]) {
cin.sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> vals(n);
for (int i = 0; i < n; i++) {
cin >> vals[i];
}
int a = *max_element(vals.begin(), vals.end());
int i = 0;
while (vals[i] != a) {
if (vals[i] > vals[i + 1]) {
cout << "NO";
return 0;
}
i++;
}
i = vals.size() - 1;
while (vals[i] != a) {
if (vals[i] > vals[i - 1]) {
cout << "NO";
return 0;
}
i--;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[1111111];
struct Tag {
string name;
vector<int> entries;
};
int tags;
Tag t[500000];
string getName(char *s, int &p, bool &closed) {
p++;
string name = "";
while (s[p] >= 'a' && s[p] <= 'z') {
name += s[p];
p++;
}
if (s[p] == '/') {
closed = true;
p++;
} else
closed = false;
p++;
return name;
}
bool isCloseTag(char *s, int &p) {
if (s[p + 1] != '/') return false;
while (s[p] != '>') p++;
p++;
return true;
}
int parse(char *s, int &p) {
bool closed = false;
int n = tags;
tags++;
t[n].name = getName(s, p, closed);
if (!closed)
while (!isCloseTag(s, p)) t[n].entries.push_back(parse(s, p));
return n;
}
vector<string> v;
int pos;
int ans;
void dfs(int k) {
if (pos + 1 >= v.size() && t[k].name == v[v.size() - 1]) ans++;
int prev = pos;
if (pos < v.size() && t[k].name == v[pos]) pos++;
for (int i = 0; i < t[k].entries.size(); i++) dfs(t[k].entries[i]);
pos = prev;
}
int main() {
scanf("%s", s);
tags = 1;
t[0].name = "ROOT";
int p = 0;
while (s[p] > '\0') t[0].entries.push_back(parse(s, p));
int kt;
cin >> kt;
string buf;
getline(cin, buf);
for (int nt = 0; nt < kt; nt++) {
getline(cin, buf);
buf += " ";
v.clear();
string cur = "";
for (int i = 0; i < buf.length(); i++) {
if (buf[i] >= 'a' && buf[i] <= 'z')
cur += buf[i];
else {
if (cur.length() > 0) v.push_back(cur);
cur = "";
}
}
pos = 0;
ans = 0;
dfs(0);
cout << ans << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
int s, b;
int p[maxn];
pair<long long, long long> a[maxn];
long long t[maxn];
long long sum[maxn];
int main() {
cin >> s >> b;
for (int i = 0; i < s; i++) cin >> p[i];
for (int i = 0; i < b; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a, a + b);
for (int i = 0; i < b; i++) t[i] = a[i].first;
for (int i = 1; i <= b; i++) sum[i] = sum[i - 1] + a[i - 1].second;
for (int i = 0; i < s; i++) {
long long re = p[i];
int pos = upper_bound(t, t + b, re) - t;
printf("%lld ", sum[pos]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ans[110][110];
int res[110];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) scanf("%d", &ans[i][j]);
}
int t = 0;
for (int i = 1; i <= n; ++i) {
bool is_good = true;
for (int j = 1; j <= n; ++j) {
if (ans[i][j] == 1 || ans[i][j] == 3) {
is_good = false;
break;
}
}
if (is_good) {
res[t++] = i;
}
}
if (t) {
printf("%d\n%d", t, res[0]);
for (int i = 1; i < t; ++i) printf(" %d", res[i]);
} else
printf("0");
printf("\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, d, m, lc, cnt;
long long a[maxn], x, ok;
double ans;
long long read() {
long long xx = 0, ff = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (x == '-') ff = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
xx = (xx << 1) + (xx << 3) + c - '0';
c = getchar();
}
return xx * ff;
}
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i <= n; i++) a[i] = read();
scanf("%d", &m);
while (m--) {
x = read();
int ss, l, r;
cnt = 0;
while (lc < n && a[lc + 1] < x) lc++;
if (!lc)
ss = a[1] - x;
else if (lc == n)
ss = x - a[n] - 1;
else
ss = min(x - a[lc] - 1, a[lc + 1] - x);
ans = atan2(1.0, (double)ss);
l = lc;
r = lc + 1;
while (l && r <= n) {
double s = atan2(1, a[r] - x);
while (l && x - a[l] < a[r] - x) {
--l;
if (s * 2 <= ans) break;
}
if (!l || s * 2 <= ans) break;
if (x - a[l] - 1 <= a[r] - x) {
ans = s * 2;
break;
}
s = atan2(1, x - a[l] - 1);
while (r <= n && a[r] - x + 1 < x - a[l] - 1) {
++r;
if (s * 2 <= ans) break;
}
if (r > n || s * 2 <= ans) break;
if (a[r] - x <= x - a[l] - 1) {
ans = s * 2;
break;
}
}
printf("%.15f\n", ans);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m;
vector<int> g[N], q[N];
bool read() {
if (!(cin >> n >> m)) return false;
for (int i = 0; i < int(n - 1); ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < int(m); ++i) {
int a, b;
cin >> a >> b;
--a, --b;
q[a].push_back(b);
q[b].push_back(a);
}
return true;
}
int l[N], r[N], T;
void dfs(int v) {
l[v] = r[v] = T++;
for (int i = 0; i < int(g[v].size()); ++i) {
int to = g[v][i];
if (l[to] == -1) {
dfs(to);
r[v] = r[to];
}
}
}
pair<int, int> st[N * 4];
int upd[N * 4];
pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first)
return make_pair(a.first, a.second + b.second);
else
return min(a, b);
}
void push(int v, int l, int r) {
if (upd[v] != 0) {
st[v].first += upd[v];
if (l != r) {
upd[v * 2 + 1] += upd[v];
upd[v * 2 + 2] += upd[v];
}
upd[v] = 0;
}
}
void update(int v, int l, int r, int L, int R, int val) {
push(v, l, r);
if (L == l && R == r) {
upd[v] += val;
return;
}
int m = (l + r) >> 1;
if (R <= m) update(v * 2 + 1, l, m, L, R, val);
if (L > m) update(v * 2 + 2, m + 1, r, L, R, val);
if (L <= m && R > m)
update(v * 2 + 1, l, m, L, m, val),
update(v * 2 + 2, m + 1, r, m + 1, R, val);
push(v * 2 + 1, l, m);
push(v * 2 + 2, m + 1, r);
st[v] = merge(st[v * 2 + 1], st[v * 2 + 2]);
}
void build(int v, int l, int r) {
if (l == r) {
st[v] = make_pair(0, 1);
return;
}
int m = (l + r) >> 1;
build(v * 2 + 1, l, m);
build(v * 2 + 2, m + 1, r);
st[v] = merge(st[v * 2 + 1], st[v * 2 + 2]);
}
pair<int, int> get(int v, int l, int r, int L, int R) {
push(v, l, r);
if (l == L && r == R) return st[v];
int m = (l + r) >> 1;
if (R <= m) return get(v * 2 + 1, l, m, L, R);
if (L > m) return get(v * 2 + 2, m + 1, r, L, R);
if (L <= m && R > m)
return merge(get(v * 2 + 1, l, m, L, m),
get(v * 2 + 2, m + 1, r, m + 1, R));
}
int ans[N];
void dfs2(int v) {
for (int i = 0; i < int(q[v].size()); ++i) {
int u = q[v][i];
update(0, 0, T - 1, l[v], r[v], +1);
update(0, 0, T - 1, l[u], r[u], +1);
}
pair<int, int> p = get(0, 0, T - 1, 0, T - 1);
int c = T;
if (p.first == 0) c -= p.second;
ans[v] = max(c - 1, 0);
for (int i = 0; i < int(g[v].size()); ++i) {
int to = g[v][i];
if (l[v] < l[to]) dfs2(to);
}
for (int i = 0; i < int(q[v].size()); ++i) {
int u = q[v][i];
update(0, 0, T - 1, l[v], r[v], -1);
update(0, 0, T - 1, l[u], r[u], -1);
}
}
void solve() {
memset(l, -1, sizeof(l));
dfs(0);
build(0, 0, T - 1);
dfs2(0);
for (int i = 0; i < int(n); ++i) cout << ans[i] << " ";
}
int main() {
while (read()) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double TL = 1.5 * CLOCKS_PER_SEC;
mt19937 rng(
(unsigned int)chrono::steady_clock::now().time_since_epoch().count());
long long mod = 998244353;
long long pow2(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
class M2 {
public:
long long x00, x01, x10, x11;
void multi(M2 p) {
long long _x00 = x00 * p.x00 + x01 * p.x10;
long long _x01 = x00 * p.x01 + x01 * p.x11;
long long _x10 = x10 * p.x00 + x11 * p.x10;
long long _x11 = x10 * p.x01 + x11 * p.x11;
x00 = _x00 % mod;
x01 = _x01 % mod;
x10 = _x10 % mod;
x11 = _x11 % mod;
}
};
M2 pow2m(M2 mat, long long b) {
M2 ans;
ans.x00 = ans.x11 = 1;
ans.x10 = ans.x01 = 0;
while (b > 0) {
if (b & 1) ans.multi(mat);
mat.multi(mat);
b >>= 1;
}
return ans;
}
long long n, m, L, R;
int main() {
cin >> n >> m >> L >> R;
if (n * m % 2 == 1) {
cout << pow2(R - L + 1, n * m) << endl;
} else {
long long a = (R - L + 1) / 2, b = (R - L + 1) / 2;
if ((R - L + 1) % 2 == 1) {
if (L % 2 == 0)
a += 1;
else
b += 1;
}
M2 mat;
mat.x00 = mat.x11 = a;
mat.x10 = mat.x01 = b;
M2 r = pow2m(mat, n * m);
cout << r.x00 << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long int N = 1e5 + 5;
const long long int LOGN = 18;
class Tree {
public:
vector<long long int> g[N];
long long int dp[LOGN][N], depth[N], euler[N], s[N], e[N], sz[N], chainh[N];
long long int n, tt;
private:
void preprocess() {
dfs1(1, 0);
for (long long int k = 1; k <= LOGN - 1; k++) {
for (long long int i = 1; i <= n; i++) {
dp[k][i] = dp[k - 1][dp[k - 1][i]];
}
}
}
public:
void init(long long int nn) {
n = nn;
tt = 0;
for (long long int i = 1; i <= n; i++) g[i].clear();
}
void add(long long int u, long long int v) {
g[u].push_back(v);
g[v].push_back(u);
}
void process() {
preprocess();
chainh[1] = 1;
dfs2(1, 0);
}
long long int lca(long long int u, long long int v) {
if (depth[u] < depth[v]) swap(u, v);
for (long long int k = LOGN - 1; k >= 0; k--) {
if (depth[dp[k][u]] >= depth[v]) u = dp[k][u];
}
if (u == v) return u;
for (long long int k = LOGN - 1; k >= 0; k--) {
if (dp[k][u] != dp[k][v]) u = dp[k][u], v = dp[k][v];
}
return dp[0][u];
}
void dfs1(long long int u, long long int p) {
depth[u] = depth[p] + 1;
sz[u] = 1;
dp[0][u] = p;
for (long long int v : g[u]) {
if (v != p) {
dfs1(v, u);
sz[u] += sz[v];
}
}
}
void dfs2(long long int u, long long int p) {
long long int HC = -1, S = -1;
s[u] = ++tt;
euler[tt] = u;
for (long long int v : g[u]) {
if (v != p) {
if (sz[v] > S) HC = v, S = sz[v];
}
}
if (HC == -1) {
e[u] = tt;
return;
}
chainh[HC] = chainh[u];
dfs2(HC, u);
for (long long int v : g[u]) {
if (v != p && v != HC) {
chainh[v] = v;
dfs2(v, u);
}
}
e[u] = tt;
}
long long int dist(long long int u, long long int v) {
return depth[u] + depth[v] - 2 * depth[lca(u, v)];
}
};
Tree T;
long long int S = 0;
set<long long int> ss;
void add(long long int u) {
if (ss.empty()) {
S = 0;
ss.insert(T.s[u]);
return;
}
auto it = ss.upper_bound(T.s[u]);
long long int l, r;
if (it == ss.end() || it == ss.begin()) {
l = T.euler[*ss.begin()], r = T.euler[*ss.rbegin()];
} else {
r = T.euler[*it];
it--;
l = T.euler[*it];
}
S += (T.dist(u, l) + T.dist(u, r) - T.dist(l, r)) / 2;
ss.insert(T.s[u]);
}
void del(long long int u) {
ss.erase(T.s[u]);
if (ss.empty()) {
S = -1;
return;
}
auto it = ss.upper_bound(T.s[u]);
long long int l, r;
if (it == ss.end() || it == ss.begin()) {
l = T.euler[*ss.begin()], r = T.euler[*ss.rbegin()];
} else {
r = T.euler[*it];
it--;
l = T.euler[*it];
}
S -= (T.dist(u, l) + T.dist(u, r) - T.dist(l, r)) / 2;
}
signed main() {
long long int n, k;
cin >> n >> k;
T.init(n);
for (long long int i = 1; i <= n - 1; i++) {
long long int u, v;
cin >> u >> v;
T.add(u, v);
}
T.process();
long long int r = 0;
long long int ans = 1;
for (long long int i = 1; i <= n; i++) {
while (r + 1 <= n) {
add(r + 1);
if (S + 1 > k) {
del(r + 1);
break;
}
r++;
}
ans = max(ans, r - i + 1);
del(i);
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 110;
int n, a[N], b[N], dp[N][N * N], pd[N][N * N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) scanf("%d", b + i);
dp[0][0] = 0;
int sa = 0, sb = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++)
for (int k = 0; k <= sb; k++) pd[j][k] = dp[j][k];
for (int j = 0; j <= i; j++)
for (int k = 0; k <= sb + b[i]; k++) dp[j][k] = -(1 << 20);
for (int j = 0; j <= i; j++)
for (int k = 0; k <= sb; k++) {
dp[j][k] = max(dp[j][k], pd[j][k]);
dp[j + 1][k + b[i]] = max(dp[j + 1][k + b[i]], pd[j][k] + a[i]);
}
sa += a[i], sb += b[i];
}
int ret = 0;
for (int j = 0; j <= n; j++) {
for (int k = sa; k <= sb; k++) ret = max(ret, dp[j][k]);
if (ret > 0) {
printf("%d %d\n", j, sa - ret);
return 0;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1000;
vector<int> tr[N + 1];
int n, sz[N + 1], R, z[N + 1];
int C(int v = 1, int p = 0) {
for (int u : tr[v])
if (u != p && sz[u] > n >> 1) return C(u, v);
return v;
}
void plsz(int v, int p = 0) {
sz[v] = 1;
for (int u : tr[v])
if (u != p) {
plsz(u, v);
sz[v] += sz[u];
}
}
int Z, d;
void as(int v, int p = R) {
Z += d;
z[v] = Z;
printf("%d %d %d\n", p, v, z[v] - z[p]);
for (int u : tr[v])
if (u != p) as(u, v);
}
void kl(int id) {
int s = 0;
for (int i = 0; i < (int)(id); ++i) s += sz[tr[R][i]];
d = 1;
for (int i = 0; i < (int)(id); ++i) as(tr[R][i]);
d = s + 1;
Z = 0;
for (int i = id; i < (int)(tr[R].size()); ++i) as(tr[R][i]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i < (int)(n); ++i) {
int a, b;
scanf("%d%d", &a, &b);
tr[a].push_back(b);
tr[b].push_back(a);
}
plsz(1);
R = C();
plsz(R);
int id = 0;
for (int i = 0; i < (int)(tr[R].size()); ++i)
if (sz[tr[R][i]] >= n / 3) {
swap(tr[R][0], tr[R][i]);
id = 1;
break;
}
if (id == 0) {
int s = 0;
for (int i = 0; i < (int)(tr[R].size()); ++i) {
s += sz[tr[R][i]];
if (s >= n / 3) {
id = i + 1;
break;
}
}
}
kl(id);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 3;
int n, k;
long long int A[N];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> A[i];
sort(A + 1, A + 1 + n);
long long int maxi = k;
int idx = 1;
int ans = 0;
for (int i = 1; i <= n; i++) {
long long int cur = A[i];
if (cur > 2 * maxi) {
while (cur > 2 * maxi) {
ans++;
maxi <<= 1;
}
}
maxi = max(maxi, A[i]);
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100012;
int n;
int a[maxn];
int f[maxn][6];
int trace[maxn][6];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= 5; i++) f[1][i] = 1;
bool ok = 0;
for (int i = 2; i <= n; i++)
for (int cur = 1; cur <= 5; cur++)
for (int pre = 1; pre <= 5; pre++) {
if (!f[i - 1][pre]) continue;
ok = 0;
if (a[i - 1] < a[i] && pre < cur) ok = 1;
if (a[i - 1] > a[i] && pre > cur) ok = 1;
if (a[i - 1] == a[i] && pre != cur) ok = 1;
if (ok) {
f[i][cur] = 1;
trace[i][cur] = pre;
}
}
int res = 0;
for (res = 1; res <= 5 && !f[n][res]; res++)
;
if (res == 6) {
cout << -1 << endl;
return 0;
} else {
stack<int> rarr;
for (int i = n; i >= 1; i--) {
rarr.push(res);
res = trace[i][res];
}
while (rarr.size()) {
cout << rarr.top() << " ";
rarr.pop();
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void sub(int &a, int b) {
a -= b;
if (a < 0) a += mod;
}
int mult(int a, int b) { return (long long)a * b % mod; }
void solve(int n) {
vector<vector<int> > dp(n + 1, vector<int>(n + 1));
dp[0][0] = 1;
for (int i = 0; i < (int)(n); ++i) {
assert(dp[i][0] == 1);
for (int l = 0; l < (int)(n + 1); ++l)
for (int r = 0; r < (int)(n + 1); ++r) {
int ways = mult(dp[i][l], dp[i][r]);
if (l + r <= n) add(dp[i + 1][l + r], ways);
if (l + r + 1 <= n) add(dp[i + 1][l + r + 1], ways);
if (l + r <= n) add(dp[i + 1][l + r], mult(ways, 2 * (l + r)));
if (1 <= l + r && l + r - 1 <= n)
add(dp[i + 1][l + r - 1], mult(ways, l * (l - 1) + r * (r - 1)));
if (l && r && l + r - 1 <= n)
add(dp[i + 1][l + r - 1], mult(ways, 2 * l * r));
}
}
cout << dp[n][1] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
while (cin >> n) solve(n);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int n;
int main() {
cin >> n;
if (n == 1)
cout << "1";
else {
if (n % 2 == 0) {
n = n - (n / 2 - 1);
cout << n;
} else {
n = n - 1;
n = n - (n / 2 - 1);
cout << n;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int N = 1111;
int dp[N][4];
int a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) cin >> a[i];
memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i < 4; i++) dp[0][i] = 0;
dp[1][0] = 1;
if (a[1] == 3)
dp[1][1] = dp[1][2] = 0;
else if (a[1] != 0)
dp[1][a[1]] = 0;
for (int i = 2; i < n + 1; i++) {
for (int j = 0; j < 3; j++) dp[i][0] = min(dp[i][0], dp[i - 1][j] + 1);
if (a[i] == 1) {
dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]);
}
if (a[i] == 2) {
dp[i][2] = min(dp[i - 1][0], dp[i - 1][1]);
}
if (a[i] == 3) {
dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]);
dp[i][2] = min(dp[i - 1][0], dp[i - 1][1]);
}
}
int res = 0x3f3f3f3f;
for (int i = 0; i < 3; i++) res = min(res, dp[n][i]);
cout << res << endl;
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.