solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#pragma GCC diagnostic ignored "-Wmissing-declarations"
vector<string> a;
vector<string> rr;
void solve(string& s, int n, int cur = 0) {
if (cur == n) {
rr.push_back(s);
return;
}
if (s[cur] == '?') {
for (char c = 'a'; c <= 'e'; ++c) {
s[cur] = c;
solve(s, n, cur + 1);
}
if (cur + 1 < n)
s = s.substr(0, cur) + s.substr(cur + 1, n - cur - 1);
else
s = s.substr(0, cur);
solve(s, n - 1, cur);
if (cur + 1 < n)
s = s.substr(0, cur) + "?" + s.substr(cur, n - cur - 1);
else
s.push_back('?');
} else
solve(s, n, cur + 1);
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
a.resize(n);
for (auto& s : a) cin >> s;
sort(begin(a), end(a));
stringstream out;
for (int i = 0; i < m; ++i) {
string s;
cin >> s;
rr.clear();
solve(s, s.length());
int res = 0;
sort(begin(rr), end(rr));
auto rb = unique(begin(rr), end(rr));
for (auto i = begin(rr); i != rb; ++i) {
res +=
upper_bound(begin(a), end(a), *i) - lower_bound(begin(a), end(a), *i);
}
out << res << "\n";
}
cout << out.str();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
long long n, c[N], ans[N], pw[64];
queue<long long> q[64];
int main() {
cin >> n;
pw[0] = 1;
for (int i = 1; i <= 60; i++) pw[i] = pw[i - 1] << 1;
for (int i = 1; i <= n; i++) {
cin >> c[i];
for (int j = 60; j >= 0; j--)
if (c[i] & pw[j]) {
q[j].push(c[i]);
break;
}
}
long long sum = 0;
for (int i = 1; i <= n; i++) {
int flag = 0;
for (int j = 0; j <= 60; j++)
if (!(sum & pw[j]) && !q[j].empty()) {
ans[i] = q[j].front(), sum ^= q[j].front(), q[j].pop();
flag = 1;
break;
}
if (!flag) {
puts("No");
return 0;
}
}
puts("Yes");
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300002;
int edge[maxn][5], d[maxn], res[maxn];
int m, n;
void read() {
memset(d, 0, sizeof(d));
memset(res, 0, sizeof(res));
int u, v;
while (m--) {
scanf("%d %d", &u, &v);
edge[u][d[u]++] = v;
edge[v][d[v]++] = u;
}
return;
}
void dfs(int st) {
int c = 0;
for (int i = 0; i < d[st]; i++) {
if (res[edge[st][i]] == res[st]) c++;
}
if (c > 1) {
res[st] ^= 1;
for (int i = 0; i < d[st]; i++) {
if (res[st] == res[edge[st][i]]) dfs(edge[st][i]);
}
}
return;
}
void solve() {
for (int i = 1; i <= n; i++) dfs(i);
for (int i = 1; i <= n; i++) printf("%d", res[i]);
puts("");
return;
}
int main() {
while (~scanf("%d %d", &n, &m)) {
read();
solve();
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
template <typename... As>
struct tpl : public std::tuple<As...> {
using std::tuple<As...>::tuple;
tpl() {}
tpl(std::tuple<As...> const& b) { std::tuple<As...>::operator=(b); }
template <typename T = tuple<As...> >
typename tuple_element<0, T>::type const& x() const {
return get<0>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<0, T>::type& x() {
return get<0>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<1, T>::type const& y() const {
return get<1>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<1, T>::type& y() {
return get<1>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<2, T>::type const& z() const {
return get<2>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<2, T>::type& z() {
return get<2>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<3, T>::type const& w() const {
return get<3>(*this);
}
template <typename T = tuple<As...> >
typename tuple_element<3, T>::type& w() {
return get<3>(*this);
}
};
using lli = long long int;
using llu = long long unsigned;
using pii = tpl<lli, lli>;
using piii = tpl<lli, lli, lli>;
using piiii = tpl<lli, lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T> >;
template <class T>
using max_queue = priority_queue<T>;
template <size_t... I>
struct my_index_sequence {
using type = my_index_sequence;
static constexpr array<size_t, sizeof...(I)> value = {{I...}};
};
namespace my_index_sequence_detail {
template <typename I, typename J>
struct concat;
template <size_t... I, size_t... J>
struct concat<my_index_sequence<I...>, my_index_sequence<J...> >
: my_index_sequence<I..., (sizeof...(I) + J)...> {};
template <size_t N>
struct make_index_sequence
: concat<typename make_index_sequence<N / 2>::type,
typename make_index_sequence<N - N / 2>::type>::type {};
template <>
struct make_index_sequence<0> : my_index_sequence<> {};
template <>
struct make_index_sequence<1> : my_index_sequence<0> {};
} // namespace my_index_sequence_detail
template <class... A>
using my_index_sequence_for =
typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;
template <class T, size_t... I>
void print_tuple(ostream& s, T const& a, my_index_sequence<I...>) {
using swallow = int[];
(void)swallow{0, (void(s << (I == 0 ? "" : ", ") << get<I>(a)), 0)...};
}
template <class T>
ostream& print_collection(ostream& s, T const& a);
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a);
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a);
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a);
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, multiset<T> const& a) {
return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
return print_collection(s, a);
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
s << '[';
for (auto it = begin(a); it != end(a); ++it) {
s << *it;
if (it != prev(end(a))) s << " ";
}
return s << ']';
}
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a) {
s << '(';
print_tuple(s, a, my_index_sequence_for<A...>{});
return s << ')';
}
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
return s << "(" << get<0>(a) << ", " << get<1>(a) << ")";
}
namespace link_cut {
struct node {
node() {}
node(lli cost_) : cost(cost_) { mcost = cost; }
lli cost;
lli mcost;
node *p = 0, *cs[2] = {0, 0};
bool isroot() const { return !p || (this != p->cs[0] && this != p->cs[1]); }
lli dir() const { return this == p->cs[1]; }
bool flip = 0;
};
void push(node* n) {
if (n->flip) {
swap(n->cs[0], n->cs[1]);
for (lli i = 0; i < (lli)(2); ++i)
if (n->cs[i]) n->cs[i]->flip ^= 1;
n->flip = 0;
}
}
void update(node* n) {
if (n) {
n->mcost = n->cost;
for (lli i = 0; i < (lli)(2); ++i)
if (n->cs[i]) n->mcost = min(n->mcost, n->cs[i]->mcost);
}
}
void rotate(node* n) {
lli d = n->dir();
node *p = n->p, *b = n->cs[1 - d];
if (!p->isroot()) p->p->cs[p->dir()] = n;
n->p = p->p;
n->cs[1 - d] = p;
p->p = n;
p->cs[d] = b;
if (b) b->p = p;
update(n);
update(p);
update(n->p);
}
void splay(node* n) {
push(n);
while (!n->isroot()) {
if (n->p->p) push(n->p->p);
push(n->p);
push(n);
if (n->p->isroot()) {
rotate(n);
} else if (n->dir() == n->p->dir()) {
rotate(n->p);
rotate(n);
} else {
rotate(n);
rotate(n);
}
}
}
node* leftmost(node* n) {
while (n->cs[0]) n = n->cs[0];
return n;
}
void splice(node* x) {
push(x->p);
x->p->cs[1] = x;
update(x->p);
}
void expose(node* x) {
{
node* y = x;
while (y) {
splay(y);
y = y->p;
}
}
{
node* y = x;
while (y->p) {
splice(y);
y = y->p;
}
}
splay(x);
}
void evert(node* n) {
expose(n);
if (n->cs[0]) {
n->cs[0]->flip ^= 1;
n->cs[0] = 0;
update(n);
}
}
void link(node* x, node* y) {
evert(y);
y->p = x;
}
void cut(node* x, node* y) {
evert(x);
expose(y);
y->cs[0] = 0;
x->p = 0;
update(y);
}
node* root(node* n) {
expose(n);
return leftmost(n);
}
lli path(node* x, node* y) {
evert(x);
expose(y);
return min(y->cs[0]->mcost, y->cost);
}
} // namespace link_cut
const lli N = 500000;
link_cut::node A[N];
link_cut::node E[N];
lli F[N];
lli SF[N + 1];
lli R[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
lli n, m;
cin >> n >> m;
vvii G(n);
for (lli i = 0; i < (lli)(m); ++i) {
lli u, v;
cin >> u >> v;
--u;
--v;
G[u].push_back(make_tuple(v, i));
G[v].push_back(make_tuple(u, i));
}
for (lli i = 0; i < (lli)(n); ++i) {
A[i] = link_cut::node(i);
}
vi AC(n);
vi EE(n);
vi C;
function<void(lli, lli)> dfs = [&](lli i, lli p) {
EE[i] = 1;
AC[i] = 1;
C.push_back(i);
for (auto e_ : G[i]) {
lli j, e;
tie(j, e) = e_;
if (j == p) continue;
if (AC[j]) {
set<lli> cc;
lli k = C.size() - 1;
while (1) {
cc.insert(C[k]);
if (C[k] == j) break;
--k;
}
lli u = *cc.begin(), v = *cc.rbegin();
F[v] = max(F[v], u + 1);
}
if (!EE[j]) dfs(j, i);
}
C.pop_back();
AC[i] = 0;
};
for (lli i = 0; i < (lli)(n); ++i)
if (!EE[i]) dfs(i, -1);
for (lli i = 0; i < (lli)(n - 1); ++i) F[i + 1] = max(F[i], F[i + 1]);
for (lli i = 0; i < (lli)(n); ++i) {
R[i] = (i == 0 ? 0 : R[i - 1]);
while (R[i] < n && F[R[i]] <= i) R[i]++;
}
for (lli i = 0; i < (lli)(n); ++i) SF[i + 1] = SF[i] + (i - F[i] + 1);
lli q;
cin >> q;
vi ANS(q);
for (lli i = 0; i < (lli)(q); ++i) {
lli l, r;
cin >> l >> r;
--l;
--r;
lli t = min(r + 1, R[l]);
lli a = 0;
a += ((t - l) * (t - l + 1)) / 2;
if (t <= r) a += (SF[r + 1] - SF[t]);
cout << a << '\n';
}
cout << flush;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sx, sy, k, p[4] = {0, 0, 0, 0}, a, b, i, j = 0;
cin >> n >> sx >> sy;
for (i = 0; i < n; i++) {
cin >> a >> b;
if (a > sx)
p[0]++;
else if (a < sx)
p[1]++;
if (b > sy)
p[2]++;
else if (b < sy)
p[3]++;
}
for (i = 0; i < 4; i++)
if (p[j] <= p[i]) j = i;
cout << p[j] << '\n';
switch (j) {
case 0:
cout << sx + 1 << ' ' << sy;
break;
case 1:
cout << sx - 1 << ' ' << sy;
break;
case 2:
cout << sx << ' ' << sy + 1;
break;
case 3:
cout << sx << ' ' << sy - 1;
break;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int i, j, ind[2000005], lf[2000005], rg[2000005];
vector<long long> a;
vector<pair<int, int> > pr, npr, st, nst;
vector<pair<int, long long> > g[2000005];
long long ans, n, k;
void dfs(int v, long long x = 0, int p = -1) {
a.push_back(x);
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i].first;
if (to == p) continue;
dfs(to, x ^ g[v][i].second, v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cin >> n >> k;
k--;
for (i = 0; i < n - 1; i++) {
int p;
long long w;
cin >> p >> w;
p--;
g[i + 1].push_back({p, w});
g[p].push_back({i + 1, w});
}
dfs(0);
sort(a.begin(), a.end());
st.push_back({0, n - 1});
pr.push_back({0, 0});
for (i = 61; i >= 0; i--) {
nst.clear();
npr.clear();
for (j = 0; j < st.size(); j++) {
int l = st[j].first, r = st[j].second;
ind[j] = r + 1;
for (int k = l; k <= r; k++) {
if (a[k] & (1LL << i)) {
ind[j] = k;
break;
}
}
if (l <= ind[j] - 1) {
lf[j] = nst.size();
nst.push_back({l, ind[j] - 1});
} else
lf[j] = -1;
if (ind[j] <= r) {
rg[j] = nst.size();
nst.push_back({ind[j], r});
} else
rg[j] = -1;
}
long long sum = 0;
for (j = 0; j < pr.size(); j++) {
int a = pr[j].first, b = pr[j].second;
sum += (ind[a] - st[a].first) * 1LL * (ind[b] - st[b].first);
sum += (st[a].second - ind[a] + 1) * 1LL * (st[b].second - ind[b] + 1);
if (sum > n * n) break;
}
if (sum > k) {
for (j = 0; j < pr.size(); j++) {
int a = pr[j].first, b = pr[j].second;
if (lf[a] != -1 && lf[b] != -1) npr.push_back({lf[a], lf[b]});
if (rg[a] != -1 && rg[b] != -1) npr.push_back({rg[a], rg[b]});
}
} else {
k -= sum;
ans |= (1LL << i);
for (j = 0; j < pr.size(); j++) {
int a = pr[j].first, b = pr[j].second;
if (lf[a] != -1 && rg[b] != -1) npr.push_back({lf[a], rg[b]});
if (rg[a] != -1 && lf[b] != -1) npr.push_back({rg[a], lf[b]});
}
}
pr = npr;
st = nst;
}
cout << ans;
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int A[10010], last[10010], ans[10010];
int n;
string s;
int main() {
memset(A, 0, sizeof(A));
int T, i, j, m;
cin >> n;
m = n * (n + 1) / 2;
int sr = sqrt(m);
int ok = 0;
for (i = 2; i <= sr; i++) {
if (m % i == 0) {
ok = 1;
cout << "Yes" << endl << 1 << " " << i << endl;
cout << n - 1 << " ";
for (j = 1; j <= n; j++) {
if (j != i) cout << j << " ";
}
cout << endl;
break;
}
}
if (!ok) cout << "No" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int a[N], cnt = 1, k;
int val;
void go(int l, int r) {
int mid = (l + r) >> 1;
if (r == l) return;
if (r == l + 1) {
a[l] = val--;
return;
}
if (cnt == k) {
for (int i = r - 1; i >= l; i--) a[i] = val--;
return;
}
cnt += 2;
go(l, mid);
go(mid, r);
}
int main() {
int n;
scanf("%d %d", &n, &k);
val = n;
go(0, n);
if (cnt != k) return puts("-1"), 0;
for (int i = 0; i < n; i++) printf("%d ", a[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
int n, m, tot[4];
std::vector<long long> vec[4];
struct node {
long long val;
int cnt1, cnt2;
bool operator<(const struct node &rhs) const { return val < rhs.val; }
} dp[(300010)];
long long pre_dp[(300010)];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
long long w, c;
scanf("%I64d%I64d", &w, &c);
vec[w].push_back(c);
}
for (int i = 1; i <= 3; ++i) {
std::sort(vec[i].begin(), vec[i].end(), std::greater<long long>());
tot[i] = (int)(vec[i].size());
}
dp[0] = (node){0, 0, 0};
for (int i = 0; i < m; ++i) {
long long val = dp[i].val;
int cnt1 = dp[i].cnt1;
int cnt2 = dp[i].cnt2;
if (cnt1 < tot[1] && i + 1 <= m) {
dp[i + 1] =
std::max(dp[i + 1], (node){val + vec[1][cnt1], cnt1 + 1, cnt2});
}
if (cnt2 < tot[2] && i + 2 <= m) {
dp[i + 2] =
std::max(dp[i + 2], (node){val + vec[2][cnt2], cnt1, cnt2 + 1});
}
}
for (int i = 1; i <= m; ++i) {
pre_dp[i] = std::max(pre_dp[i - 1], dp[i].val);
}
long long ans = pre_dp[m], pre = 0;
for (int i = 1; i <= tot[3] && 3 * i <= m; ++i) {
pre += vec[3][i - 1];
ans = std::max(ans, pre + pre_dp[m - 3 * i]);
}
printf("%I64d\n", ans);
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T checkmin(T &a, T b) {
return (a < b) ? a : a = b;
}
template <class T>
inline T checkmax(T &a, T b) {
return (a > b) ? a : a = b;
}
template <class T>
T GCD(T a, T b) {
if (a < 0) return GCD(-a, b);
if (b < 0) return GCD(a, -b);
return (a == 0) ? b : GCD(b % a, a);
}
template <class T>
T LCM(T a, T b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return (a == 0 || b == 0) ? 0 : a / GCD(a, b) * b;
}
template <class T>
inline T sqr(T X) {
return X * X;
}
namespace Poor {
const int MaxiN = 100005;
int N, K;
int A[MaxiN];
void Run() {
scanf("%d%d", &N, &K);
for (int i = 1; i <= N; ++i) {
char Ch = getchar();
while (!isdigit(Ch)) Ch = getchar();
A[i] = Ch - '0';
}
for (int i = 1; i < N && K > 0; ++i) {
if (A[i] == 4 && A[i + 1] == 7) {
if (i % 2 == 1) {
if (i + 2 <= N && A[i + 2] == 7) {
K %= 2;
if (K == 0) break;
}
A[i + 1] = 4;
--K;
} else {
if (i - 1 > 0 && A[i - 1] == 4) {
K %= 2;
if (K == 0) break;
}
A[i] = 7;
--K;
}
}
}
for (int i = 1; i <= N; ++i) printf("%d", A[i]);
puts("");
}
} // namespace Poor
int main() {
Poor::Run();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
string s[30];
cin >> n;
for (i = 0; i < n; i++) {
cin >> s[i];
}
for (i = 0; i < n; i++) {
if (s[i].substr(s[i].length() - 2) == "po") {
cout << "FILIPINO" << endl;
} else if (s[i].substr(s[i].length() - 4) == "desu" ||
s[i].substr(s[i].length() - 4) == "masu") {
cout << "JAPANESE" << endl;
} else if (s[i].substr(s[i].length() - 5) == "mnida") {
cout << "KOREAN" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
const long long MAX = INT_MAX;
const long long inf = 1e18 + 5;
const double pi = 3.14159265358979323846;
long long dirX[] = {1, -1, 0, 0};
long long dirY[] = {0, 0, 1, -1};
using namespace std;
long long n;
pair<int32_t, int32_t> tree[400001][20];
long long power[21];
long long getindex(long long index, long long s, long long e) {
if (s == e) {
return index;
}
long long mid = (s + e) / 2;
return getindex(2 * index + 1, s, mid);
}
void update(long long index, long long s, long long e, long long l, long long r,
long long j) {
if (s > r || e < l) return;
if (s >= l && e <= r) {
tree[index][j].second++;
long long sum = tree[index][j].first;
tree[index][j].first = e - s + 1 - sum;
return;
}
long long mid = (s + e) / 2;
update(2 * index + 1, s, mid, l, r, j);
update(2 * index + 2, mid + 1, e, l, r, j);
tree[index][j].first =
tree[2 * index + 1][j].first + tree[2 * index + 2][j].first;
if (tree[index][j].second & 1) {
long long sum = tree[index][j].first;
tree[index][j].first = e - s + 1 - sum;
}
}
long long query(long long index, long long s, long long e, long long l,
long long r, long long j, long long xors) {
if (s > r || e < l) return 0;
if (s >= l && e <= r) {
long long ans = 0;
if (xors & 1) {
long long sum = e - s + 1 - tree[index][j].first;
ans += (power[j] * sum);
} else {
ans += (power[j] * tree[index][j].first);
}
return ans;
}
long long mid = (s + e) / 2;
long long ans =
query(2 * index + 1, s, mid, l, r, j, xors + tree[index][j].second);
ans +=
query(2 * index + 2, mid + 1, e, l, r, j, xors + tree[index][j].second);
return ans;
}
void buildtree(long long index, long long s, long long e) {
if (s == e) return;
long long mid = (s + e) / 2;
buildtree(2 * index + 1, s, mid);
buildtree(2 * index + 2, mid + 1, e);
for (long long i = 0; i < 20; i++) {
tree[index][i].first =
tree[2 * index + 1][i].first + tree[2 * index + 2][i].first;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
power[0] = 1;
for (long long i = 1; i < 21; i++) {
power[i] = power[i - 1] * 2;
}
cin >> n;
long long size = 1;
while (size < n) size *= 2;
long long treesize = size * 2;
for (long long i = 0; i < treesize; i++) {
for (long long j = 0; j < 20; j++) tree[i][j] = {0, 0};
}
long long index = getindex(0, 0, size - 1);
for (long long i = 0; i < n; i++) {
long long t;
cin >> t;
long long j = 0;
while (t > 0) {
if (t & 1) {
tree[index][j].first = 1;
}
t >>= 1;
j++;
}
index++;
}
buildtree(0, 0, size - 1);
long long t;
cin >> t;
while (t--) {
long long t;
cin >> t;
if (t == 1) {
long long l;
cin >> l;
long long r;
cin >> r;
long long ans = 0;
for (long long j = 0; j < 20; j++) {
long long temp = query(0, 0, size - 1, l - 1, r - 1, j, 0);
ans += temp;
}
cout << ans << "\n";
} else {
long long l;
cin >> l;
long long r;
cin >> r;
long long val;
cin >> val;
long long j = 0;
while (val > 0) {
if (val & 1) {
update(0, 0, size - 1, l - 1, r - 1, j);
}
val >>= 1;
j++;
}
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
template <typename T>
inline void rd(T& x) {
int si = 1;
char c = getchar();
x = 0;
while (!isdigit(c)) si = c == '-' ? -1 : si, c = getchar();
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
x *= si;
}
template <typename T, typename... Args>
inline void rd(T& x, Args&... args) {
rd(x);
rd(args...);
}
const int kN = 4e3 + 5, kInf = 0x3f3f3f3f;
const long long kMod = 998244353, kInfLL = 0x3f3f3f3f3f3f3f3fLL;
int n, k, t[kN];
long long f[15][kN], w[kN], s[kN][kN], ans = 0;
void Calc(int l, int r, int d) {
if (l == r) {
for (int i = 0; i <= t[l]; ++i)
ans = std::max(ans, f[d - 1][k - i] + s[l][i]);
} else {
int mid = (l + r) >> 1;
memcpy(f[d], f[d - 1], sizeof(f[d]));
for (int i = mid + 1; i <= r; ++i)
for (int j = k; j >= t[i]; --j)
f[d][j] = std::max(f[d][j], f[d][j - t[i]] + w[i]);
Calc(l, mid, d + 1);
memcpy(f[d], f[d - 1], sizeof(f[d]));
for (int i = l; i <= mid; ++i)
for (int j = k; j >= t[i]; --j)
f[d][j] = std::max(f[d][j], f[d][j - t[i]] + w[i]);
Calc(mid + 1, r, d + 1);
}
}
int main() {
int T = 1;
while (T--) {
rd(n, k);
for (int i = 1; i <= n; ++i) {
rd(t[i]);
for (int j = 1; j <= t[i]; ++j) {
int x;
rd(x);
if (j <= k) s[i][j] = s[i][j - 1] + x;
}
t[i] = std::min(t[i], k);
w[i] = s[i][t[i]];
}
Calc(1, n, 1);
printf("%lld\n", ans);
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
int a, b, n, l, h;
set<int> st;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
string f, l;
cin >> f >> l;
cout << f[0];
for (int i = 1; i < f.length(); ++i) {
if (f[i] >= l[0])
break;
else
cout << f[i];
}
cout << l[0];
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int fin = 0, maxn = 6001, maxm = maxn * (maxn - 1) / 2 + 10;
int n;
bool flag[maxm];
int p[maxm / 3], c[maxn];
void pre(int n) {
int i, j;
for (i = 2; i <= n; ++i) {
if (!flag[i]) p[++p[0]] = i;
for (j = 1; j <= p[0] && i * p[j] <= n; ++j)
if (flag[i * p[j]] = 1, i % p[j] == 0) break;
}
}
int main() {
if (fin) {
freopen("t.in", "r", stdin);
freopen("t.out", "w", stdout);
}
int s, x, i;
scanf("%d", &n);
if (n == 2) return puts("1 1"), 0;
pre(s = n * (n + 1) / 2);
if (s & 1) {
if (!flag[s - 2]) {
for (i = 1; i <= n; ++i) printf("%d ", i == 2 ? 2 : 1);
return 0;
}
s -= 3, c[3] = 3;
}
for (x = 2; flag[x] || flag[s - x]; ++x)
;
for (i = n; i; --i)
if (!c[i])
if (i <= x)
c[i] = 1, x -= i;
else
c[i] = 2;
for (i = 1; i <= n; ++i) printf("%d ", c[i]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
bool dp[110][350][60][2];
string second;
int n, ans = -(1 << 29);
char opp(char ch) {
if (ch == 'F') return 'T';
return 'F';
}
void Calc(int cur, int pos, int nn, int dir) {
if (cur == second.size()) {
if (n == nn) {
ans = max(ans, abs(pos - 150));
return;
} else
return;
}
bool &ans = dp[cur][pos][nn][dir];
if (ans) return;
ans = true;
for (int i = 0; i + nn <= n; ++i) {
char ch = second[cur];
if (i & 1) ch = opp(ch);
if (ch == 'T')
Calc(cur + 1, pos, i + nn, !dir);
else
Calc(cur + 1, pos + ((dir == 1) ? 1 : -1), i + nn, dir);
}
}
int main() {
getline(cin, second);
cin >> n;
memset(dp, 0, sizeof(dp));
Calc(0, 150, 0, 1);
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, t1, t2;
long long a[200005], b[200005], c[200005], s1, s2;
bool fst() {
if (s1 != s2) return s1 > s2;
for (int i = 0; i < min(t1, t2); i++) {
if (a[i] > b[i]) return 1;
if (a[i] < b[i]) return 0;
}
if (t1 != t2) return t1 > t2;
return c[n - 1] > 0;
}
int main() {
long long tmp;
scanf("%d", &n);
t1 = t2 = 0;
s1 = s2 = 0;
for (int i = 0; i < n; i++) {
scanf("%I64d", c + i);
if (c[i] > 0) {
a[t1++] = c[i];
s1 += c[i];
} else {
tmp = -c[i];
b[t2++] = tmp;
s2 += tmp;
}
}
if (fst())
printf("first\n");
else
printf("second\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[100001], b[100001];
long long n, m;
long long f(long long x) {
long long result = 0;
for (long long i = 0; i < n; i++) {
if (x > a[i]) result += x - a[i];
}
for (long long i = 0; i < m; i++)
if (x < b[i]) result += b[i] - x;
return result;
}
void ternarySearch() {
long long l = 1, r = 1000000000;
while (r - l > 5) {
long long mid1 = l + (r - l) / 3;
long long mid2 = r - (r - l) / 3;
if (f(mid1) < f(mid2))
r = mid2;
else
l = mid1;
}
long long minn = f(l);
for (long long j = l; j <= r; j++)
if (minn > f(j)) minn = f(j);
cout << minn;
cout << endl;
}
int main() {
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < m; i++) {
cin >> b[i];
}
ternarySearch();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
unsigned int n, a, b, c, d;
inline unsigned int f(unsigned int x) { return ((a * x + b) * x + c) * x + d; }
inline unsigned int geta(unsigned int x) {
unsigned int ans = 0, p = x;
const unsigned int lim = n / p;
while (p <= n) {
ans += n / p;
if (p > lim) break;
p *= x;
}
return ans;
}
const int N = 17330;
int mark[N];
int p[N], sz;
void sieve(unsigned int L, unsigned int R) {
memset(mark, 0, sizeof mark);
for (int i = 0; i < sz; i++) {
for (unsigned int j = (L + p[i] - 1) / p[i] * p[i]; j <= R; j += p[i])
mark[j - L] = 1;
}
}
int main() {
scanf("%u %u %u %u %u", &n, &a, &b, &c, &d);
unsigned int ans = 0;
for (int i = 2; i < N; i++)
if (!mark[i]) {
p[sz++] = i;
ans += f(i) * geta(i);
for (int j = i + i; j < N; j += i) mark[j] = 1;
}
for (unsigned int i = N; i < n; i += N) {
sieve(i, i + N - 1);
for (unsigned int j = 0; j < N; j++)
if (!mark[j]) ans += f(j + i) * geta(j + i);
}
printf("%u\n", ans);
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using dl = double;
const int N = 2e5 + 10;
ll aarray[200000 + 10];
ll magic[101][101];
vector<ll> primes;
bool prime[1000001];
int main() {
ios_base::sync_with_stdio(false);
string str;
ll i, j, n, m, k, t, l, r, p1, p2, p3;
cin >> str;
cin >> t;
while (t--) {
cin >> l >> r >> k;
l--;
r--;
string ans;
ll len = r - l + 1;
k %= len;
p1 = r - k + 1;
for (j = 0; j < l; j++) ans += str[j];
ans += str.substr(p1, k);
ans += str.substr(l, p1 - l);
ans += str.substr(r + 1, str.length() - ans.length());
str = ans;
}
cout << str << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
fast();
long long n, m;
cin >> n >> m;
long long sum = 0;
for (long long i = 0; i < m; i++) {
long long x, d;
cin >> x >> d;
sum += x * n;
if (d >= 0) {
long long temp = (n - 1) * n * d;
temp /= 2;
sum += temp;
} else {
long long temp = n / 2;
if (n % 2 == 0) temp--;
long long val = temp * (temp + 1);
if (n % 2 == 0) val += 1 + temp;
sum += d * (val);
}
}
double ans = sum / (n * 1.0);
cout << fixed << setprecision(6) << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, h, m;
cin >> n >> h >> m;
int l, r, x;
vector<int> v;
v.assign(n, h * h);
while (m--) {
cin >> l >> r >> x;
for (int i = l - 1; i < r; ++i) {
v[i] = min(v[i], x * x);
}
}
int ans = 0;
for (int i = 0; i < n; ++i) ans += v[i];
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1.01e9;
const int N = 1 << 18;
int main() {
int n;
while (scanf("%d", &n) == 1) {
vector<int> a(n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a.begin(), a.end());
printf("%d\n", max(0, a[n - 1] - 25));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
inline int read() {
char c = getchar();
int x = 0;
bool sgn = false;
while (c < '0' || c > '9') {
if (c == '-') {
sgn = true;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
return sgn ? -x : x;
}
const int maxN = 200005;
int n, val[maxN], a[maxN], b[maxN], c[maxN], t[maxN];
long long f[maxN], g[maxN];
std::vector<int> ans;
bool vis[maxN][2];
struct List {
int tot, fst[maxN], nxt[maxN << 1], to[maxN << 1];
List() { memset(fst, -1, sizeof(fst)); }
inline void insert(int u, int v) {
nxt[tot] = fst[u];
to[tot] = v;
fst[u] = tot++;
}
inline void link(int u, int v) {
insert(u, v);
insert(v, u);
}
} e;
void dfs(int u, int fa) {
g[u] = 1e18;
bool isLeaf = true;
for (int i = e.fst[u], v; ~i; i = e.nxt[i]) {
v = e.to[i];
if (v != fa) {
dfs(v, u);
f[u] += f[v];
isLeaf = false;
}
}
for (int i = e.fst[u], v; ~i; i = e.nxt[i]) {
v = e.to[i];
if (v != fa) {
if (g[u] > f[u] - f[v] + g[v]) {
g[u] = f[u] - f[v] + g[v];
b[v] = ++c[u];
t[u] = 1;
} else if (g[u] == f[u] - f[v] + g[v]) {
b[v] = c[u];
t[u]++;
}
}
}
if (isLeaf) {
a[u] = u;
f[u] = val[u];
g[u] = 0;
} else {
if (f[u] > g[u] + val[u]) {
f[u] = g[u] + val[u];
a[u] = u;
} else if (f[u] == g[u] + val[u]) {
a[u] = -1;
}
}
}
void getAns(int u, int fa, int x) {
if (vis[u][x]) {
return;
}
vis[u][x] = true;
if (x == 0) {
if (a[u] != 0) {
ans.push_back(u);
getAns(u, fa, 1);
}
if (a[u] <= 0) {
for (int i = e.fst[u], v; ~i; i = e.nxt[i]) {
v = e.to[i];
if (v != fa) {
getAns(v, u, 0);
}
}
}
} else {
for (int i = e.fst[u], v; ~i; i = e.nxt[i]) {
v = e.to[i];
if (v != fa) {
if (t[u] == 1) {
getAns(v, u, b[v] == c[u]);
} else {
if (b[v] == c[u]) {
getAns(v, u, 1);
}
getAns(v, u, 0);
}
}
}
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
val[i] = read();
}
for (int i = 2; i <= n; i++) {
e.link(read(), read());
}
dfs(1, 0);
getAns(1, 1, 0);
printf("%I64d %d\n", f[1], (int)ans.size());
std::sort(ans.begin(), ans.end());
for (std::vector<int>::iterator it = ans.begin(); it != ans.end(); it++) {
printf("%d ", *it);
}
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 519;
int a[MAX_N], b[MAX_N], last[2 * MAX_N], d[MAX_N][MAX_N];
pair<int, int> pr[MAX_N][MAX_N];
set<int> s;
map<int, int> ma;
vector<int> numbers;
int main() {
int n, m;
scanf("%d", &n);
for (int i = 0; (i) < (n); ++i) scanf("%d", &a[i]), s.insert(a[i]);
scanf("%d", &m);
for (int i = 0; (i) < (m); ++i) scanf("%d", &b[i]), s.insert(b[i]);
int it = 0;
for (auto k : s) ma[k] = it++, numbers.push_back(k);
for (int i = 0; (i) < (n); ++i) a[i] = ma[a[i]];
for (int i = 0; (i) < (m); ++i) b[i] = ma[b[i]];
for (int i = 0; (i) < (n); ++i) {
for (int j = 0; (j) < ((n + m)); ++j) last[j] = -1;
for (int j = 0; (j) < (m); ++j) {
last[b[j]] = j;
if (a[i] != b[j]) continue;
d[i][j] = 1;
pr[i][j] = make_pair(-1, -1);
for (int g = 0; (g) < (i); ++g)
if (a[g] < a[i] && last[a[g]] != -1) {
if (d[i][j] < d[g][last[a[g]]] + 1) {
d[i][j] = d[g][last[a[g]]] + 1;
pr[i][j] = make_pair(g, last[a[g]]);
}
}
}
}
int x = 0, y = 0, maxx = 0;
for (int i = 0; (i) < (n); ++i)
for (int j = 0; (j) < (m); ++j)
if (d[i][j] > maxx) maxx = d[i][j], x = i, y = j;
printf("%d\n", d[x][y]);
if (d[x][y] == 0) return 0;
vector<int> v;
while (x >= 0 && y >= 0) {
v.push_back(a[x]);
int x2 = pr[x][y].first;
y = pr[x][y].second;
x = x2;
}
reverse((v).begin(), (v).end());
for (int k : v) printf("%d ", numbers[k]);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
namespace RenaMoe {
template <typename T>
inline void read(T &x) {
x = 0;
bool f = false;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
if (f) x = -x;
}
const int N = 1e6 + 9;
struct Ask {
char opt;
int x, y;
};
struct BitTree {
long long sum[N];
inline void update(int x, long long k) {
for (int i = x; i < N; i += i & -i) sum[i] += k;
}
inline long long query(int x) {
long long res = 0;
for (int i = x; i; i -= i & -i) res += sum[i];
return res;
}
inline int bound(int x) {
long long s = query(x);
x = 0;
for (int i = 1 << 19; i; i >>= 1) {
if (x + i < N && sum[x + i] < s) {
x += i;
s -= sum[x];
}
}
return x;
}
} T;
struct Graph {
int tot;
int ls[N], rs[N], fa[N], size[N], id[N];
inline void init(int n) {
tot = n;
for (int i = 1; i <= n * 2; ++i) size[i] = 1, id[i] = i;
}
inline void link(int x, int y) {
++tot;
fa[id[x]] = fa[id[y]] = tot;
ls[tot] = id[x], rs[tot] = id[y];
size[tot] = size[id[x]] + size[id[y]];
id[x] = tot;
}
} G1, G2;
int n, m;
long long ans[N];
Ask q[N];
vector<int> add[N], clr[N], qry[N];
void dfs1(int u) {
for (int i = 0; i < clr[u].size(); ++i) {
int j = clr[u][i];
T.update(j, 1);
}
if (u <= n) {
for (int i = 0; i < qry[u].size(); ++i) {
int j = qry[u][i];
q[j].y = T.bound(j);
}
} else
dfs1(G1.ls[u]), dfs1(G1.rs[u]);
for (int i = 0; i < clr[u].size(); ++i) {
int j = clr[u][i];
T.update(j, -1);
}
}
void dfs2(int u) {
for (int i = 0; i < add[u].size(); ++i) {
int j = add[u][i];
T.update(j, G2.size[u]);
}
if (u <= n) {
for (int i = 0; i < qry[u].size(); ++i) {
int j = qry[u][i];
ans[j] = T.query(j) - T.query(q[j].y);
}
} else
dfs2(G2.ls[u]), dfs2(G2.rs[u]);
for (int i = 0; i < add[u].size(); ++i) {
int j = add[u][i];
T.update(j, -G2.size[u]);
}
}
inline void main() {
read(n), read(m);
char str[3];
for (int i = 1; i <= m; ++i) {
scanf("%s", str);
q[i].opt = str[0];
read(q[i].x);
if (q[i].opt == 'U' || q[i].opt == 'M') read(q[i].y);
}
G1.init(n), G2.init(n);
for (int i = 1; i <= m; ++i) {
if (q[i].opt == 'M') {
G1.link(q[i].x, q[i].y);
} else if (q[i].opt == 'Z') {
int x = G1.id[q[i].x];
clr[x].push_back(i);
} else if (q[i].opt == 'U') {
G2.link(q[i].x, q[i].y);
} else if (q[i].opt == 'A') {
int x = G2.id[q[i].x];
add[x].push_back(i);
} else if (q[i].opt == 'Q') {
qry[q[i].x].push_back(i);
}
}
for (int i = 1; i <= G1.tot; ++i) {
if (!G1.fa[i]) dfs1(i);
}
for (int i = 1; i <= G2.tot; ++i) {
if (!G2.fa[i]) dfs2(i);
}
for (int i = 1; i <= m; ++i) {
if (q[i].opt == 'Q') printf("%lld\n", ans[i]);
}
}
} // namespace RenaMoe
int main() {
RenaMoe::main();
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int cur = m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x < cur) {
cur -= x;
cout << "0 ";
} else {
int ans = 1;
x -= cur;
ans += x / m;
cur = m - (x % m);
cout << ans << " ";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
;
double nr1;
cin >> nr1;
double r1, fr1 = 0;
for (double i = 0; i < nr1; i++) {
cin >> r1;
fr1 = (max(fr1, r1));
}
double nden1;
cin >> nden1;
double den1, fden1 = 0;
for (double i = 0; i < nden1; i++) {
cin >> den1;
fden1 = max(fden1, den1);
}
double nden2;
cin >> nden2;
double den2, fden2 = 111313131;
for (double i = 0; i < nden2; i++) {
cin >> den2;
fden2 = min(fden2, den2);
}
double r2 = 0.0;
double a, b;
cin >> a >> b;
cout.precision(10);
r2 = (sqrt((fden1 * fr1 * fr1 * b) / ((fden1 * b) + (fden2 * a))));
cout << r2;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace suffix_automaton_array {
std::vector<int> len, link, pos;
std::vector<std::vector<int> > child;
const int alpha = 26, start_char = 'A';
int init() {
len.clear();
link.clear();
child.clear();
pos.clear();
len.push_back(0);
pos.push_back(-1);
link.push_back(-1);
child.push_back(std::vector<int>(alpha, -1));
return 0;
}
void add(int c, int &last, int z) {
int cur = len.size();
len.push_back(len[last] + 1);
link.push_back(-1);
pos.push_back(z);
child.push_back(std::vector<int>(alpha, -1));
int p = last;
while (p != -1 && child[p][c] == -1) {
child[p][c] = cur;
p = link[p];
}
if (p == -1) {
link[cur] = 0;
} else {
int q = child[p][c];
if (len[p] + 1 == len[q]) {
link[cur] = q;
} else {
int clone = len.size();
len.push_back(len[p] + 1);
pos.push_back(pos[q]);
link.push_back(link[q]);
child.push_back(child[q]);
while (p != -1 && child[p][c] == q) {
child[p][c] = clone;
p = link[p];
}
link[cur] = link[q] = clone;
}
}
last = cur;
}
void make(std::string s) {
int last = init();
for (int i = 0; i < int(s.size()); i++) {
add(s[i] - start_char, last, i);
}
}
} // namespace suffix_automaton_array
using namespace suffix_automaton_array;
int main() {
std::ios_base::sync_with_stdio(false);
string p;
cin >> p;
make(p);
int n;
cin >> n;
vector<string> s(n);
for (auto &first : (s)) {
cin >> first;
}
vector<vector<int> > C(n);
for (int i = 0; i < int(n); i++) {
C[i] = vector<int>(int((s[i]).size()), int((p).size()));
for (int j = 0, u = 0; j < int((s[i]).size()); j++) {
u = child[u][s[i][j] - 'A'];
if (u == -1) {
break;
}
C[i][j] = pos[u];
}
}
reverse((p).begin(), (p).end());
make(p);
int ans = 0;
for (int i = 0; i < int(n); i++) {
for (int j = int((s[i]).size()) - 1, u = 0; j > 0; j--) {
u = child[u][s[i][j] - 'A'];
if (u == -1) {
break;
}
if (C[i][j - 1] < int((p).size()) - pos[u] - 1) {
ans++;
break;
}
}
}
cout << ans;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
cin >> x;
cout << 1 + x * (x + 1) * 3 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ansx, ansy;
int n, er;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
if (n % 4 == 1 || n % 4 == 0) {
cout << "YES"
<< "\n";
er = n % 4;
if (n % 4) n--;
for (int i = 1; i <= n; i += 4) {
int a = i;
int b = i + 1;
int c = i + 2;
int d = i + 3;
for (int i = d + 1; i <= n; i++) ansx.push_back(a), ansy.push_back(i);
ansx.push_back(a), ansy.push_back(b);
for (int i = n; i > d; i--) ansx.push_back(b), ansy.push_back(i);
for (int i = d + 1; i <= n; i++) ansx.push_back(c), ansy.push_back(i);
ansx.push_back(c), ansy.push_back(d);
for (int i = n; i > d; i--) ansx.push_back(d), ansy.push_back(i);
ansx.push_back(a), ansy.push_back(d);
ansx.push_back(b), ansy.push_back(c);
ansx.push_back(a), ansy.push_back(c);
ansx.push_back(b), ansy.push_back(d);
}
for (int i = 0; i < ansx.size(); i++) {
if (er && ansy[i] - ansx[i] == 1 && ansy[i] % 2 == 0)
cout << ansx[i] << " " << n + 1 << "\n";
cout << ansx[i] << " " << ansy[i] << "\n";
if (er && ansy[i] - ansx[i] == 1 && ansy[i] % 2 == 0)
cout << ansy[i] << " " << n + 1 << "\n";
}
} else {
cout << "NO"
<< "\n";
}
}
| 23 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
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...);
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<vector<pair<int, int>>> arr(n, vector<pair<int, int>>(n));
vector<vector<char>> res(n, vector<char>(n, '@'));
stack<pair<int, int>> exes;
int a, b;
for (int i = 0; i < (n); i++) {
for (int j = 0; j < (n); j++) {
cin >> a >> b;
if (a > 0) a--;
if (b > 0) b--;
if (a == i and b == j) {
res[i][j] = 'X';
exes.push({i, j});
}
arr[i][j] = {a, b};
}
}
function<void(int, int, pair<int, int>)> flood = [&](int i, int j,
pair<int, int> p) {
if (i + 1 < n and arr[i + 1][j] == p and res[i + 1][j] == '@') {
res[i + 1][j] = 'U';
flood(i + 1, j, p);
}
if (i - 1 >= 0 and arr[i - 1][j] == p and res[i - 1][j] == '@') {
res[i - 1][j] = 'D';
flood(i - 1, j, p);
}
if (j + 1 < n and arr[i][j + 1] == p and res[i][j + 1] == '@') {
res[i][j + 1] = 'L';
flood(i, j + 1, p);
}
if (j - 1 >= 0 and arr[i][j - 1] == p and res[i][j - 1] == '@') {
res[i][j - 1] = 'R';
flood(i, j - 1, p);
}
};
while (!exes.empty()) {
pair<int, int> p = exes.top();
exes.pop();
int i = p.first, j = p.second;
flood(i, j, p);
}
function<void(int, int)> fn2 = [&](int i, int j) {
if (i + 1 < n and arr[i + 1][j] == make_pair(-1, -1)) {
res[i][j] = 'D';
} else if (i - 1 >= 0 and arr[i - 1][j] == make_pair(-1, -1)) {
res[i][j] = 'U';
} else if (j + 1 < n and arr[i][j + 1] == make_pair(-1, -1)) {
res[i][j] = 'R';
} else if (j - 1 >= 0 and arr[i][j - 1] == make_pair(-1, -1)) {
res[i][j] = 'L';
}
};
bool gud = true;
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) {
if (arr[i][j] == make_pair(-1, -1)) {
fn2(i, j);
}
}
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) {
if (res[i][j] == '@') {
gud = false;
break;
}
}
if (not gud) {
cout << "INVALID\n";
return 0;
}
cout << "VALID\n";
for (int i = 0; i < (n); i++) {
for (int j = 0; j < (n); j++) cout << res[i][j];
cout << "\n";
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int m = 0, mask[11], cnt[6][6], N;
vector<pair<int, int> > cards;
int next_mask() {
m++;
for (int i = int(0); i <= int(9); i++) mask[i + 1] = (m >> i) & 1;
return m != (1 << 10);
}
int okay() {
pair<int, int> a[N];
for (int i = int(0); i <= int(N - 1); i++) {
a[i] = pair<int, int>(0, 0);
if (mask[cards[i].first]) {
a[i].first = cards[i].first;
}
if (mask[5 + cards[i].second]) {
a[i].second = cards[i].second;
}
}
for (int i = int(0); i <= int(N - 1); i++)
for (int j = int(0); j <= int(N - 1); j++)
if (i != j)
if (a[i] == a[j]) {
return 0;
}
return 1;
}
int main() {
int number;
cin >> number;
char c;
int x;
for (int i = int(1); i <= int(number); i++) {
cin >> c >> x;
if (c == 'R') cnt[1][x] = 1;
if (c == 'G') cnt[2][x] = 1;
if (c == 'B') cnt[3][x] = 1;
if (c == 'Y') cnt[4][x] = 1;
if (c == 'W') cnt[5][x] = 1;
}
for (int i = int(1); i <= int(5); i++)
for (int j = int(1); j <= int(5); j++)
if (cnt[i][j]) cards.push_back(pair<int, int>(i, j));
N = cards.size();
int ans = 2000000000;
m = 0;
do {
if (okay()) {
int x = 0;
for (int i = int(1); i <= int(10); i++)
if (mask[i]) x++;
ans = min(ans, x);
}
} while (next_mask());
cout << ans << endl;
cards.clear();
for (int i = int(0); i <= int(5); i++)
for (int j = int(0); j <= int(5); j++) cnt[i][j] = 0;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200100], is[200100];
int main() {
int i, j, k, Ans = 0;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
j = n / 2 + 1;
for (i = 1; i <= n / 2; i++) {
while (j < n && a[j] - a[i] < m) j++;
if (a[j] - a[i] >= m) Ans++, j++;
}
cout << Ans;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long int powe(long long int a, long long int b) {
long long int ans = 1;
for (; b; b >>= 1) {
if (b & 1) ans = ans * a;
a = a * a;
}
return ans;
}
class Comp {
public:
bool operator()(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if (a.first < b.first || (a.first == b.first && a.second > b.second)) {
return true;
}
return false;
}
};
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n, 0);
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int>>, Comp>
vp;
vp.push({n, 0});
long long int ind = 0, indd = n - 1;
long long int mid, cur = 1;
while (!vp.empty()) {
pair<long long int, long long int> p = vp.top();
vp.pop();
ind = p.second;
indd = ind + p.first - 1;
long long int len = indd - ind + 1;
long long int pp = indd - ind + 1;
if (pp & 1)
mid = (ind + indd) / 2;
else {
mid = (ind + indd - 1) / 2;
}
a[mid] = cur++;
if ((indd - mid) > 0) vp.push({(indd - mid), mid + 1});
if (mid - ind > 0) {
vp.push({(mid - ind), ind});
}
}
for (long long int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
string s[n];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
char ch;
cin >> ch;
s[i].push_back(ch);
}
}
for (int i = 0; i < n; ++i) {
int c = 0;
for (int j = 0; j < n; ++j) {
if (s[i][j] == 'C') ++c;
}
if (c > 1) {
c--;
while (c) {
ans += c;
c--;
}
}
}
for (int i = 0; i < n; ++i) {
int c = 0;
for (int j = 0; j < n; ++j) {
if (s[j][i] == 'C') ++c;
}
if (c > 1) {
c--;
while (c) {
ans += c;
c--;
}
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <class T>
T abs(T &x) {
return (x >= 0) ? (x) : (-x);
}
template <class T>
T sqr(T &x) {
return (x) * (x);
}
template <class T>
T min(T &a, T &b) {
return (a < b) ? (a) : (b);
}
template <class T>
T max(T &a, T &b) {
return (a > b) ? (a) : (b);
}
int rev(int a) {
int res = 0;
for (int i = 0; i < 8; i++)
if (a & (1 << i)) res |= 1 << (8 - i - 1);
return res;
}
int main() {
string s;
getline(cin, s);
s = char(0) + s;
vector<int> v;
int n = ((int)((s).size()));
int x = s[n - 1];
for (int i = n - 1; i >= 1; i--) {
x = rev(x);
int ans = (rev(int(s[i - 1])) - x + 256) % 256;
v.push_back(ans);
x = (x + ans) % 256;
x = rev(x);
}
for (int i = ((int)((v).size())) - 1; i >= 0; i--) cout << v[i] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double coo[70000], v[70000];
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> coo[i];
}
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int bb = 60;
double lo = 0, mid = 0.0, hi = 1000000000;
double ans = 0.0;
while (bb--) {
mid = (lo + hi) / 2;
double mx = -1e9;
double mn = 1e9;
for (int i = 0; i < n; i++) {
mn = min(mn, coo[i] + v[i] * mid);
mx = max(mx, coo[i] - v[i] * mid);
}
if (mn <= mx) {
ans = mid;
lo = mid;
} else
hi = mid;
}
printf("%7lf", ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int fact[1000050];
int main() {
ios::sync_with_stdio(false);
fact[0] = 1;
for (int i = 1; i < 1000050; i++)
fact[i] = (fact[i - 1] * 1ll * i) % 1000000007;
int n, m;
cin >> n >> m;
vector<vector<int> > pokemonIin(m);
for (int i = 0; i < n; i++) {
int cnt;
cin >> cnt;
for (int j = 0; j < cnt; j++) {
int x;
cin >> x;
x--;
pokemonIin[x].push_back(i);
}
}
for (int i = 0; i < m; i++) sort(pokemonIin[i].begin(), pokemonIin[i].end());
sort(pokemonIin.begin(), pokemonIin.end());
long long int ans = 1;
int cur = 1;
for (int i = 1; i < m; i++) {
if (pokemonIin[i] == pokemonIin[i - 1]) {
cur++;
} else {
ans = ((fact[cur] * 1ll * ans) % 1000000007);
cur = 1;
}
}
ans = ((fact[cur] * 1ll * ans) % 1000000007);
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string a, b;
int v[200010];
bool subsir(int k) {
string ac = a;
for (int i = 0; i < k; ++i) {
ac[v[i] - 1] = '*';
}
int r, poz = 0;
for (int i = 0; i < b.length(); ++i) {
r = ac.find(b[i], poz);
if (r == -1) {
return false;
}
poz = r + 1;
}
return true;
}
int cautb(long long n) {
int pas = 1 << 30, r = -1;
while (pas != 0) {
if (r + pas <= n && subsir(r + pas)) {
r += pas;
}
pas /= 2;
}
return r;
}
int main() {
cin >> a >> b;
for (int i = 0; i < a.length(); ++i) {
cin >> v[i];
}
cout << cautb(a.length());
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> girls;
vector<int> pizza;
vector<int> taxi;
vector<string> v;
while (n--) {
int k;
string s, t;
cin >> k >> s;
int p = 0, ta = 0, g = 0;
for (int f = 0; f < k; f++) {
cin >> t;
if (t[0] > t[1] && t[1] > t[3] && t[3] > t[4] && t[4] > t[6] &&
t[6] > t[7])
p++;
else if (t[0] == t[1] && t[1] == t[3] && t[3] == t[4] && t[4] == t[6] &&
t[6] == t[7])
ta++;
else
g++;
}
v.push_back(s);
pizza.push_back(p);
taxi.push_back(ta);
girls.push_back(g);
}
int maxi = -1;
cout << "If you want to call a taxi, you should call: ";
bool first = 1;
for (int f = 0; f < v.size(); f++) {
maxi = max(maxi, taxi[f]);
}
for (int f = 0; f < v.size(); f++) {
if (taxi[f] == maxi) {
if (first)
cout << v[f];
else
cout << ", " << v[f];
first = false;
}
}
cout << "." << endl;
maxi = -1;
first = 1;
cout << "If you want to order a pizza, you should call: ";
for (int f = 0; f < v.size(); f++) {
maxi = max(maxi, pizza[f]);
}
for (int f = 0; f < v.size(); f++) {
if (pizza[f] == maxi) {
if (first)
cout << v[f];
else
cout << ", " << v[f];
first = false;
}
}
cout << "." << endl;
maxi = -1;
first = 1;
cout
<< "If you want to go to a cafe with a wonderful girl, you should call: ";
for (int f = 0; f < v.size(); f++) {
maxi = max(maxi, girls[f]);
}
for (int f = 0; f < v.size(); f++) {
if (girls[f] == maxi) {
if (first)
cout << v[f];
else
cout << ", " << v[f];
first = false;
}
}
cout << "." << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, a, b;
scanf("%d %d %d %d", &x, &y, &a, &b);
if (x <= a && y <= b || x + y <= max(a, b)) {
printf("Polycarp\n");
} else {
printf("Vasiliy\n");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
printf("%d\n", n * (n + 1ll) % 4 == 0 ? 0 : 1);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
long long f[MAXN][2], dat[MAXN];
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x;
}
int main() {
ios::sync_with_stdio(false);
long long n = read(), r1 = read(), r2 = read(), r3 = read(), d = read();
for (int i = 1; i <= n; i++) dat[i] = read();
f[1][0] = dat[1] * r1 + r3, f[1][1] = min(r2, dat[1] * r1 + r1);
for (int i = 2; i <= n; i++) {
f[i][0] =
min(f[i - 1][0] + d + dat[i] * r1 + r3,
f[i - 1][1] + d + r1 + d + min(dat[i] * r1 + r1, r2) + r1 + d);
f[i][1] = min(f[i - 1][0] + d + min(r2, dat[i] * r1 + r1),
f[i - 1][1] + d + min(dat[i] * r1 + r1, r2) + d + r1 + d);
}
cout << min(f[n][0], f[n - 1][1] + d + dat[n] * r1 + r3 + d + r1) << endl;
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (; t--;) {
int n, x, k, c, y = 0;
cin >> n >> x;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
vector<int> v1;
for (int i = 0; i < n; i++) {
int j;
if (i == 0) {
v1.push_back(v[i]);
j = v[i];
} else if (v[i] != j) {
v1.push_back(v[i]);
j = v[i];
}
}
for (k = 1, c = 0; x >= 0; k++, c++) {
if (binary_search(v1.begin(), v1.end(), k)) {
y++;
} else {
x--;
if (x < 0) break;
}
}
cout << k - 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
long long a, b, c, d;
scanf("%lld%lld", &a, &b);
for (c = 1; c <= b; c++) {
if (a % c != c - 1) {
printf("No\n");
return 0;
}
}
printf("Yes\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[505000], ans;
multiset<long long> s;
signed main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= n; i++) {
if (!s.empty() && *s.begin() < a[i]) {
ans += a[i] - *s.begin();
s.erase(s.begin());
s.insert(a[i]);
s.insert(a[i]);
} else {
s.insert(a[i]);
}
}
cout << ans;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long n, cnt = 1, ans, a[200005], b[200005];
signed main() {
cin >> n;
while (n--) {
long long c, x, y;
cin >> c;
if (c == 1) {
cin >> x >> y;
a[x] += y;
ans += x * y;
}
if (c == 2) {
cin >> x;
b[++cnt] = x;
ans += x;
}
if (c == 3) {
a[cnt - 1] += a[cnt];
ans -= a[cnt];
a[cnt] = 0;
ans -= b[cnt];
b[cnt] = 0;
cnt--;
}
printf("%.6lf\n", ans * 1.0 / cnt);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400;
int n, v, e;
long long sum = 0;
int a[N + 1], s[N + 1], fa[N + 1], b[N + 1];
vector<int> nei[N + 1];
int getFather(int i) {
if (fa[i] == -1) return i;
return fa[i] = getFather(fa[i]);
}
bool vis[N + 1];
bool mark[N + 1];
int currentVo;
vector<pair<int, pair<int, int> > > ans;
void check(int cur, int p, int &x) {
x = abs(currentVo);
if (currentVo < 0) currentVo = min(0, currentVo + a[cur]);
if (currentVo > 0) currentVo = max(currentVo - (v - a[cur]), 0);
if (currentVo) x = -1;
return;
}
bool isg = false;
void dfs2(int cur, int p) {
int x = 0;
if (!currentVo) return;
if (cur != p) check(cur, p, x);
for (int ne : nei[cur])
if (ne != p && !mark[ne]) dfs2(ne, cur);
if (cur == p) return;
if (isg) {
if (x == -1) x = min(v - a[cur], a[p]);
a[cur] += x;
a[p] -= x;
ans.push_back(make_pair(x, make_pair(p, cur)));
} else {
if (x == -1) x = min(v - a[p], a[cur]);
a[cur] -= x;
a[p] += x;
ans.push_back(make_pair(x, make_pair(cur, p)));
}
return;
}
void dfs(int cur, int p) {
sum += s[cur];
vis[cur] = true;
for (int ne : nei[cur])
if (ne != p) dfs(ne, cur);
mark[cur] = true;
currentVo = a[cur] - b[cur];
isg = (currentVo > 0);
if (currentVo) dfs2(cur, cur);
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> v >> e;
fill(fa, fa + N + 1, -1);
for (int i = 0; i < n; i++) cin >> a[i];
for (int j = 0; j < n; j++) cin >> b[j], s[j] = a[j] - b[j];
for (int i = 0; i < e; i++) {
int u, v;
cin >> u >> v;
u--, v--;
int f = getFather(u);
int ff = getFather(v);
if (ff != f) {
fa[ff] = f;
nei[v].push_back(u);
nei[u].push_back(v);
}
}
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
sum = 0;
dfs(i, i);
if (sum != 0) return cout << "NO", 0;
}
cout << (int)ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].second.first + 1 << ' ' << ans[i].second.second + 1 << ' '
<< ans[i].first << endl;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int cnt = 0;
cin >> n;
string s;
char c;
while (n != 0) {
s = to_string(n);
c = s[0];
for (int i = 0; i < s.size(); i++) {
if (s[i] > c) c = s[i];
}
n -= stoi(to_string(c)) - 48;
cnt++;
}
cout << cnt;
}
| 3 |
#include <bits/stdc++.h>
int INF = 99999;
int main() {
std::string a, b;
int n;
std::cin >> a >> b >> n;
if (a.size() != b.size()) {
std::cout << -1 << std::endl;
return 0;
}
std::vector<std::vector<int> > g(26, std::vector<int>(26, INF));
for (int i = 0; i < n; ++i) {
char x, y;
int w;
std::cin >> x >> y >> w;
g[x - 'a'][y - 'a'] = std::min(g[x - 'a'][y - 'a'], w);
}
for (int i = 0; i < 26; ++i) {
g[i][i] = 0;
}
for (int k = 0; k < 26; ++k) {
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < 26; ++j) {
int ncost = g[i][k] + g[k][j];
g[i][j] = std::min(g[i][j], ncost);
}
}
}
int res = 0;
std::string c;
for (int i = 0; i < (int)a.size(); ++i) {
int best = INF;
int bestidx;
for (int j = 0; j < 26; ++j) {
int cost = g[a[i] - 'a'][j] + g[b[i] - 'a'][j];
if (best > cost) {
best = cost;
bestidx = j;
}
}
if (best == INF) {
res = -1;
break;
} else {
res += best;
c += bestidx + 'a';
}
}
std::cout << res << std::endl;
if (res != -1) {
std::cout << c << std::endl;
}
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
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...);
}
const long long int MOD = 1e9 + 7;
const long long int INF = 1000000000;
const long long int MAX_N = 2e5 + 2;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n / 2; ++i) {
char c1 = s[i];
char c2 = s[n - i - 1];
if (c1 - c2 < -2 || c1 - c2 > 2 || abs(c1 - c2) == 1) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
cin >> t;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int a;
while (cin >> n) {
map<int, int> G;
while (n--) {
scanf("%d", &a);
if (G.find(a) != G.end())
G[a]++;
else
G[a] = 1;
}
map<int, int>::iterator iter = G.begin();
while (iter != G.end() && iter->second % 2 == 0) ++iter;
if (iter != G.end())
puts("Conan");
else
puts("Agasa");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
int c = 0;
for (int i = 2 * n; i <= 4 * n; i += 2) {
c++;
cout << i << " ";
if (c == n) break;
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int all[500], n, m;
int main() {
scanf("%d%d", &n, &m);
memset(all, 0, sizeof(all));
for (int i = 0; i < n; i++) scanf("%d", &all[i + 1]);
for (int i = 1; i <= n; i++) all[i] += all[i - 1];
int ans = 0;
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
int sum = all[r] - all[l - 1];
if (sum >= 0) ans += sum;
}
printf("%d", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double epsilon = 1e-9;
bool is_valid(vector<int> v) {
if (v[1] > 12) return false;
int m[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (v[0] % 4 == 0) m[1]++;
return v[2] <= m[v[1] - 1];
}
int main() {
vector<int> y(3), v(3);
scanf("%d.%d.%d", &y[0], &y[1], &y[2]);
scanf("%d.%d.%d", &v[0], &v[1], &v[2]);
sort(v.begin(), v.end());
vector<int> maxm(3, 1000);
do {
if (is_valid(v)) {
maxm = min(maxm, v);
}
} while (next_permutation(v.begin(), v.end()));
v = maxm;
reverse(v.begin(), v.end());
if (v[2] < y[2] - 18 || (v[2] == y[2] - 18 && v[1] < y[1]) ||
(v[2] == y[2] - 18 && v[1] == y[1] && v[0] <= y[0]))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline void Swap(long long &x, long long &y) {
long long Temp = x;
x = y;
y = Temp;
}
inline long long Min(long long x, long long y) { return x < y ? x : y; }
inline long long Max(long long x, long long y) { return x > y ? x : y; }
inline void read(long long &x) {
x = 0;
long long f = 1;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = (x << 3) + (x << 1) + (s ^ 48);
s = getchar();
}
x *= f;
}
long long dp[205][205 * 30], a[205], Five[205], Two[205];
inline long long Count(long long x, long long y) {
long long Res = 0;
while (x % y == 0) {
Res++;
x /= y;
}
return Res;
}
int main() {
long long n, k;
read(n);
read(k);
for (register int i = 1; i <= n; ++i) {
read(a[i]);
Five[i] = Count(a[i], 5);
Two[i] = Count(a[i], 2);
}
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (register int i = 1; i <= n; ++i)
for (register int j = i; j >= 1; --j)
for (register int k = i * 30; k >= Five[i]; --k)
if (~dp[j - 1][k - Five[i]])
dp[j][k] = Max(dp[j][k], dp[j - 1][k - Five[i]] + Two[i]);
long long Ans = 0;
for (register int i = 1; i <= 30 * n; ++i) Ans = Max(Ans, Min(i, dp[k][i]));
printf("%lld", Ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a[205];
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int t1[205], t2[205], ans = -999999999;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
int n1 = 0, n2 = 0, tp = 0;
for (int k = 0; k < i; k++) t1[n1++] = a[k];
for (int k = j + 1; k < n; k++) t1[n1++] = a[k];
for (int k = i; k <= j; k++) {
tp += a[k];
t2[n2++] = a[k];
}
ans = max(ans, tp);
if (n2 == 0 || n1 == 0) continue;
sort(t1, t1 + n1);
sort(t2, t2 + n2);
int p1 = n1 - 1, p2 = 0;
for (int k = 1; k <= m; k++) {
if (p1 < 0 || p2 >= n2) break;
if (t1[p1] > t2[p2])
tp += t1[p1] - t2[p2];
else
break;
p1--;
p2++;
}
ans = max(ans, tp);
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
long long n, k, l, r, res, r1, l1;
cin >> n >> k;
vector<int> a(n, 1);
vector<int> lin(n);
for (int i = 0; i < n; i++) {
cin >> lin[i];
lin[i]--;
}
for (int i = 0; i < n; i++) {
res = 0;
l = i - k > -1 ? i - k : 0;
r = i + k < n ? i + k : n - 1;
res = r - l + 1;
if (lin[i] != -1) {
l1 = lin[i] - k > -1 ? lin[i] - k : 0;
r1 = lin[i] + k < n ? lin[i] + k : n - 1;
if (r1 < l)
res = (r - l) + a[lin[i]] + 1;
else {
res = (r - l) - (r1 - l) + a[lin[i]];
}
}
a[i] = res;
}
for (int i = 0; i < n; i++) cout << a[i] << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
long long mod = 1000000007LL;
long long mod2 = 998244353LL;
int n;
int p[200005];
int pmax[200005][20];
int pos[200005];
long long ans;
void dfs(int l, int r) {
if (l >= r) return;
int pw = 0;
while ((1 << pw) <= (r - l + 1)) {
pw++;
}
pw--;
int id1 = pmax[l][pw];
int id2 = pmax[r - (1 << pw) + 1][pw];
int id = -1;
if (id2 < 0 || (id1 >= 0 && p[id1] > p[id2])) {
id = id1;
} else {
id = id2;
}
if (id - l < r - id) {
for (int i = l; i < id; ++i) {
if (pos[p[id] - p[i]] > id && pos[p[id] - p[i]] <= r) {
ans++;
}
}
} else {
for (int i = id + 1; i <= r; ++i) {
if (pos[p[id] - p[i]] < id && pos[p[id] - p[i]] >= l) {
ans++;
}
}
}
dfs(l, id - 1);
dfs(id + 1, r);
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%d", &p[i]);
pos[p[i]] = i;
}
memset(pmax, -1, sizeof(pmax));
for (int i = 1; i <= n; ++i) {
pmax[i][0] = i;
}
for (int i = 1; (1 << i) <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (j + (1 << i) - 1 <= n) {
if (pmax[j][i - 1] >= 0 &&
(pmax[j][i] < 0 || p[pmax[j][i]] < p[pmax[j][i - 1]])) {
pmax[j][i] = pmax[j][i - 1];
}
if (pmax[j + (1 << (i - 1))][i - 1] >= 0 &&
(pmax[j][i] < 0 ||
p[pmax[j][i]] < p[pmax[j + (1 << (i - 1))][i - 1]])) {
pmax[j][i] = pmax[j + (1 << (i - 1))][i - 1];
}
}
}
}
ans = 0LL;
dfs(1, n);
cout << ans << endl;
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, d[1001], y[100001], dp[1001][1001];
int main() {
scanf("%lld%lld", &a, &b);
for (int i = 1; i <= a; i++) {
scanf("%lld", &d[i]);
}
sort(d + 1, d + a + 1);
long long pp = 1;
for (int i = d[1]; i <= d[a]; i++) {
while (pp < a && i >= d[pp + 1]) {
pp++;
}
y[i] = pp;
}
long long ans = 0;
for (int i = 0; i <= a; i++) {
dp[i][0] = 1;
}
for (int ii = 1; ii * (b - 1) <= d[a]; ii++) {
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; j++) {
dp[i][j] = dp[i - 1][j] + dp[d[i] - ii >= 0 ? y[d[i] - ii] : 0][j - 1];
dp[i][j] %= 998244353;
}
}
ans += dp[a][b];
ans %= 998244353;
}
printf("%lld", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
string a;
vector<int> pod;
int n, m, u;
bool func(int k) {
m = 0;
for (int i = 0; i < k - 1; i++) {
pod[a[i]]++;
if (pod[a[i]] == 1) {
m++;
}
}
for (int l = 0, r = k - 1; r < n; l++, r++) {
pod[a[r]]++;
if (pod[a[r]] == 1) {
m++;
}
if (m == u) {
return true;
}
pod[a[l]]--;
if (pod[a[l]] == 0) {
m--;
}
}
return false;
}
int main() {
m = 0;
u = 0;
scanf("%d", &n);
cin >> a;
pod.resize('z' + 1);
for (int i = 0; i < n; i++) {
if (pod[a[i]] == 0) {
u++;
pod[a[i]] = 1;
}
}
pod.assign('z' + 1, 0);
int l = 0, r = n;
while (l + 1 < r) {
int md = (l + r) / 2;
if (func(md)) {
r = md;
} else {
l = md;
}
pod.assign('z' + 1, 0);
}
cout << r;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
typedef long long ll;
void my_return(ll code) { exit(code); }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll my_exp(ll a, ll b, ll MOD = numeric_limits<ll>::max()) {
a %= MOD;
if (b == 0) {
return 1;
} else {
return ((b % 2 == 1 ? a : 1) * my_exp(a * a, b / 2, MOD)) % MOD;
}
}
bool is_prime(ll n) {
if (n != 2 && n % 2 == 0) {
return false;
} else {
for (int i = 3; (i * i) <= n; i += 2) {
if (n % i == 0) return false;
}
return true;
}
}
int main() {
ios_base::sync_with_stdio(false);
ll x;
cin >> x;
vector<pair<ll, ll> > ans;
for (ll i = 1; i < 2000000; ++i) {
if ((x + ((i * (i + 1) * (i - 1)) / 6)) % (i * (i + 1) / 2) == 0) {
ll n = (x + ((i * (i + 1) * (i - 1)) / 6)) / (i * (i + 1) / 2);
if (n > 0 && n >= i) {
ans.push_back(make_pair(i, n));
}
}
}
ll s = 2 * ll(ans.size());
for (decltype(ans.begin()) it = ans.begin(); it != ans.end(); it++) {
if (it->first == it->second) {
--s;
break;
}
}
cout << s << endl;
for (decltype(ans.begin()) it = ans.begin(); it != ans.end(); it++) {
cout << it->first << " " << it->second << endl;
}
for (decltype(ans.rbegin()) it = ans.rbegin(); it != ans.rend(); it++) {
if (it->first != it->second) {
cout << it->second << " " << it->first << endl;
}
}
my_return(0);
}
| 11 |
#include <bits/stdc++.h>
using ll = long long;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
using p = std::pair<int, int>;
int n, m;
std::vector<std::string> stage;
std::vector<std::vector<int>> color;
int num = 0;
void dfs(p u, p pre = p(-1, -1)) {
color[u.first][u.second] = num;
for (int i = 0; i < 4; i++) {
int next_f = u.first + dy[i];
int next_s = u.second + dx[i];
if (next_f < 0 || next_f >= n) continue;
if (next_s < 0 || next_s >= m) continue;
p next = p(next_f, next_s);
if (next == pre || color[next_f][next_s] != -1) continue;
if (stage[next_f][next_s] == '#') {
dfs(next, u);
}
}
}
int main() {
std::cin >> n >> m;
stage.resize(n);
for (int i = 0; i < n; i++) {
std::cin >> stage[i];
}
bool existAllWhiteRow = false, existAllWhiteCol = false;
for (int i = 0; i < n; i++) {
if (stage[i] == std::string(m, '.')) {
existAllWhiteRow = true;
break;
}
}
for (int j = 0; j < m; j++) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (stage[i][j] == '.') cnt++;
}
if (cnt == n) existAllWhiteCol = true;
}
if (existAllWhiteCol != existAllWhiteRow) {
std::cout << -1 << std::endl;
return 0;
}
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < m; j++) {
if (cnt >= 0 && stage[i][j] == '#') {
cnt++;
} else if (cnt > 0 && stage[i][j] == '.') {
cnt = -1;
} else if (stage[i][j] == '#') {
std::cout << -1 << std::endl;
return 0;
}
}
}
for (int j = 0; j < m; j++) {
int cnt = 0;
for (int i = 0; i < n; i++) {
if (cnt >= 0 && stage[i][j] == '#') {
cnt++;
} else if (cnt > 0 && stage[i][j] == '.') {
cnt = -1;
} else if (stage[i][j] == '#') {
std::cout << -1 << std::endl;
return 0;
}
}
}
color.assign(n, std::vector<int>(m, -1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (stage[i][j] == '#' && color[i][j] == -1) {
dfs(p(i, j));
num++;
}
}
}
std::cout << num << std::endl;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y;
vector<int> v[3005];
long long cal(int k) {
vector<int> bk;
long long res = 0;
long long cnt = v[1].size();
for (int i = 2; i <= m; i++) {
int num = v[i].size();
for (int j = 0; j < num; j++) {
if (num - j >= k) {
res += v[i][j];
cnt++;
} else
bk.push_back(v[i][j]);
}
}
if (cnt < k) {
sort(bk.begin(), bk.end());
for (int i = 0; i < bk.size() && cnt < k; i++) {
res += bk[i];
cnt++;
}
}
return cnt < k ? 0x3f3f3f3f3f3f3f3f : res;
}
int main() {
while (~scanf("%d %d", &n, &m)) {
for (int i = 1; i <= m; i++) v[i].clear();
for (int i = 1; i <= n; i++) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
}
for (int i = 1; i <= m; i++) sort(v[i].begin(), v[i].end());
long long ans = 0x3f3f3f3f3f3f3f3f;
for (int i = 1; i <= n; i++) ans = min(ans, cal(i));
printf("%lld\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool busy[8][8], safe[8][8];
char r1[8], r2[8], wk[8], b[8];
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, -1, 1, -1, 1};
void kill(char *str, bool rook) {
int x = str[0] - 'a', y = str[1] - '1';
if (rook) {
for (int d = 0; d < 4; ++d) {
for (int i = 1; i < 8; ++i) {
int nx = x + dx[d] * i, ny = y + dy[d] * i;
if (nx < 0 || ny < 0 || nx >= 8 || ny >= 8) continue;
safe[nx][ny] = 0;
if (busy[nx][ny]) break;
}
}
} else {
for (int d = 0; d < 8; ++d) {
int nx = x + dx[d], ny = y + dy[d];
if (nx < 0 || ny < 0 || nx >= 8 || ny >= 8) continue;
safe[nx][ny] = 0;
}
}
}
void show() {
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 8; ++j) putc(safe[i][j] + '0', stdout);
putc(10, stdout);
}
puts("----------------");
}
int main(void) {
scanf("%s %s %s %s", r1, r2, wk, b);
for (int i = 0; i < 8; ++i)
for (int j = 0; j < 8; ++j) safe[i][j] = 1, busy[i][j] = 0;
busy[r1[0] - 'a'][r1[1] - '1'] = 1;
busy[r2[0] - 'a'][r2[1] - '1'] = 1;
busy[wk[0] - 'a'][wk[1] - '1'] = 1;
kill(r1, 1);
kill(r2, 1);
kill(wk, 0);
int myx = b[0] - 'a', myy = b[1] - '1';
bool imfinethx = safe[myx][myy];
for (int d = 0; !imfinethx && d < 8; ++d) {
int nx = myx + dx[d], ny = myy + dy[d];
if (nx < 0 || ny < 0 || nx >= 8 || ny >= 8) continue;
imfinethx |= safe[nx][ny];
}
if (imfinethx)
puts("OTHER");
else
puts("CHECKMATE");
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void read(long long &x) {
char ch = getchar();
x = 0;
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - 48, ch = getchar();
}
const long long N = 1e5 + 10;
long long n, q, mx, sum, k, c[N], dis[N];
long long cnt, h[N], to[N << 1], nxt[N << 1], len[N << 1];
void add(long long u, long long v, long long l) {
sum += l, ++c[u], ++c[v];
to[++cnt] = v, len[cnt] = l, nxt[cnt] = h[u], h[u] = cnt;
to[++cnt] = u, len[cnt] = l, nxt[cnt] = h[v], h[v] = cnt;
}
void get(long long u, long long la) {
if (dis[u] > dis[mx]) mx = u;
for (long long i = h[u], v; i; i = nxt[i])
if ((v = to[i]) != la) dis[v] = dis[u] + len[i], get(v, u);
}
struct tree {
pair<long long, long long> a[N];
long long cc;
long long rt, tp[N], son[N], mx[N], fa[N][19], dp[N];
long long ti[N], ans[N], bt[N], d[N];
void dfs(long long u) {
for (long long i = 1; (1 << i) <= d[u]; ++i)
fa[u][i] = fa[fa[u][i - 1]][i - 1];
for (long long i = h[u], v; i; i = nxt[i]) {
if ((v = to[i]) == fa[u][0]) continue;
dp[v] = mx[v] = dp[u] + len[i];
d[v] = d[u] + 1, fa[v][0] = u, dfs(v);
if (mx[v] > mx[u]) mx[u] = mx[v], son[u] = v;
}
}
void dfs(long long u, long long topp) {
tp[u] = topp;
if (son[u]) dfs(son[u], topp);
for (long long i = h[u]; i; i = nxt[i])
if (!tp[to[i]]) dfs(to[i], to[i]);
}
void pre() {
d[rt] = 1;
dfs(rt);
dfs(rt, rt);
for (long long i = 1; i <= n; ++i)
if (c[i] == 1 && i != rt)
a[++cc] = make_pair(dp[i] - dp[fa[tp[i]][0]], i);
sort(a + 1, a + cc + 1);
for (long long i = cc, t = 1; i >= 1; --i, ++t) {
ans[t] = ans[t - 1] + a[i].first;
long long e = a[i].second;
while (e != fa[tp[a[i].second]][0])
ti[e] = t, bt[e] = a[i].second, e = fa[e][0];
}
}
long long calc(long long x, long long y) {
y = y * 2 - 1;
if (y >= cc) return ans[cc];
if (ti[x] <= y) return ans[y];
long long tpp = x;
for (long long i = 18; i >= 0; --i)
if (ti[fa[tpp][i]] > y) tpp = fa[tpp][i];
long long res = ans[y - 1] + dp[bt[x]] - dp[fa[tpp][0]];
return max(res, ans[y] + dp[bt[x]] - dp[fa[tpp][0]] - dp[bt[fa[tpp][0]]] +
dp[fa[tpp][0]]);
}
} p[2];
signed main() {
read(n), read(q);
for (long long i = 1, u, v, l; i < n; ++i)
read(u), read(v), read(l), add(u, v, l);
get(1, 0);
p[0].rt = mx;
get(mx, 0);
p[1].rt = mx;
p[0].pre(), p[1].pre();
for (long long i = 1, x, y, la = 0; i <= q; ++i) {
read(x), read(y);
x = (x + la - 1) % n + 1, y = (y + la - 1) % n + 1;
la = max(p[0].calc(x, y), p[1].calc(x, y));
printf("%lld\n", la);
}
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long prod;
for (int i = 3;; i++) {
prod = (i * (i + 1)) / 2;
if (n < prod) {
n = (i * (i - 1)) / 2;
break;
}
}
int a = (sqrt((8 * n) + 1) - 1) / 2;
a += 1;
cout << a << "\n";
a -= 1;
vector<vector<int> > vec(a + 1, vector<int>(a));
int z, m = 0, j, i;
int *ptr1;
int *ptr2;
for (i = 0; i < a; i++) {
j = i;
for (z = 1 + m; z <= (((i + 1) * a) - ((i * (i + 1)) / 2)); z++) {
ptr1 = &vec[i][j];
ptr2 = &vec[j + 1][i];
*ptr1 = z;
*ptr2 = z;
j++;
}
m = (((i + 1) * a) - ((i * (i + 1)) / 2));
}
for (int j = 0; j <= a; j++) {
for (int k = 0; k < a; k++) {
cout << vec[j][k] << " ";
}
cout << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int w[1005], h[1005], v[1005];
int n, ans = 0x3f3f3f3f;
void solve(int H) {
int sum = 0, cnt = 0, cc = 0;
for (int i = 0; i < n; ++i) {
if (h[i] > H && w[i] > H) return;
if (h[i] > H) {
++cnt;
sum += h[i];
continue;
}
if (w[i] > H) {
sum += w[i];
continue;
}
sum += w[i];
v[cc++] = h[i] - w[i];
}
if (cnt > n / 2) return;
sort(v, v + cc);
cnt = n / 2 - cnt;
for (int i = 0; i < cc && i < cnt; ++i) {
if (v[i] >= 0) break;
sum += v[i];
}
ans = min(ans, sum * H);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d%d", w + i, h + i);
for (int i = 1; i <= 1000; ++i) solve(i);
printf("%d\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2, typename T3>
class triple {
public:
T1 first;
T2 second;
T3 third;
triple() {
first = 0;
second = 0;
third = 0;
}
};
const int maxn = 2e5 + 9;
const int INF = 1e9 + 9;
const int LOG = 2e1 + 2;
int n, m, q;
int h[maxn], part[maxn];
int par[maxn][LOG];
vector<pair<int, int> > g[maxn], g2[maxn];
bool cut[maxn], visited[maxn];
int dfs(int u, int p) {
int temp = INF;
visited[u] = true;
par[u][0] = p;
for (int i = 1; i < LOG && par[u][i - 1] != -1; i++)
par[u][i] = par[par[u][i - 1]][i - 1];
for (auto node : g[u]) {
int v = node.first, id = node.second;
if (!visited[v]) {
g2[u].push_back(make_pair(v, id));
g2[v].push_back(make_pair(u, id));
h[v] = h[u] + 1;
int x = dfs(v, u);
temp = min(x, temp);
if (x > h[u]) cut[id] = true;
} else if (v != par[u][0])
temp = min(temp, h[v]);
}
return temp;
}
int lca(int u, int v) {
if (h[u] < h[v]) swap(u, v);
for (int((i)) = ((LOG - 1)); ((i)) >= (0); ((i))--)
if (h[v] <= h[u] - (1 << i)) u = par[u][i];
if (u == v) return u;
for (int((i)) = ((LOG - 1)); ((i)) >= (0); ((i))--)
if (par[u][i] != par[v][i]) {
u = par[u][i];
v = par[v][i];
}
return par[u][0];
}
void dfs2(int u) {
for (auto node : g2[u]) {
int v = node.first, id = node.second;
if (v != par[u][0]) {
part[v] += part[u] + cut[id];
dfs2(v);
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int(i) = (1); (i) < (m + 1); (i)++) {
int u, v;
cin >> u >> v;
g[u].push_back(make_pair(v, i));
g[v].push_back(make_pair(u, i));
}
memset(par, -1, sizeof(par));
dfs(1, -1);
dfs2(1);
cin >> q;
for (int(i) = (1); (i) < (q + 1); (i)++) {
int a, b;
cin >> a >> b;
int p = lca(a, b);
cout << part[a] + part[b] - part[p] * 2 << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[1007][1007];
int b[1000007];
map<int, int> mp;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = a[i][0]; j <= a[i][1]; j++) {
mp[j]++;
}
}
vector<int> kq;
for (int i = 1; i <= m; i++) {
if (mp[i] == 0) {
kq.push_back(i);
}
}
cout << kq.size() << endl;
for (int i = 0; i < kq.size(); i++) {
cout << kq[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, sum;
while (~scanf("%d%d", &m, &n)) {
int hx;
sum = 0;
int ans = 1;
for (int i = 0; i < m; i++) {
scanf("%d", &hx);
sum += hx;
if (sum > n) {
ans++;
sum = hx;
}
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int cost[200][200];
int x[200], y[200];
int a[200];
int dis[200];
bool vis[200];
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
int n, d;
cin >> n >> d;
for (int i = 2; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
cin >> x[i] >> y[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cost[i][j] = (abs(x[i] - x[j]) + abs(y[i] - y[j])) * d;
cost[i][j] -= a[i];
}
}
memset(dis, 0x4f4f4f4f, sizeof(dis));
memset(vis, false, sizeof(vis));
dis[1] = 0;
for (int i = 0; i < n; i++) {
int min = 0x4f4f4f4f;
int mink;
for (int j = 1; j <= n; j++) {
if (!vis[j] && dis[j] < min) {
min = dis[j];
mink = j;
}
}
if (min == 0x4f4f4f4f) {
break;
}
vis[mink] = true;
if (mink == n) {
break;
}
for (int j = 1; j <= n; j++) {
if (!vis[j] && dis[mink] + cost[mink][j] < dis[j]) {
dis[j] = dis[mink] + cost[mink][j];
}
}
}
cout << dis[n] << "\n";
;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
char c[1001];
vector<int> v;
int main() {
int n;
cin >> n;
if (n == 1) {
cin >> c[1];
cout << c[1];
return 0;
}
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
for (int i = 2; i <= n; i++) {
if (n % i == 0) v.push_back(i);
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
reverse(c + 1, c + v[i] + 1);
}
for (int i = 1; i <= n; i++) {
cout << c[i];
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001000;
int nx[N], vis[N], d[N], cnt[N], all[N];
vector<int> g;
int main() {
int p, k;
cin >> p >> k;
if (k == 0) {
long long res = 1;
for (int i = 0; i < p - 1; i++) {
(res *= p) %= (int)(1e9 + 7);
}
cout << res << endl;
return 0;
}
for (int i = 0; i < p; i++)
if (!vis[i]) {
int tmp = i, c = 0;
g.push_back(i);
vis[tmp] = 1;
do {
tmp = 1LL * tmp * k % p;
c++;
} while (tmp != i);
do {
tmp = 1LL * tmp * k % p;
d[tmp] = c;
vis[tmp] = 1;
} while (tmp != i);
}
for (int i = 0; i < p; i++) {
cnt[d[i]]++;
}
for (int i = 1; i <= p; i++) {
for (int j = i; j <= p; j += i) {
all[j] += cnt[i];
}
}
long long res = 1;
for (int i = 0; i < g.size(); i++) {
(res *= all[d[g[i]]]) %= (int)(1e9 + 7);
}
cout << res << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long mod = (long long)1e9 + 7;
const double pi = acos(-1.0);
const double eps = (double)1e-9;
const int dx[] = {0, 0, 1, 0, -1};
const int dy[] = {0, 1, 0, -1, 0};
const int N = 100500;
int n, m;
pair<int, pair<int, int> > p[N];
struct edge {
int from, to, cap, flow;
edge(){};
edge(int a, int b, int c, int d) {
from = a;
to = b;
cap = c;
flow = d;
}
};
vector<edge> e;
vector<int> g[N];
int d[N], ptr[N];
inline void add_edge(int x, int y, int cap) {
g[x].push_back((int)e.size());
e.push_back(edge(x, y, cap, 0));
g[y].push_back((int)e.size());
e.push_back(edge(y, x, 0, 0));
}
inline bool bfs(int x, int y) {
for (int i = 0; i <= n + n + 1; i++) d[i] = inf;
d[x] = 0;
queue<int> q;
q.push(x);
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto i : g[v]) {
if (d[e[i].from] + 1 < d[e[i].to] && e[i].flow < e[i].cap) {
d[e[i].to] = d[e[i].from] + 1;
q.push(e[i].to);
}
}
}
return (d[y] != inf);
}
int dfs(int v, int fin, int flow = inf) {
if (v == fin || !flow) return flow;
while (ptr[v] < (int)g[v].size()) {
int i = g[v][ptr[v]];
if (d[e[i].from] + 1 == d[e[i].to] && e[i].flow < e[i].cap) {
int cur = dfs(e[i].to, fin, min(flow, e[i].cap - e[i].flow));
if (cur) {
e[i].flow += cur;
e[i ^ 1].flow -= cur;
return cur;
}
}
ptr[v]++;
}
return 0;
}
inline int max_flow(int x, int y) {
int res = 0;
while (bfs(x, y)) {
memset(ptr, 0, sizeof(ptr));
while (1) {
int add = dfs(x, y);
if (!add) break;
res += add;
}
}
return res;
}
inline bool check(int lim) {
for (int i = 0; i <= n + n + 1; i++) g[i].clear();
e.clear();
for (int i = 1; i <= n; i++) {
add_edge(0, i, 1);
add_edge(n + i, n + n + 1, 1);
}
for (int i = 1; i <= lim; i++) {
int x = p[i].second.first;
int y = p[i].second.second;
add_edge(x, n + y, 1);
}
int res = max_flow(0, n + n + 1);
return res == n;
}
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y, z;
cin >> x >> y >> z;
p[i] = {z, {x, y}};
}
sort(p + 1, p + 1 + m);
int l = 1, r = m, res = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
res = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (res == -1)
cout << -1;
else
cout << p[res].first;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e5 + 123;
int siz[N], son[N], fa[N], top[N], dep[N], dfn[N], tot;
struct Edge {
int to, pre;
} e[N * 2];
int ecnt = 0, h[N];
void addedge(int u, int v) {
e[ecnt] = (Edge){v, h[u]};
h[u] = ecnt++;
}
void dfs1(int u, int t) {
top[u] = t;
dfn[u] = ++tot;
if (son[u]) dfs1(son[u], t);
for (int i = h[u]; ~i; i = e[i].pre) {
int v = e[i].to;
if (v == son[u] || v == fa[u]) continue;
dfs1(v, v);
}
}
void dfs(int u) {
siz[u] = 1;
for (int i = h[u]; ~i; i = e[i].pre) {
int v = e[i].to;
if (v == fa[u]) continue;
fa[v] = u;
dep[v] = dep[u] + 1;
dfs(v);
siz[u] += siz[v];
if (siz[v] > siz[son[u]]) son[u] = v;
}
}
int lca(int u, int v) {
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
u = fa[top[u]];
}
return dep[u] < dep[v] ? u : v;
}
int sum(int u, int v) {
int res = 0;
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
res += dfn[u] - dfn[top[u]] + 1;
u = fa[top[u]];
}
res += abs(dfn[u] - dfn[v]) + 1;
return res;
}
int get(int a, int b, int c) {
int u = lca(a, b), v = c;
int p = lca(a, c);
int A, B;
if (dep[p] >= dep[u])
A = sum(c, p);
else
A = sum(u, c);
p = lca(b, c);
if (dep[p] >= dep[u])
B = sum(c, p);
else
B = sum(u, c);
return min(A, B);
}
int main() {
memset(h, 0xff, sizeof h);
int n, q;
scanf("%d %d", &n, &q);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
addedge(p, i);
}
dfs(1);
dfs1(1, 1);
while (q--) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
int ans = max(get(a, b, c), max(get(a, c, b), get(b, c, a)));
printf("%d\n", ans);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 50;
int main() {
std::ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
long long x, y, k;
cin >> x >> y >> k;
long long cnt = y * k + k - 1;
long long ans = cnt / (x - 1) + k;
if (cnt % (x - 1)) ans++;
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using std::endl;
using std::map;
using std::priority_queue;
using std::string;
using std::vector;
int main(void) {
using std::cin;
using std::cout;
std::ios_base::sync_with_stdio(false);
cin.tie(0);
string S;
cin >> S;
const int N = S.size();
int lastInd = -1;
priority_queue<int> closed;
priority_queue<int> unclosed;
map<int, vector<int>> seqs;
for (int pos = 0; pos < N; ++pos) {
if (S[pos] == '0') {
if (unclosed.empty()) {
++lastInd;
closed.push(lastInd);
assert(seqs[lastInd].empty());
seqs[lastInd].push_back(pos);
} else {
const int ind = unclosed.top();
unclosed.pop();
seqs[ind].push_back(pos);
closed.push(ind);
}
} else {
assert(S[pos] == '1');
if (closed.empty()) {
unclosed.push(-1);
break;
}
const int ind = closed.top();
closed.pop();
seqs[ind].push_back(pos);
unclosed.push(ind);
}
}
if (!unclosed.empty()) {
cout << "-1\n";
} else {
cout << closed.size() << '\n';
while (!closed.empty()) {
const int ind = closed.top();
closed.pop();
cout << seqs[ind].size() << ' ';
for (const auto& index : seqs[ind]) cout << (index + 1) << ' ';
cout << '\n';
}
}
cout.flush();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 7;
long long arr[MAXN];
pair<long long, long long> A[MAXN];
long long n, m;
long long dx[5] = {1, -1, 0, 0};
long long dy[5] = {0, 0, 1, -1};
char maps[100][100];
bool found;
bool visited[200][200];
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long bigmod(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void dfs(long long i, long long j, long long fx, long long fy, char p) {
if (i >= n || i < 0 || j >= m || j < 0) return;
if (maps[i][j] != p) return;
if (visited[i][j]) {
found = true;
return;
}
visited[i][j] = true;
for (long long k = 0; k < 4; k++) {
long long movex = i + dx[k];
long long movey = j + dy[k];
if (movex == fx && movey == fy) continue;
dfs(movex, movey, i, j, p);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cin >> maps[i][j];
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (!visited[i][j]) {
dfs(i, j, -1, -1, maps[i][j]);
}
}
}
if (found == true)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> out;
vector<int> used(50);
vector<vector<int> > arr(1000);
int t = 0;
bool dfs(char v) {
used[v] = 1;
for (int i = 0; i < arr[v].size(); i++)
if (used[arr[v][i]] == 0) {
if (dfs(arr[v][i])) return 1;
} else if (used[arr[v][i]] == 1) {
return 1;
}
used[v] = 2;
out.push_back(v);
return 0;
}
int main() {
int n;
cin >> n;
string s2;
cin >> s2;
for (int i = 0; i < n - 1; i++) {
string s1;
cin >> s1;
int k = -1;
for (int j = 0; j < min(s1.length(), s2.length()) && k < 0; j++) {
if (k < 0 && s1[j] != s2[j]) k = j;
}
if (k == -1 && s1.length() < s2.length()) {
cout << "Impossible";
return 0;
}
if (k >= 0) {
arr[s1[k] - 'a'].push_back(s2[k] - 'a');
}
s2 = s1;
}
for (int i = 0; i <= 'z' - 'a'; i++)
if (!used[i]) {
if (dfs(i)) {
cout << "Impossible";
return 0;
}
}
for (int i = 0; i < out.size(); i++) {
cout << char(out[i] + 'a');
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename... T>
void read(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void write(T&&... args) {
((cout << args << " "), ...);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, drink, drinkNeed(0);
long long ability, moneySpend(0);
vector<int> weight, price;
read(n, ability);
for (int i = 0, t; i < n; ++i) cin >> t, weight.push_back(t);
read(drink);
for (int i = 0, t; i < n; ++i) cin >> t, price.push_back(t);
set<int> minDrinkPrices;
for (int i = 0; i < n; ++i) {
minDrinkPrices.insert(price[i]);
while (ability < weight[i] and minDrinkPrices.size()) {
ability += drink;
moneySpend += *minDrinkPrices.begin();
minDrinkPrices.erase(*minDrinkPrices.begin());
}
if (ability < weight[i] and !minDrinkPrices.size())
return cout << -1 << endl, 0;
}
cout << moneySpend << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long dp[100001][2];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long n, a[100000];
cin >> n;
vector<int> v(100001);
for (int i = 0; i < n; i++) {
cin >> a[i];
v[a[i]]++;
}
dp[1][1] = v[1];
dp[1][0] = 0;
for (long long i = 2; i < 100001; i++) {
dp[i][1] = max(dp[i - 2][1], dp[i - 2][0]) + v[i] * i;
dp[i][0] = dp[i - 1][1];
}
cout << max(dp[100000][0], dp[100000][1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, k, ans, s[5005][5005];
inline int read() {
int num = 0;
char cc = getchar();
while (cc < 48 || cc > 57) cc = getchar();
while (cc > 47 && cc < 58)
num = (num << 1) + (num << 3) + (cc ^ 48), cc = getchar();
return num;
}
inline int power(int a, int b) {
int res = 1;
while (b) {
if (b & 1) res = 1ll * res * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return res;
}
int main() {
n = read(), k = read();
s[0][0] = 1;
for (int i = 1; i <= k; i++)
for (int j = 1; j <= i; j++)
s[i][j] = (s[i - 1][j - 1] + 1ll * s[i - 1][j] * j) % mod;
int fac = 1, mul2 = power(2, n), inv = power(2, mod - 2);
for (int i = 0; i <= k; i++) {
(ans += 1ll * s[k][i] * fac % mod * mul2 % mod) %= mod;
fac = 1ll * fac * (n - i) % mod;
mul2 = 1ll * mul2 * inv % mod;
}
if (!k) ans--;
printf("%d", ans);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n;
const long double ep = 1e-10;
inline char nc() {
static char buf[100000], *l = buf, *r = buf;
return l == r && (r = (l = buf) + fread(buf, 1, 100000, stdin), l == r)
? EOF
: *l++;
}
template <class T>
void read(T &x) {
x = 0;
int f = 1, ch = nc();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = nc();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 - '0' + ch;
ch = nc();
}
x *= f;
}
struct pnt {
long double x, y;
pnt(long double x = 0, long double y = 0) : x(x), y(y) {}
pnt operator+(const pnt &b) const { return pnt(x + b.x, y + b.y); }
pnt operator-(const pnt &b) const { return pnt(x - b.x, y - b.y); }
pnt operator*(const long double &b) { return pnt(x * b, y * b); }
pnt operator/(const long double &b) { return pnt(x / b, y / b); }
long double operator&(const pnt &b) { return x * b.x + y * b.y; }
pnt rot() { return pnt(-y, x); }
long double dist() { return sqrt(x * x + y * y); }
void input() { read(x), read(y); }
} p[100005], A, B, M, dir;
long double r[100005], R, R2;
void answer(long double R) {
cout << fixed << setprecision(10) << R << endl;
exit(0);
}
bool far(pnt C, long double cr, pnt D, long double dr) {
long double d = (C - D).dist();
if (d > cr + dr - ep) return 1;
return 0;
}
bool con(pnt C, long double cr, pnt D, long double dr) {
long double d = (C - D).dist();
if (cr > d + dr - ep) return 1;
return 0;
}
using pdd = pair<long double, long double>;
long double far_yes_max(pnt p, long double r) {
long double st = R, en = 1e12;
if (!far(M, R, p, r)) return R;
int step = 100;
while (step--) {
long double mid = (en + st) * .5;
pnt O = M + dir * sqrt(mid * mid - R2);
if (far(O, mid, p, r))
st = mid;
else
en = mid;
}
return st;
}
long double con_yes_min(pnt p, long double r) {
long double st = R, en = 1e12;
int step = 100;
while (step--) {
long double mid = (en + st) * .5;
pnt O = M + dir * sqrt(mid * mid - R2);
if (con(O, mid, p, r))
en = mid;
else
st = mid;
}
return en;
}
long double con_yes_max(pnt p, long double r) {
long double st = R, en = 1e12;
int step = 100;
while (step--) {
long double mid = (en + st) * .5;
pnt O = M + dir * sqrt(mid * mid - R2);
if (con(O, mid, p, r))
st = mid;
else
en = mid;
}
return st;
}
long double far_yes_min(pnt p, long double r) {
long double st = R, en = 1e12;
int step = 100;
while (step--) {
long double mid = (en + st) * .5;
pnt O = M + dir * sqrt(mid * mid - R2);
if (far(O, mid, p, r))
en = mid;
else
st = mid;
}
return en;
}
vector<pdd> vec;
int main() {
A.input(), B.input();
read(n);
for (int i = 1; i <= n; i++) {
p[i].input();
read(r[i]);
}
M = (A + B) * 0.5;
R = (A - B).dist() * 0.5;
R2 = R * R;
bool flag = 0;
for (int i = 1; i <= n; i++) {
bool f = far(M, R, p[i], r[i]) || con(M, R, p[i], r[i]);
if (!f) {
flag = 1;
break;
}
}
if (!flag) answer(R);
long double ans = 1e12;
dir = (B - A).rot();
dir = dir / dir.dist();
for (int t = 0; t < 2; t++) {
vec.clear();
for (int i = 1; i <= n; i++) {
long double f, s;
if ((dir & p[i] - B) > -ep) {
if (con(M, R, p[i], r[i])) continue;
if (far(M, R, p[i], r[i]))
f = far_yes_max(p[i], r[i]);
else
f = R;
s = con_yes_min(p[i], r[i]);
} else {
if (far(M, R, p[i], r[i])) continue;
if (con(M, R, p[i], r[i]))
f = con_yes_max(p[i], r[i]);
else
f = R;
s = far_yes_min(p[i], r[i]);
}
if (abs(s - f) > ep) vec.push_back(pdd(f, s));
}
sort(vec.begin(), vec.end());
long double res = R + 2 * ep;
for (auto x : vec) {
if (x.first < res - ep) {
res = max(res, x.second);
} else
break;
}
ans = min(ans, res);
dir = pnt(-dir.x, -dir.y);
}
answer(ans);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> a, b;
long long int fep(long long int x, long long int y, long long int mod) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m, i, j, x, y, r, sm = 0, cnt = 0;
string s[105];
cin >> n;
for (i = 0; i < n; i++) cin >> s[i];
for (i = 1; i < n - 1; i++)
for (j = 1; j < n - 1; j++)
if (s[i][j] == '.' && s[i - 1][j] == '.' && s[i][j - 1] == '.' &&
s[i + 1][j] == '.' && s[i][j + 1] == '.')
s[i][j] = s[i - 1][j] = s[i][j - 1] = s[i + 1][j] = s[i][j + 1] = '#';
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (s[i][j] == '.') {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, unsigned long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modInverse(long long n, long long p) { return power(n, p - 2, p); }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1;
while (T--) {
long long n, m;
cin >> n >> m;
vector<long long> a(n), b(m);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
for (long long i = 0; i < m; i++) {
cin >> b[i];
}
long long ans = 1000000007;
for (long long k = 0; k < 1000; k++) {
long long f1 = 0;
for (long long i = 0; i < n; i++) {
long long f = 0;
for (long long j = 0; j < m; j++) {
if (((a[i] & b[j]) | k) == k) {
f = 1;
break;
}
}
if (f)
continue;
else {
f1 = 1;
break;
}
}
if (!f1) {
ans = k;
break;
}
}
cout << ans << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double PI = acos(-1.0);
long long mod = 1e9 + 7;
long long GCD(long long a, long long b) {
if (b == 0) return a;
return GCD(b, a % b);
}
long long prod(long long a, long long b) {
long long res = 0;
a %= mod;
while (b) {
if (b & 1ll) res = (res + a) % mod;
a = (2ll * a) % mod;
b >>= 1ll;
}
return res;
}
long long power(long long a, long long b) {
long long res = 1ll;
while (b > 0) {
if (b % 2ll) res = (res * a) % mod;
a = (a * a) % mod;
b /= 2ll;
}
return res;
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
string ans = "";
for (long long i = 0; i < n; i++) {
ans.push_back('0');
}
long long x = n;
long long i = 0, j = n - 1;
vector<bool> vis(n + 1, false);
while (i <= j) {
while (x > 0 and vis[x]) x--;
if (j - i + 1 == x) {
ans[j - i] = '1';
}
vis[max(a[i], a[j])] = true;
if (a[i] > a[j])
i++;
else
j--;
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
int n, r, c, len[1000086], next[20][1000086];
char buf[6000086], *pos[1000086];
int main() {
gets(buf);
sscanf(buf, "%d%d%d", &n, &r, &c);
memset(buf, ' ', sizeof(buf));
gets(buf);
buf[strlen(buf)] = ' ';
char *cp = pos[1] = buf;
for (int i = (2), asdf = (n + 1); i <= asdf; ++i) {
while (*cp != ' ') ++cp;
pos[i] = ++cp;
}
int cr = n, cs = -1;
for (int i = (n); i >= (1); --i) {
cs += (len[i] = pos[i + 1] - pos[i]);
while (cs > c) cs -= len[cr--];
next[0][i] = cr + 1;
}
next[0][n + 1] = n + 1;
for (int j = (1); j <= (19); ++j)
for (int i = (1), asdf = (n + 1); i <= asdf; ++i)
next[j][i] = next[j - 1][next[j - 1][i]];
int bans = -1, bi, br;
for (int i = (1); i <= (n); ++i) {
int cr = i;
for (int j = (0); j <= (19); ++j)
if (r & (1 << j)) cr = next[j][cr];
if (cr - i > bans) {
bans = cr - i;
bi = i;
br = cr;
}
}
if (bi == br) return 0;
for (int c = bi; c != br; c = next[0][c]) *(pos[c] - 1) = '\n';
*(pos[br] - 1) = 0;
puts(pos[bi]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 2e5 + 10;
int N, M;
long long L[kN], R[kN];
struct Event {
long long x;
long long l, r;
int type, id;
bool operator<(const Event& e) const {
if (x != e.x)
return x < e.x;
else
return type > e.type;
}
} es[2 * kN];
int e_cnt;
int ans[kN];
int main() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%I64d %I64d", L + i, R + i);
}
for (int i = 1; i < N; i++) {
long long l = L[i + 1] - R[i];
long long r = R[i + 1] - L[i];
es[++e_cnt] = (Event){l, l, r, 1, i};
}
for (int i = 1; i <= M; i++) {
long long x;
scanf("%I64d", &x);
es[++e_cnt] = (Event){x, x, x, 0, i};
}
sort(es + 1, es + 1 + e_cnt);
priority_queue<Event> q;
for (int i = 1; i <= e_cnt; i++) {
Event& e = es[i];
if (e.type == 1) {
e.x = -e.r;
q.push(e);
} else if (q.size()) {
Event bri = q.top();
q.pop();
if (e.x <= bri.r) {
ans[bri.id] = e.id;
} else {
break;
}
}
}
bool ok = true;
for (int i = 1; i < N; i++)
if (!ans[i]) {
printf("No\n");
return 0;
}
printf("Yes\n");
for (int i = 1; i < N; i++) printf("%d ", ans[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long mint = 0x7fffffff;
const long long linf = 1000000000000000000LL;
const long long mod = 998244353LL;
const double eps = 1e-3;
const int N = 1000020;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int trie[N][26];
int q[N], s[N], a[N], b[N];
void dfs(int n) {
b[n] = min(b[n], a[n]);
if (s[n]) a[n] = min(a[n], b[n] + 1);
for (int i = 0; i < 26; i++) {
if (trie[n][i]) {
int now = trie[n][i];
a[now] = min(a[now], a[n] + 1);
b[now] = min(b[now], b[n] + s[n]);
dfs(now);
s[n] += s[now];
}
}
}
int main(void) {
int n = read();
for (int i = 1; i <= n; i++) {
trie[read()][getchar() - 'a'] = i;
}
int m = read();
for (int i = 0; i < m; i++) {
q[i] = read();
s[q[i]]++;
}
for (int i = 1; i <= N; i++) a[i] = b[i] = inf;
dfs(0);
for (int i = 0; i < m; i++) printf("%d%c", a[q[i]], i == m - 1 ? '\n' : ' ');
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long int sum = 0;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int i = 0, j = 0;
int m = INT_MIN;
while (i < n && j < n) {
if (a[i] > 0 && a[j] > 0) {
m = max(m, a[j]);
j++;
} else if (a[i] < 0 && a[j] < 0) {
m = max(m, a[j]);
j++;
} else {
sum += m;
m = INT_MIN;
i = j;
}
}
sum = sum + m;
cout << sum << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
istream& in = cin;
ostream& out = cout;
template <class T>
void outputArray(const vector<T>& ar, ostream& out) {
for (size_t i = 0; i < ar.size(); ++i) out << ar[i] << " ";
out << endl;
}
typedef struct Item* PItem;
struct Item {
Item(int val, int prior)
: value(val),
prior(prior),
cnt(0),
needReverse(false),
left(NULL),
right(NULL) {}
int prior, value, cnt;
bool needReverse;
PItem left, right;
};
int cnt(PItem item) {
if (item != NULL)
return item->cnt;
else
return 0;
}
void updateCnt(PItem item) {
if (item) item->cnt = cnt(item->left) + cnt(item->right) + 1;
}
void push(PItem item) {
if (item && item->needReverse) {
item->needReverse = false;
swap(item->left, item->right);
if (item->left) item->left->needReverse ^= true;
if (item->right) item->right->needReverse ^= true;
}
}
void split(PItem t, PItem& l, PItem& r, int key, int add = 0) {
if (t == NULL) return void(l = r = NULL);
push(t);
int cur_key = add + cnt(t->left);
if (key <= cur_key)
split(t->left, l, t->left, key, add), r = t;
else
split(t->right, t->right, r, key, add + 1 + cnt(t->left)), l = t;
updateCnt(t);
}
void merge(PItem& t, PItem l, PItem r) {
push(l);
push(r);
if (!l || !r)
t = l ? l : r;
else if (l->prior > r->prior)
merge(l->right, l->right, r), t = l;
else
merge(r->left, l, r->left), t = r;
updateCnt(t);
}
void reverse(PItem t, int l, int r) {
PItem t1, t2, t3;
split(t, t1, t2, l);
split(t2, t2, t3, r - l + 1);
if (t2) t2->needReverse ^= true;
merge(t, t1, t2);
merge(t, t, t3);
}
void shiftRight(PItem t, int l, int r) {
PItem a, b, c, d, lef, rgh;
split(t, a, b, r + 1);
split(a, c, d, l);
split(d, lef, rgh, r - l);
merge(a, c, rgh);
merge(b, lef, b);
merge(t, a, b);
}
void insert(PItem& t, int pos, PItem newIt) {
if (!t) {
t = newIt;
} else {
PItem t1, t2;
split(t, t1, t2, pos);
merge(t1, t1, newIt);
merge(t, t1, t2);
}
}
void search(PItem t, int pos, PItem& res, int add = 0) {
if (!t) {
res = NULL;
exit;
}
push(t);
int cur_key = add + cnt(t->left);
if (pos == cur_key) {
res = t;
return;
} else if (pos < cur_key)
search(t->left, pos, res, add);
else
search(t->right, pos, res, add + 1 + cnt(t->left));
}
void output(PItem t, vector<int>& res) {
if (t == NULL) return;
push(t);
output(t->left, res);
out << t->value << " ";
output(t->right, res);
}
struct ItemIdx {
int value;
int index;
ItemIdx(int value, int index) : value(value), index(index) {}
bool operator<(const ItemIdx& rhs) { return value < rhs.value; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
size_t n, q, m;
in >> n >> q >> m;
vector<ItemIdx> Ar;
int num;
for (size_t i = 0; i < n; ++i) {
in >> num;
Ar.push_back(ItemIdx(num, i));
}
PItem treap = NULL;
for (size_t i = 0; i < n; ++i) {
PItem item = new Item(Ar[i].value, Ar[i].value);
insert(treap, i, item);
}
for (size_t i = 0; i < q; ++i) {
size_t t, l, r;
in >> t >> l >> r;
if (t == 1)
shiftRight(treap, l - 1, r - 1);
else
reverse(treap, l - 1, r - 1);
vector<int> ans;
}
for (size_t i = 0; i < m; ++i) {
size_t pos;
PItem res;
in >> pos;
search(treap, pos - 1, res);
out << res->value << " ";
}
out << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int arr[3], a, b, c, sum = 0;
cin >> arr[0] >> arr[1] >> arr[2];
sort(arr, arr + 3);
c = arr[2];
b = arr[1];
a = arr[0];
if (c <= (a + b)) {
sum = (a + b + c) / 2;
cout << sum << endl;
} else
cout << a + b << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int N;
int min1, max1, min2, max2, min3, max3;
int res1, res2, res3;
int main() {
scanf("%d", &N);
scanf("%d%d", &min1, &max1);
scanf("%d%d", &min2, &max2);
scanf("%d%d", &min3, &max3);
res3 = min(max(N - max1 - max2, min3), max3);
N -= res3;
res2 = min(max(N - max1, min2), max2);
N -= res2;
res1 = N;
printf("%d %d %d", res1, res2, res3);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
const long long M = 1e9 + 7;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
void solve() {
int n;
scanf("%d", &n);
if (n == 3) {
puts("5");
return;
}
for (int i = 1; i; i += 2) {
if ((i * i + 1) / 2 >= n) {
printf("%d", i);
return;
}
}
}
int main() {
int t = 1;
for (int tt = 1; tt <= t; ++tt) {
solve();
puts("");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int baseres(const vector<int> &base, int v) {
for (auto x : base) v = min(v, v ^ x);
return v;
}
int baseres(const vector<int> &base, int len, int v) {
for (int i = 0; i < len; ++i) v = min(v, v ^ base[i]);
return v;
}
vector<int> baseof(const vector<int> &sum) {
vector<int> b;
int n = sum.size();
for (int i = 0; i < n; ++i) {
int v = baseres(b, sum[i]);
if (v) {
if (bool byYourChoice = 1)
b.push_back(v);
else
b.push_back(sum[i]);
}
}
return b;
}
const int INT_BITS = 32;
int maxSubarrayXORMy(vector<int> set) {
int n = set.size();
int cur = 0;
vector<int> b = baseof(set);
for (int i = INT_BITS - 1; i >= 0; --i) {
int ncur = cur + (1 << i);
if (baseres(b, ncur) < (1 << i)) {
cur = ncur;
}
}
return cur;
}
int maxSubarrayXOR(vector<int> set) {
int n = set.size();
int index = 0;
for (int i = INT_BITS - 1; i >= 0; i--) {
int maxInd = index;
int maxEle = INT_MIN;
for (int j = index; j < n; j++) {
if ((set[j] & (1 << i)) != 0 && set[j] > maxEle)
maxEle = set[j], maxInd = j;
}
if (maxEle == INT_MIN) continue;
swap(set[index], set[maxInd]);
maxInd = index;
for (int j = 0; j < n; j++) {
if (j != maxInd && (set[j] & (1 << i)) != 0)
set[j] = set[j] ^ set[maxInd];
}
index++;
}
int res = 0;
for (int i = 0; i < n; i++) res ^= set[i];
return res;
}
long long mod = 1e9 + 7;
long long mypow(long long a, long long n) {
long long res = 1;
long long base = a;
while (n > 0) {
if (n % 2) res = res * base % mod;
base = base * base % mod;
n = n / 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, q;
cin >> n >> q;
vector<int> a(n);
for (int &i : a) cin >> i;
vector<int> b;
vector<int> len(n);
for (int i = 0; i < n; ++i) {
int r = baseres(b, a[i]);
if (r) b.push_back(r);
len[i] = b.size();
}
while (q--) {
int l, x;
cin >> l >> x;
if (l == 0) {
if (x == 0)
cout << 1 << "\n";
else
cout << 0 << "\n";
} else {
int rlen = len[l - 1];
if (baseres(b, rlen, x))
cout << "0\n";
else
cout << (mypow(2, l - rlen)) << "\n";
}
}
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
scanf("%d", &n);
int maxi = 0;
int arr[n];
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
int i;
for (i = n - 1; i > 0 && arr[i - 1] >= arr[i]; i--)
;
for (; i > 0 && arr[i - 1] <= arr[i]; i--)
;
printf("%d\n", i);
return;
}
int main() {
int t, z = 1;
scanf("%d", &t);
while (z <= t) {
solve();
z++;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 5;
const long long mod = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
srand(time(0));
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
n *= 3;
bool used[n];
for (long long i = 0; i < n; i++) used[i] = 0;
vector<pair<long long, long long> > edg;
for (long long i = 0; i < m; i++) {
long long u, v;
cin >> u >> v;
edg.push_back({v - 1, u - 1});
}
vector<long long> ans;
for (long long i = 0; i < m; i++) {
if (!used[edg[i].first] && !used[edg[i].second]) {
used[edg[i].first] = 1;
used[edg[i].second] = 1;
ans.push_back(i);
}
}
if (ans.size() >= n / 3) {
cout << "Matching\n";
for (long long i = 0; i < n / 3; i++) cout << ans[i] + 1 << ' ';
} else {
cout << "IndSet\n";
long long kek = 0;
for (long long i = 0; i < n; i++) {
if (!used[i]) {
cout << i + 1 << ' ';
kek++;
}
if (kek == n / 3) break;
}
}
cout << '\n';
}
return 0;
}
| 12 |
Subsets and Splits