solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int N = 1e5 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
double ans = 0;
for (int i = n; i >= 1; --i) {
ans += (double)1 / i;
}
cout << setprecision(6) << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<int, int>;
using vi = vc<int>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
return os << vc<t>(first.begin(), first.end());
}
template <int i, class T>
void print_tuple(ostream&, const T&) {}
template <int i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
template <class t>
void print(t x, int suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(int n, int off = 0) {
vi v(n);
for (int i = int(0); i < int(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, int suc = 1) {
for (int i = int(0); i < int(v.size()); i++)
print(v[i], i == int(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes"
<< "\n";
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No"
<< "\n";
if (ex) exit(0);
}
void possible(bool ex = true) {
cout << "Possible"
<< "\n";
if (ex) exit(0);
}
void impossible(bool ex = true) {
cout << "Impossible"
<< "\n";
if (ex) exit(0);
}
constexpr ll ten(int n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const int inf = INT_MAX / 2 - 100;
int topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
int topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
int botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
int botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
int popcount(signed t) { return __builtin_popcount(t); }
int popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(int i) { return i && (i & -i) == i; }
ll mask(int i) { return (ll(1) << i) - 1; }
bool inc(int first, int second, int c) {
return first <= second && second <= c;
}
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
void myshuffle(vc<t>& first) {
for (int i = int(0); i < int(int(first.size())); i++)
swap(first[i], first[rand_int(0, i)]);
}
template <class t>
int lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
struct unionfind {
vi p, s;
int c;
unionfind(int n = 0) : p(n, -1), s(n, 1), c(n) {}
int find(int first) {
return p[first] == -1 ? first : (p[first] = find(p[first]));
}
bool unite(int first, int second) {
first = find(first);
second = find(second);
if (first == second) return false;
p[second] = first;
s[first] += s[second];
c--;
return true;
}
bool same(int first, int second) { return find(first) == find(second); }
int sz(int first) { return s[find(first)]; }
};
template <class t>
vi toposort(vvc<t> g) {
int n = g.size();
vi first(n);
for (int i = int(0); i < int(n); i++)
for (auto e : g[i]) first[e]++;
queue<int> q;
for (int i = int(0); i < int(n); i++)
if (first[i] == 0) q.push(i);
vi res;
for (int i = int(0); i < int(n); i++) {
if (q.empty()) return {};
int v = q.front();
q.pop();
res.push_back(v);
for (auto e : g[v])
if (--first[e] == 0) q.push(e);
}
return res;
}
template <class E>
struct HLD {
vvc<E> g;
int n, rt, cnt;
vi sub, in, out, par, head, dep;
int dfs1(int v, int p, int d) {
par[v] = p;
dep[v] = d;
g[v].erase(remove(g[v].begin(), g[v].end(), p), g[v].end());
for (auto& e : g[v]) {
sub[v] += dfs1(e, v, d + 1);
if (sub[g[v][0]] < sub[e]) swap(g[v][0], e);
}
return sub[v];
}
void dfs2(int v, int h) {
in[v] = cnt++;
head[v] = h;
for (int to : g[v]) dfs2(to, to == g[v][0] ? h : to);
out[v] = cnt;
}
HLD() {}
HLD(const vvc<E>& gg, int rr)
: g(gg),
n(g.size()),
rt(rr),
cnt(0),
sub(n, 1),
in(n),
out(n),
par(n, -1),
head(n),
dep(n) {
dfs1(rt, -1, 0);
dfs2(rt, rt);
}
int lca(int first, int second) {
while (head[first] != head[second]) {
if (dep[head[first]] > dep[head[second]]) swap(first, second);
second = par[head[second]];
}
if (dep[first] > dep[second]) swap(first, second);
return first;
}
int len(int first, int second) {
return dep[first] + dep[second] - dep[lca(first, second)] * 2;
}
bool asde(int first, int second) {
return in[first] <= in[second] && out[second] <= out[first];
}
unionfind uf;
vi has, dif;
int k;
vc<pi> buf;
int ac(int v) { return uf.find(v * 2) / 2; }
vi memo;
int dfs(int v) {
for (auto to : g[v]) {
memo[to] = dfs(to);
}
buf[ac(v)] = pi(0, k);
for (auto to : g[v]) {
buf[ac(to)] = pi(0, k);
}
for (auto to : g[v]) {
int w = memo[to];
if (w == inf) return inf;
int i = uf.find(to * 2);
int t = i % 2;
i /= 2;
if (!has[i]) continue;
if (t == 0) {
chmax(buf[i].first, w + 1);
} else {
chmin(buf[i].second, k - w - 1);
}
if (buf[i].second < buf[i].first) return inf;
}
for (int waf = int(0); waf < int(2); waf++) {
int vac = uf.find(v * 2);
int vt = vac % 2;
vac /= 2;
int lw, up;
tie(lw, up) = buf[vac];
if (vt) {
tie(lw, up) = pi(k - up, k - lw);
}
for (auto to : g[v]) {
int i = uf.find(to * 2);
int t = i % 2;
i /= 2;
if (!has[i]) continue;
dif[to] = t;
if (i == vac) {
dif[to] ^= vt;
continue;
}
int l, r;
tie(l, r) = buf[i];
if ((k - r < l) ^ waf) {
tie(l, r) = pi(k - r, k - l);
dif[to] ^= 1;
}
chmax(lw, l);
chmin(up, r);
}
if (lw <= up) {
void(0);
return lw;
}
}
return inf;
}
void geth(int v, int p, int t, vvc<int>& h) {
if (has[ac(v)]) {
if (t == 0) {
h[v].push_back(p);
} else {
h[p].push_back(v);
}
}
for (auto to : g[v]) {
geth(to, v, t ^ dif[to], h);
}
}
void slv(int m) {
uf = unionfind(n * 2);
auto unitesub = [&](int v, int p) {
while (1) {
v = ac(v);
void(0);
if (dep[v] - dep[p] >= 2) {
void(0);
for (int t = int(0); t < int(2); t++) {
uf.unite(par[v] * 2 + t, v * 2 + t);
}
v = par[v];
} else
break;
}
};
vi ls;
vc<pi> es;
for (int _ = int(0); _ < int(m); _++) {
int first, second;
cin >> first >> second;
first--;
second--;
int c = lca(first, second);
unitesub(first, c);
unitesub(second, c);
if (first != c && second != c) {
es.emplace_back(first, second);
}
if (first != c)
ls.push_back(first);
else
ls.push_back(second);
}
for (auto e : es) {
for (int t = int(0); t < int(2); t++) {
uf.unite(e.first * 2 + t, e.second * 2 + 1 - t);
}
}
has.resize(n);
for (auto i : ls) has[ac(i)] = 1;
for (int i = int(0); i < int(n); i++)
if (uf.same(i * 2, i * 2 + 1)) {
print(-1);
return;
}
dif.resize(n);
buf.resize(n);
memo.resize(n);
int lw = -1, up = n - 1;
while (up - lw > 1) {
const int mid = (lw + up) / 2;
k = mid;
if (dfs(0) < inf)
up = mid;
else
lw = mid;
}
k = up;
void(0);
int tmp = dfs(0);
void(0);
assert(tmp < inf);
void(0);
vvc<int> h(n);
geth(0, -1, 0, h);
void(0);
void(0);
void(0);
vi ans(n);
vi ord = toposort(h);
for (auto i : ord) {
for (auto j : h[i]) chmax(ans[j], ans[i] + 1);
}
for (auto& v : ans) v++;
print(k + 1);
print(ans);
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
int n, m;
cin >> n >> m;
vvc<int> t(n);
for (int _ = int(0); _ < int(n - 1); _++) {
int first, second;
cin >> first >> second;
first--;
second--;
t[first].push_back(second);
t[second].push_back(first);
}
HLD<int> hld(t, 0);
hld.slv(m);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + "," +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug() { cerr << endl; }
template <typename Head, typename... Tail>
void debug(Head H, Tail... T) {
cerr << " " << to_string(H);
debug(T...);
}
struct fast_power {
long long integer(long long n, long long e,
long long my_mod = 9223372036854775807LL) {
long long ans = 1;
while (e) {
if (e & 1)
ans = (ans * n) % my_mod, e--;
else
n = (n * n) % my_mod, e >>= 1;
}
return ans;
}
long long matrix(vector<vector<long long>> &n, long long e,
long long my_mod = 9223372036854775807LL);
};
struct euclidean {
int gcdi(int a, int b) { return b ? gcdi(b, a % b) : a; }
double gcdf(double a, double b, double accuracy) {
return b <= accuracy ? a : gcdf(b, fmod(a, b), accuracy);
}
};
const int INF = 0x3f3f3f3f;
const int maxn = 300 + 5;
int arr[maxn][maxn] = {0};
vector<int> G[maxn];
int a[maxn];
int brr[maxn] = {0}, num;
void dfs1(int n, int pre) {
if (brr[n]) arr[n][n] = 1;
int pos = -1;
for (int i = 0; i < G[n].size(); i++)
if (G[n][i] == pre) pos = i;
if (pos != -1) swap(G[n][pos], G[n][G[n].size() - 1]);
for (int i = 0; i < G[n].size(); i++) {
if (G[n][i] == pre) continue;
dfs1(G[n][i], n);
for (int q = 1; q <= num; q++) arr[n][q] |= arr[G[n][i]][q];
}
}
int ok = 1, cnt = 0;
vector<int> ans;
int vis[maxn] = {0};
int crr[maxn] = {0};
void dfs2(int n, int pre) {
if (vis[n] >= crr[n]) return;
vis[n]++;
ans.push_back(n);
if (!arr[n][a[cnt]]) {
for (int i = 0; i < G[n].size(); i++) dfs2(G[n][i], n);
} else {
if (n == a[cnt]) {
cnt++;
for (int i = 0; i < G[n].size(); i++) {
dfs2(G[n][i], n);
}
} else {
while (1) {
int f = 1;
for (int i = 0; i < G[n].size(); i++) {
if (G[n][i] == pre) continue;
if (arr[G[n][i]][a[cnt]]) {
f = 0;
int s = G[n][i];
G[n].erase(G[n].begin() + i, G[n].begin() + i + 1);
dfs2(s, n);
break;
}
}
if (f) break;
}
for (int i = 0; i < G[n].size(); i++) dfs2(G[n][i], n);
}
}
}
int getnum(int n, int pre) {
int num = 0, f = 1;
for (int i = 0; i < G[n].size(); i++)
if (G[n][i] != pre) f = 0, num += getnum(G[n][i], n);
return num + f;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> num;
for (int i = 0; i < num - 1; i++) {
int f1, f2;
cin >> f1 >> f2;
G[f1].push_back(f2), G[f2].push_back(f1);
crr[f1]++, crr[f2]++;
}
int k = getnum(1, -1);
for (int i = 0; i < k; i++) cin >> a[i], brr[a[i]] = 1;
a[k] = 0;
dfs1(1, -1);
dfs2(1, -1);
if (cnt == k) {
ans.push_back(1);
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << endl;
} else
cout << -1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
int A[303030], B[303030];
signed long long dp[303030][2];
void solve() {
int i, j, k, l, r, x, y;
string s;
scanf("%d%d", &N, &K);
for (i = 0; i < (N); i++) scanf("%d", &A[i]);
for (i = 0; i < (N); i++) scanf("%d", &B[i]);
for (i = 0; i < (N); i++) {
dp[i + 1][0] = dp[i + 1][1] = K + 1;
signed long long miT = 1 + (B[i] / K);
signed long long maT = 1LL * (B[i] + 1) * K;
signed long long miF = 1 + (B[i] / K);
signed long long maF = 1LL * (B[i] + 1) * K;
if (dp[i][0] <= K) {
x = K - dp[i][0];
signed long long mi = (B[i] + K - 1) / K;
signed long long mai = 1LL * (B[i] - 1) * K + x;
if (A[i] >= mi) dp[i + 1][0] = min(dp[i + 1][0], max(1LL, A[i] - mai));
mi = (A[i] + dp[i][0] + K - 1) / K;
mai = 1LL * A[i] * K;
if (B[i] >= mi) dp[i + 1][1] = min(dp[i + 1][1], max(1LL, B[i] - mai));
}
if (dp[i][1] <= K) {
x = K - dp[i][1];
signed long long mi = (A[i] + K - 1) / K;
signed long long mai = 1LL * (A[i] - 1) * K + x;
if (B[i] >= mi) dp[i + 1][1] = min(dp[i + 1][1], max(1LL, B[i] - mai));
mi = (B[i] + dp[i][1] + K - 1) / K;
mai = 1LL * B[i] * K;
if (A[i] >= mi) dp[i + 1][0] = min(dp[i + 1][0], max(1LL, A[i] - mai));
}
}
if (dp[N][0] > K && dp[N][1] > K)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
cout.tie(0);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int p[5005], cnt[5005], qwq[5005];
vector<int> v;
int main(int argc, char** argv) {
int n;
srand((unsigned long long)new char);
cin >> n;
for (int i = 1; i <= n; i++) p[i] = i - 1;
for (int i = 1; i <= n; i++) cnt[i] = cnt[i ^ i & -i] + 1;
random_shuffle(p + 1, p + n + 1);
int x = 0, now = 0;
while (1) {
int a, b;
do a = rand() % n, b = rand() % n;
while (a == b);
cout << "? " << a + 1 << " " << b + 1 << endl;
int t;
cin >> t;
if (cnt[t] <= 6) {
x = a + 1;
break;
}
}
now = 2047;
for (int i = 1; i <= n; i++) {
if (x != i) {
cout << "? " << x << " " << i << endl;
cin >> qwq[i];
now &= qwq[i];
}
}
qwq[x] = now;
for (int i = 1; i <= n; i++)
if (qwq[i] == now) v.push_back(i);
int pos = 0;
if (v.size() == 1)
pos = x;
else if (v.size() == 2) {
if (v[0] != x)
pos = v[0];
else
pos = v[1];
} else {
while (1) {
int a;
do a = v[rand() % v.size()];
while (a == x);
for (auto t : v) {
if (a != t) {
cout << "? " << a << " " << t << endl;
cin >> qwq[t];
now &= qwq[t];
}
}
qwq[a] = now;
v.clear();
for (int i = 1; i <= n; i++)
if (qwq[i] == now) v.push_back(i);
if (v.size() == 2) {
if (v[0] != a)
pos = v[0];
else
pos = v[1];
break;
} else if (v.size() == 1) {
pos = a, qwq[a] = 0;
break;
}
x = a;
}
}
qwq[pos] = 0;
for (int i = 1; i <= n; i++) {
if (i != pos) {
cout << "? " << i << " " << pos << endl;
cin >> qwq[i];
}
}
cout << "! ";
for (int i = 1; i <= n; i++) cout << qwq[i] << " ";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXH = 8 + 2;
const int MAXW = 8 + 2;
char G[MAXH][MAXW];
int has_stat[MAXH][MAXH][MAXW];
const int dy[] = {0, 1, 0, 1, -1, 0, 1, -1, -1};
const int dx[] = {-1, 0, 0, -1, -1, 1, 1, 0, 1};
int vis[2 * MAXH][MAXH][MAXW];
bool outOfRange(int x, int y) { return x < 0 || x >= 8 || y < 0 || y >= 8; }
void solve() {
for (int i = 0; i < 8; ++i)
for (int j = 0; j < 8; ++j)
if (G[i][j] == 'S')
for (int k = 0; i + k < 8; ++k) has_stat[k][i + k][j] = 1;
queue<pair<int, int> > que;
que.push(pair<int, int>(0, 7 * MAXW + 0));
vis[0][7][0] = 1;
while (!que.empty()) {
int t = que.front().first;
int x = que.front().second / MAXW;
int y = que.front().second % MAXW;
que.pop();
if (x == 0 && y == 7) return (void)puts("WIN");
for (int di = 0; di < 9; ++di) {
int nx = x + dx[di];
int ny = y + dy[di];
if (outOfRange(nx, ny)) continue;
if (has_stat[t][nx][ny] || has_stat[t + 1][nx][ny]) continue;
if (vis[t + 1][nx][ny]) continue;
vis[t + 1][nx][ny] = 1;
que.push(pair<int, int>(t + 1, nx * MAXW + ny));
}
}
puts("LOSE");
}
int main() {
for (int i = 0; i < 8; ++i) scanf("%s", G[i]);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
int n, m, v;
inline void print(int a, int b) {
if (a == n - 1)
a = v;
else if (a == v)
a = n - 1;
if (b == n - 1)
b = v;
else if (b == v)
b = n - 1;
printf("%d %d\n", a, b);
}
int main() {
int i;
scanf("%d%d%d", &n, &m, &v);
if (m < n - 1 || m - 1 > ((long long)(n - 1) * (n - 2) / 2))
printf("-1\n");
else {
for (i = 1; i < n; ++i) {
print(i, i + 1);
--m;
}
if (m == 0) goto OVER;
int k;
for (i = 1; i < n - 2; ++i) {
for (k = i + 2; k < n; ++k) {
print(i, k);
--m;
if (m == 0) goto OVER;
}
}
OVER:;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long expo(long long x, long long n, long long m) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return expo((x * x) % m, n / 2, m);
else
return (x * expo((x * x) % m, (n - 1) / 2, m)) % m;
}
string toBinary(long long n) {
std::string r;
while (n != 0) {
r = (n % 2 == 0 ? "0" : "1") + r;
n /= 2;
}
return r;
}
vector<long long> adj[100005];
vector<long long> colour[105];
long long visit[100005];
long long a[100005][105];
void solve() {
long long n, m, k, s;
cin >> n >> m >> k >> s;
for (long long i = 1; i <= n; i++) {
long long t;
cin >> t;
colour[t].push_back(i);
}
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (long long c = 1; c <= k; c++) {
memset(visit, 0, sizeof(visit));
;
queue<pair<long long, long long> > q;
for (long long i : colour[c]) {
visit[i] = 1;
q.push({i, 0});
}
while (!q.empty()) {
pair<long long, long long> x = q.front();
q.pop();
for (long long i : adj[x.first]) {
if (visit[i] == 0) {
visit[i] = 1;
a[i][c] = x.second + 1;
q.push({i, a[i][c]});
}
}
}
}
for (long long i = 1; i <= n; i++) {
sort(a[i] + 1, a[i] + 1 + k);
long long ans = 0;
for (long long j = 1; j <= s; j++) ans += a[i][j];
cout << ans << " ";
}
cout << endl;
return;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const signed inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T>
long long chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
long long chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T mmin(T a, T b) {
return a < b ? a : b;
}
template <class T>
T mmax(T a, T b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
long long dcmp(T a, T b) {
return a > b;
}
template <long long *a>
long long cmp_a(long long first, long long second) {
return a[first] < a[second];
}
namespace io {
const long long SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
long long f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
inline void read(signed &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
}
inline void read(long long &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
}
inline void read(char &first) {
first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
inline void read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
while (!(*first == '\n' || *first == ' ' || *first == '\r'))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
}
template <typename A, typename... B>
inline void read(A &first, B &...second) {
read(first);
read(second...);
}
inline void write(signed first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
}
inline void write(long long first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
}
inline void write(char first) { putc(first); }
inline void write(const char *first) {
while (*first) {
putc(*first);
++first;
}
}
inline void write(char *first) {
while (*first) {
putc(*first);
++first;
}
}
template <typename A, typename... B>
inline void write(A first, B... second) {
write(first);
write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
long long c0, c1, n;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lls[31];
long long C(long long a, long long b) {
long long s = 1, first, g;
for (long long i = 1; i <= b; ++i) lls[i] = i;
for (long long i = 0; i < b; ++i) {
first = a + b - i;
for (long long j = 1; j <= b; ++j) {
g = gcd(lls[j], first);
first /= g;
lls[j] /= g;
}
if (first > inf / s) return inf;
s *= first;
}
return s;
}
long long check(long long first) {
long long tmp = first / c0 + first / c1 + 1;
if (tmp > n) return 1;
for (long long i = 1; i <= 26; ++i) {
for (long long j = i; j * c0 + i * c1 <= first; ++j) {
tmp += C(j, i);
if (tmp > n) return 1;
}
for (long long j = i + 1; j * c1 + i * c0 <= first; ++j) {
tmp += C(j, i);
if (tmp > n) return 1;
}
}
return 0;
}
void Work(long long first, long long &tmp, long long &ans) {
tmp = first / c0 + first / c1 + 1;
ans = ((first / c0) * (first / c0 + 1) * c0 +
(first / c1) * (first / c1 + 1) * c1) >>
1;
long long c;
for (long long i = 1; i <= 26; ++i) {
for (long long j = i; j * c0 + i * c1 <= first; ++j) {
c = C(j, i);
tmp += c;
ans += c * (j * c0 + i * c1);
}
for (long long j = i + 1; j * c1 + i * c0 <= first; ++j) {
c = C(j, i);
tmp += c;
ans += c * (j * c1 + i * c0);
}
}
}
int main() {
read(n, c0, c1);
--n;
if (c0 > c1) swap(c0, c1);
if (!c0)
printf("%lld\n", n * c1);
else {
long long l = 0, r = c1 * 26, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
long long c, s;
Work(l - 1, c, s);
s += (n - c) * l + n * (c0 + c1);
printf("%lld\n", s);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long n;
int arr[5001][2];
int nbr[5001][2];
int mkd[5001][2];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cout << "? " << 0 << " " << i << endl;
cin >> arr[i][0];
cout << "? " << i << " " << 0 << endl;
cin >> arr[i][1];
}
int ans = 0, pb0;
for (int b0 = 0; b0 < n; b0++) {
int k = 1;
memset(mkd, 0, sizeof mkd);
for (int i = 0; i < n; i++) {
nbr[i][0] = b0 ^ arr[i][1];
if (nbr[i][0] >= n || mkd[nbr[i][0]][0]) {
k = 0;
break;
}
mkd[nbr[i][0]][0] = 1;
}
if (!k) continue;
for (int i = 0; i < n; i++) {
nbr[i][1] = nbr[0][0] ^ arr[i][0];
if (nbr[i][1] >= n || mkd[nbr[i][1]][1]) {
k = 0;
break;
}
mkd[nbr[i][1]][1] = 1;
}
for (int i = 0; i < n; i++) {
if (nbr[nbr[i][0]][1] != i) k = 0;
}
if (b0 != nbr[0][1]) k = 0;
ans += k;
if (k) pb0 = b0;
}
cout << "!\n" << ans << "\n";
for (int i = 0; i < n; i++) cout << (pb0 ^ arr[i][1]) << " ";
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using dd = long double;
namespace {
static bool constexpr dbg = 0;
ll constexpr N = 1.1e5, MO = 1e9 + 7;
ll n, x, a[N];
ll power(ll x, ll pw) {
ll ret = 1;
for (ll i = 1; i <= pw; i <<= 1, x = x * x % MO)
if (pw & i) ret = ret * x % MO;
return ret;
}
void init() {
cin >> n >> x;
for (ll i = 1; i <= (ll)(n); ++i) cin >> a[i];
}
void solve() {
ll sum = 0;
for (ll i = 1; i <= (ll)(n); ++i) sum += a[i];
if (sum == 0 || n == 1) {
cout << 1;
return;
}
map<ll, ll> mp;
for (ll i = 1; i <= (ll)(n); ++i) ++mp[sum - a[i]];
ll t;
for (;;) {
auto iter = mp.begin();
t = iter->first;
ll cnt = iter->second;
mp.erase(iter);
if (cnt % x)
break;
else {
mp[t + 1] += cnt / x;
}
}
cout << power(x, min(t, sum));
}
void test() {
if (dbg) {
}
}
} // namespace
int main() {
if (!dbg) {
std::ios::sync_with_stdio(false);
cin.tie(nullptr);
}
cout << fixed << setprecision(20);
init();
solve();
test();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n % 2 == 0)
cout << -1;
else {
for (int i = 0; i < n; i++) cout << i << " ";
cout << endl;
for (int i = 1; i < n; i++) cout << i << " ";
cout << 0 << endl;
for (int i = 1; i < n; i++) cout << (i + i - 1) % n << " ";
cout << n - 1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Vi = vector<int>;
using Pii = pair<int, int>;
int uplg(int n) { return 32 - __builtin_clz(n); }
int uplg(ll n) { return 64 - __builtin_clzll(n); }
void run();
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(18);
run();
return 0;
}
void run() {
int n;
cin >> n;
vector<ll> elems(n);
for (auto& e : (elems)) cin >> e;
vector<pair<ll, ll>> kek;
for (auto& e : (elems)) {
ll three = 0;
ll tmp = e;
while (tmp % 3 == 0) {
three++;
tmp /= 3;
}
kek.push_back({-three, e});
}
sort((kek).begin(), (kek).end());
for (auto& e : (kek)) cout << e.second << ' ';
cout << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, r, c, row[12], col[12];
char a[12][12];
cin >> r >> c;
for (i = 0; i < r; i++) cin >> a[i];
memset(row, 0, sizeof(int) * r);
memset(col, 0, sizeof(int) * c);
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
if (a[i][j] == 'S') {
row[i] = 1;
col[j] = 1;
}
}
}
int cnt_r = 0, cnt_c = 0;
for (i = 0; i < r; i++)
if (row[i] == 1) cnt_r++;
for (i = 0; i < c; i++)
if (col[i] == 1) cnt_c++;
cout << (r * c) - (cnt_r * cnt_c);
return 0;
}
| 0 |
#include <bits/stdc++.h>
struct data {
int val;
int pos;
int ranks;
} p[2005];
bool cmp1(const data &a, const data &b) {
if (a.val == b.val) return a.pos < b.pos;
return a.val < b.val;
}
bool cmp2(const data &a, const data &b) { return a.val > b.val; }
bool cmp3(const data &a, const data &b) { return a.pos < b.pos; }
const double pi = acos(-1.0);
const long long mod = 1e9 + 7;
using namespace std;
int main() {
int N;
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d", &p[i].val);
p[i].pos = i;
}
sort(p + 1, p + N + 1, cmp2);
for (int i = 1; i <= N; i++)
p[i].ranks = lower_bound(p + 1, p + N + 1, p[i], cmp2) - p;
sort(p + 1, p + N + 1, cmp3);
for (int i = 1; i < N; i++) printf("%d ", p[i].ranks);
printf("%d\n", p[N].ranks);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef class Edge {
public:
int u, v;
long long w;
Edge() {}
Edge(int u, int v, long long w) : u(u), v(v), w(w) {}
void read() { scanf("%d%d%lld", &u, &v, &w); }
bool operator<(Edge b) const { return w < b.w; }
} Edge;
typedef class Node {
public:
int p;
long long d;
int org;
Node(int p, long long d, int org) : p(p), d(d), org(org) {}
bool operator<(Node b) const { return d > b.d; }
} Node;
const long long llf = (~0ull >> 2);
const int N = 1e5 + 5;
int n, m;
bool iskey[N];
vector<pair<int, int> > G[N];
vector<Edge> E, E0;
long long f[N];
int g[N];
void dijkstra() {
priority_queue<Node> Q;
for (int i = 1; i <= n; i++) {
if (iskey[i]) {
Q.push(Node(i, f[i] = 0, g[i] = i));
} else {
f[i] = llf;
}
}
while (!Q.empty()) {
Node e = Q.top();
Q.pop();
if (e.d ^ f[e.p]) continue;
for (auto _ : G[e.p]) {
int q = _.first;
int w = _.second;
if (f[e.p] + w < f[q]) {
Q.push(Node(q, f[q] = f[e.p] + w, g[q] = e.org));
}
}
}
}
int uf[N];
int find(int x) { return uf[x] == x ? (x) : (uf[x] = find(uf[x])); }
long long kruskal() {
for (int i = 1; i <= n; i++) uf[i] = i;
sort(E.begin(), E.end());
long long ret = 0;
for (auto e : E) {
int u = find(e.u), v = find(e.v);
if (u ^ v) {
uf[u] = v;
ret += e.w;
}
}
return ret;
}
int main() {
scanf("%d%d", &n, &m);
E0.resize(m);
for (int i = 0; i < m; i++) {
E0[i].read();
G[E0[i].u].emplace_back(E0[i].v, (int)E0[i].w);
G[E0[i].v].emplace_back(E0[i].u, (int)E0[i].w);
}
int cnt, x;
scanf("%d", &cnt);
while (cnt--) {
scanf("%d", &x);
iskey[x] = true;
}
dijkstra();
for (auto e : E0) {
if (g[e.u] ^ g[e.v]) {
E.emplace_back(g[e.u], g[e.v], f[e.u] + f[e.v] + e.w);
}
}
long long ans = kruskal() + f[1];
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << " ";
err(++it, args...);
}
long long mod(long long x, long long m = 1000000007) { return x % m; }
long long power(long long x, long long y, long long p = 1000000007) {
x %= p;
long long val = 1;
while (y) {
if (y & 1LL) val = (val * x) % p;
y >>= 1LL;
x = (x * x) % p;
}
return val;
}
long long a[101];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, x;
cin >> n >> k >> x;
long long sum = 0;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (i >= n - k + 1) a[i] = x;
sum += a[i];
}
cout << sum << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long md = 1e9 + 7;
long long n, k;
vector<int> primes;
bool isprime[1 << 20];
int main() {
fill_n(isprime, 1 << 20, 1);
for (int i = 2; i <= 1024; ++i)
if (isprime[i]) {
for (int j = i * i; j < 1 << 20; j += i) isprime[j] = 0;
}
for (int i = 2; i < 1 << 20; ++i)
if (isprime[i]) primes.push_back(i);
cin >> n >> k;
for (k = (k + 1) / 2; k-- && n > 1;) {
map<long long, long long> div;
for (auto p : primes)
if (n % p == 0) {
div[p] = 1;
for (; n % p == 0; n /= p) div[p] *= p;
}
if (n > 1) div[n] = n, n = 1;
for (auto [p, pn] : div) n *= (pn - pn / p);
}
cout << n % md << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 333;
const long long linf = 1e18 + 333;
const int mod = 1e9 + 7;
bool h[1000005];
int pws[1000005];
int p, k;
int pw(int x, int k) {
int res = 1;
while (k) {
if (k & 1) res = (long long)res * x % mod;
x = (long long)x * x % mod;
k >>= 1;
}
return res;
}
int main() {
scanf("%d %d", &p, &k);
pws[0] = 1;
for (int i = 1; i <= p; i++) pws[i] = (long long)pws[i - 1] * k % p;
if (!k) {
printf("%d\n", pw(p, p - 1));
} else if (k == 1) {
printf("%d\n", pw(p, p));
} else {
int ans = 1;
for (int i = 1; i < p; i++) {
if (!h[i]) {
int x = i, cnt = 0;
do {
cnt++;
h[x] = 1;
x = (long long)x * k % p;
} while (!h[x]);
if (pws[cnt] == 1) ans = (long long)ans * p % mod;
}
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
long long mana = 0;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
vector<long long> v;
long long i = 0;
for (i = 0; i < n - 2; i++) {
if (a[i] != a[i + 1]) {
if (a[i] == a[i + 2]) {
v.push_back(a[i]);
v.push_back(a[i + 2]);
} else {
v.push_back(a[i + 1]);
v.push_back(a[i + 2]);
}
i += 2;
} else {
v.push_back(a[i]);
v.push_back(a[i + 1]);
i++;
}
}
if (i == n - 2 && a[i] != a[i + 1]) v.push_back(0);
if (i == n - 2 && a[i] == a[i + 1]) {
v.push_back(a[i]);
v.push_back(a[i + 1]);
} else if (i == n - 1 && a[i] == 0)
v.push_back(0);
cout << v.size() << "\n";
for (long long k = 0; k < v.size(); k++) cout << v[k] << " ";
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void f() {
int T;
cin >> T;
for (int i = 0; i < T; i++) {
int n, m;
cin >> n >> m;
vector<bool> covered(3 * n + 1);
int uncovered = 3 * n;
vector<int> matching;
for (int j = 0; j < m; j++) {
int u, v;
cin >> u >> v;
if (covered[u] == 0 && covered[v] == 0) {
matching.push_back(j + 1);
covered[u] = 1;
covered[v] = 1;
uncovered -= 2;
}
}
if (matching.size() >= n) {
cout << "Matching" << endl;
for (int j = 0; j < n; j++) {
cout << matching[j];
if (j != n - 1) cout << " ";
}
} else if (uncovered >= n) {
int printed = 0;
cout << "IndSet" << endl;
for (int j = 1; j <= 3 * n; j++) {
if (covered[j] == 0) {
cout << j;
if (printed != n - 1) cout << " ";
printed++;
}
if (printed == n) break;
}
} else
cout << "Impossible";
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
f();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using f64 = double;
using pii = pair<int, int>;
using pll = pair<i64, i64>;
vector<i64> b, a;
int n;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
bool flag;
int p = 0;
cin >> n;
b.resize(n);
for (auto &i : b) cin >> i;
for (int i = 0; i < n; ++i)
if (b[i] > b[p]) p = i;
if (b[p] == 0) {
cout << "YES\n";
for (int i = 1; i <= n; ++i) cout << 1 << " \n"[i == n];
return 0;
}
if (b[p] != 0 &&
*max_element(begin(b), end(b)) == *min_element(begin(b), end(b))) {
cout << "NO\n";
return 0;
}
while (b[p] == b[(p - 1 + n) % n]) p = (p - 1 + n) % n;
flag = false;
a.resize(n);
a[p] = b[p];
for (int lst, ptr = p, i = 1; i < n; ++i) {
lst = ptr;
ptr = (ptr + n - 1) % n;
if (b[ptr] == 0 && !flag) {
a[ptr] = a[lst] * 2;
flag = true;
} else
a[ptr] = a[lst] + b[ptr];
}
flag = true;
for (int t = 1, i = 0; i < n; ++i, t = (t + 1) % n)
if (a[t] == 0 || a[i] % a[t] != b[i]) flag = false;
if (flag) {
cout << "YES\n";
for (int i = 0; i < n; ++i) cout << a[i] << " \n"[i == n - 1];
} else
cout << "NO\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, w, e, r, t, a[26][26];
char c, v, d[100001], f[100001];
for (w = 0; w < 26; w++)
for (e = 0; e < 26; e++)
if (w == e)
a[w][e] = 0;
else
a[w][e] = 100000;
scanf("%s%s", d, f);
q = strlen(d);
if (strlen(f) != q)
cout << -1;
else {
for (cin >> w; w; w--) {
cin >> c >> v >> e;
c -= 97;
v -= 97;
if (a[c][v] > e) a[c][v] = e;
}
for (w = 0; w < 26; w++)
for (e = 0; e < 26; e++)
for (r = 0; r < 26; r++)
if (a[e][r] > a[e][w] + a[w][r]) a[e][r] = a[e][w] + a[w][r];
t = 0;
for (w = 0; w < q; w++) {
r = 100000;
c = d[w] - 97;
v = f[w] - 97;
for (e = 0; e < 26; e++)
if (r > a[c][e] + a[v][e]) {
r = a[c][e] + a[v][e];
d[w] = e + 97;
}
if (r == 100000) {
t = -1;
break;
}
t += r;
}
cout << t << "\n";
if (t >= 0) printf("%s", d);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, c = 0;
cin >> n >> m;
while (n--) {
int a[2 * m];
for (i = 0; i < 2 * m; i++) {
cin >> a[i];
}
for (i = 0; i < 2 * m; i = i + 2) {
if (a[i] || a[i + 1] == 1) c++;
}
}
cout << c << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, d;
cin >> n >> m >> d;
vector<int> a(n * m);
vector<int> cnt(d);
for (int i = 0; i < n * m; i++) cin >> a[i], cnt[a[i] % d]++;
int mi = *min_element(a.begin(), a.end());
int ma = *max_element(cnt.begin(), cnt.end());
if (ma != n * m) {
cout << -1;
} else {
int sum = 0;
for (int x : a) sum += (x - mi);
int ans = sum / d;
sort(a.begin(), a.end());
int right = n * m - 1;
for (int i = 1; i < n * m; i++) {
sum += (a[i] - a[i - 1]) * i - (a[i] - a[i - 1]) * (right--);
ans = min(ans, sum / d);
}
cout << ans;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> x, y, z;
int partial() {
int ret = 0;
for (int i = 0; i < (int)(min<int>(m, x.size())); i++)
if (z[m - 1 - i] >= x[i]) ret += z[m - 1 - i] - x[i];
return ret;
}
int all() {
if (n > m) return 0;
vector<int> v = z;
int ret = 0;
for (int i = 0; i < (int)(y.size()); i++) {
vector<int>::iterator itr = upper_bound(v.begin(), v.end(), y[i]);
if (itr == v.end()) return -1;
ret -= *itr;
v.erase(itr);
}
for (int i = 0; i < (int)(x.size()); i++)
if (x[x.size() - 1 - i] > z[m - 1 - i]) return -1;
for (int i = 0; i < (int)(m); i++) ret += z[i];
for (int i = 0; i < (int)(x.size()); i++) ret -= x[i];
return ret;
}
int main() {
cin >> n >> m;
for (int i = 0; i < (int)(n); i++) {
string type;
int v;
cin >> type >> v;
if (type == "ATK")
x.push_back(v);
else
y.push_back(v);
}
for (int i = 0; i < (int)(m); i++) {
int v;
cin >> v;
z.push_back(v);
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
sort(z.begin(), z.end());
int ret = max(partial(), all());
cout << ret << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 30;
vector<int> pos[MAXN];
string inp;
int countdiff(int l, int r) {
int res = 0;
for (int i = 0; i < 26; i++) {
auto it = lower_bound(pos[i].begin(), pos[i].end(), l);
if (it != pos[i].end() && *it <= r) res++;
}
return res;
}
int main() {
ios::sync_with_stdio((false));
cin >> inp;
for (int i = 0; i < inp.size(); i++) {
pos[inp[i] - 'a'].push_back(i);
}
int qlen;
cin >> qlen;
while (qlen--) {
int l, r;
cin >> l >> r;
l--, r--;
int diff = countdiff(l, r);
if (l == r || diff >= 3 || (diff == 2 && inp[l] != inp[r])) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int64_t mod = 998244353;
int64_t mod1 = 1e9 + 5;
int64_t power(int64_t a, int64_t b) {
if (b == 0)
return 1;
else if (b % 2 == 0)
return power(((((a) % mod) * ((a) % mod)) % mod), b / 2) % mod;
else
return (((a) % mod) *
(power(((((a) % mod) * ((a) % mod)) % mod), b / 2) % mod)) %
mod;
}
inline int64_t inverse(int64_t a, int64_t md) {
a %= md;
if (a < 0) a += md;
int64_t b = md, u = 0, v = 1;
while (a) {
int64_t t = b / a;
b -= t * a;
swap(a, b);
u -= t * v;
swap(u, v);
}
assert(b == 1);
if (u < 0) u += md;
return u;
}
const int64_t ce = 1e9 + 7;
int64_t fast_mod(int64_t input) { return input < ce ? input : input % ce; }
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int64_t n;
cin >> n;
int64_t a[n + 1];
int64_t c1 = 0;
for (int64_t i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 1) c1++;
}
int64_t c = 0;
for (int64_t i = n; i >= 1; i--)
if (a[i] == 0)
c++;
else
break;
if (c == 0) {
cout << "NO" << '\n';
return 0;
}
if (c == 2 and n == 2) {
cout << "NO";
return 0;
}
if (n <= 2) {
cout << "YES" << '\n';
for (int64_t i = 1; i <= n; i++) {
cout << a[i];
if (i != n) cout << "->";
}
cout << '\n';
return 0;
}
if (c == 2) {
if (c1 + c == n) {
cout << "NO";
return 0;
}
cout << "YES" << '\n';
int64_t c3 = 0, st;
for (int64_t i = n - 2; i >= 1; i--) {
if (a[i] == 0) {
st = i;
break;
}
}
for (int64_t i = 1; i <= n; i++) {
if (i == n) {
cout << a[i];
break;
}
if (i == n - 1) {
cout << a[i];
for (int64_t j = 1; j <= c3; j++) cout << ")";
cout << "->";
continue;
}
if (i >= st) {
cout << "(";
c3++;
}
cout << a[i];
if (i != n) cout << "->";
}
return 0;
}
cout << "YES" << '\n';
for (int64_t i = 1; i <= n; i++) {
if (i == n - 2) cout << "(";
cout << a[i];
if (i == n - 1) cout << ")";
if (i != n) cout << "->";
}
cout << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
for (int j = 0; j < t; j++) {
long long x, y;
cin >> x >> y;
if (y <= x)
cout << "YES\n";
else {
if (x == 1)
cout << "NO\n";
else {
if (x == 2) {
if (y == 3)
cout << "YES\n";
else
cout << "NO\n";
} else if (x == 3) {
if (y == 2)
cout << "YES\n";
else
cout << "NO\n";
} else {
cout << "YES\n";
}
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const char lend = '\n';
const int N = 300;
string last, res;
int vet[N], n;
bool build(int p, int s, int k) {
if (last[p] + k > '9') return false;
for (int i = 0; i < p; ++i) res[i] = last[i], s -= last[i] - '0';
res[p] = last[p] + k;
s -= res[p] - '0';
if (s < 0) return false;
for (int i = res.size() - 1; i > p && s; --i) {
res[i] = min(s, 9) + '0';
s -= res[i] - '0';
}
return s == 0;
}
void reset(string& s, int d) {
s.resize(d);
for (int i = 0; i < d; ++i) s[i] = '0';
}
void solve(int s, bool e) {
int d = last.size();
bool g = 0;
for (int i = d - 1; i >= 0 && !g; --i) {
for (int j = !e; j <= 9 && !g; ++j) {
reset(res, d);
g = build(i, s, j);
}
}
if (!g) {
reset(last, d + 1);
last[0] = '1';
solve(s, 1);
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> vet[i];
last = "0";
for (int i = 0; i < n; ++i) {
solve(vet[i], 0);
cout << res << lend;
last = res;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int a, b, c, d;
cin >> a >> b >> c >> d;
cout << max(abs(c - a), abs(d - b));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long x = n / 2;
x += n % 2;
if (k <= x)
cout << 2 * k - 1;
else {
k -= x;
cout << 2 * k;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<double, double> pt[100001];
int n, kth;
double getDist(int i1, int i2) {
pair<double, double> &a = pt[i1];
pair<double, double> &b = pt[i2];
double x = a.first - b.first;
double y = a.second - b.second;
return sqrt(x * x + y * y);
}
double getAns(int till, int from);
int main(void) {
scanf("%d %d", &n, &kth);
pair<double, double> tar;
for (int i = 0; i <= n; i++) scanf("%lf", &pt[i].first);
scanf("%lf", &pt[n].second);
kth--;
tar = pt[kth];
sort(pt, pt + n);
double ans = 99999999;
if (kth != n) {
int ind;
for (int i = 0; i < n; i++)
if (pt[i] == tar) ind = i;
ans = min(getDist(ind, 0) + getDist(0, n - 1) + getDist(n - 1, n),
getDist(ind, n - 1) + getDist(n - 1, 0) + getDist(0, n));
for (int i = 0; i < n; i++) {
int s = min(ind, i);
int e = max(ind, i);
ans = min(ans, getAns(s - 1, e + 1) + getDist(i, n) + pt[e].first -
pt[s].first);
if (s < ind) {
ans = min(ans, getAns(s - 1, n) + pt[n - 1].first - pt[ind].first +
pt[n - 1].first - pt[s].first + getDist(s, n));
ans = min(ans, getAns(s - 1, n) + pt[ind].first - pt[s].first +
pt[n - 1].first - pt[s].first + getDist(n - 1, n));
} else {
ans = min(ans, getAns(-1, e + 1) + pt[ind].first - pt[0].first +
pt[e].first - pt[0].first + getDist(e, n));
ans = min(ans, getAns(-1, e + 1) + pt[e].first - pt[ind].first +
pt[e].first - pt[0].first + getDist(0, n));
}
}
} else {
ans = min(getDist(0, n), getDist(n - 1, n));
ans += pt[n - 1].first - pt[0].first;
}
printf("%.10lf\n", ans);
return 0;
}
double getAns(int till, int from) {
double ret;
if (till == -1 && from == n)
ret = 0;
else if (till == -1)
ret = pt[n - 1].first - pt[from].first +
min(getDist(from, n), getDist(n - 1, n));
else if (from == n)
ret = pt[till].first - pt[0].first + min(getDist(0, n), getDist(till, n));
else {
ret = getDist(n, till) + pt[till].first - pt[0].first + pt[n - 1].first -
pt[0].first;
ret = min(ret, getDist(n, 0) + pt[n - 1].first - pt[0].first);
ret = min(ret, getDist(n, from) + pt[n - 1].first - pt[from].first +
pt[n - 1].first - pt[0].first);
ret = min(ret, getDist(n, n - 1) + pt[n - 1].first - pt[0].first);
}
return ret;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, k, v, ans = 0;
cin >> k >> a >> b >> v;
while (b && a) {
if (b >= k - 1) {
b -= k - 1;
ans++;
if (a >= k * v)
a -= k * v;
else
a = 0;
} else {
ans++;
if (a >= (b + 1) * v)
a -= (b + 1) * v;
else
a = 0;
b = 0;
}
}
if (!a) {
cout << ans << endl;
return 0;
} else {
while (a) {
if (a >= v)
a -= v;
else
a = 0;
ans++;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double err = 1e-12;
const double PI = 3.141592653589793;
const int N = 1e5 + 5;
int n, m;
vector<int> A(N), B(N);
unordered_map<int, int> cnt;
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < n; i++) cin >> B[i];
cin >> m;
int pairs = 0, ans = 1;
for (int i = 0; i < n; i++) {
if (A[i] == B[i]) pairs++;
cnt[A[i]]++;
cnt[B[i]]++;
}
for (auto p : cnt) {
for (int i = 1; i < p.second + 1; i++) {
int t = i;
while (pairs > 0 && t % 2 == 0) {
t /= 2;
pairs--;
}
ans = ((long long)ans * (long long)t) % m;
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int d, x, n, a;
int main() {
cin >> d >> n;
for (int i = 0; i < n - 1; i++) {
cin >> a;
x += d - a;
}
cout << x;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
string toString(T n) {
ostringstream ost;
ost << n;
ost.flush();
return ost.str();
}
long long toInt64(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
int main() {
int t = 0;
int m = 0;
char buff[100];
cin.getline(buff, 100);
string s(buff);
istringstream is(s);
is >> t >> m;
vector<int> a(m, 0);
int c = 1;
for (int i = 0; i < t; ++i) {
cin.getline(buff, 100);
s = buff;
istringstream is2(s);
string action;
is2 >> action;
int n;
if (action == "alloc") {
bool find = false;
int start = -1;
is2 >> n;
for (int j = 0; j <= int((a).size()) - n; ++j) {
if (count(a.begin() + j, a.begin() + j + n, 0) == n) {
find = true;
start = j;
break;
}
}
if (!find) {
cout << "NULL" << endl;
} else {
cout << c << endl;
for (int j = 0; j < n; ++j) {
a[start + j] = c;
}
c++;
}
} else if (action == "erase") {
is2 >> n;
if (n == 0 || count((a).begin(), (a).end(), n) == 0) {
cout << "ILLEGAL_ERASE_ARGUMENT" << endl;
}
for (int j = 0; j < int((a).size()); ++j) {
if (a[j] == n) {
a[j] = 0;
}
}
} else {
vector<int> b(m, 0);
int k = 0;
for (int j = 0; j < int((a).size()); ++j) {
if (a[j] != 0) {
b[k++] = a[j];
}
}
a = b;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class classcomp {
public:
bool operator()(const int& l, const int& r) const { return l < r; }
};
vector<int> a[100010];
vector<vector<int> > ed;
int n, m, in;
bool cmp(int x, int y) { return a[in][x] < a[in][y]; }
vector<int> vis;
bool fail = false;
set<int> inq;
list<int> dfs(int in) {
vis[in] = 1;
inq.insert(in);
int i, j, k;
list<int> ret, tt;
if (fail) return ret;
for (i = 0; i < ed[in].size(); i++) {
j = ed[in][i];
if (inq.find(j) != inq.end()) {
fail = true;
return ret;
}
if (vis[j] == 0) {
tt = dfs(j);
ret.insert(ret.begin(), tt.begin(), tt.end());
}
}
ret.insert(ret.begin(), in);
inq.erase(in);
return ret;
}
int main() {
scanf("%d%d", &n, &m);
vector<int> empty(m), nthn;
int i, j, k, l;
for (i = 0; i < n; i++) {
a[i] = empty;
for (j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
vector<int> seq(m);
for (j = 0; j < m; j++) {
seq[j] = j;
ed.push_back(nthn);
}
int nnum = m - 1;
for (i = 0; i < n; i++) {
in = i;
sort(seq.begin(), seq.end(), cmp);
j = 0;
while (j < m && a[i][seq[j]] == -1) j++;
vector<int> tt;
nnum++;
ed.push_back(nthn);
while (j < m) {
tt.clear();
tt.push_back(seq[j]);
j++;
while (j < m && a[i][seq[j]] == a[i][tt.front()]) {
tt.push_back(seq[j]);
j++;
}
nnum++;
ed.push_back(nthn);
for (k = 0; k < tt.size(); k++) {
ed[nnum - 1].push_back(tt[k]);
ed[tt[k]].push_back(nnum);
}
}
}
list<int> order, tl;
vis.assign((int)ed.size(), 0);
for (i = 0; i < vis.size() && !fail; i++) {
if (vis[i] == 0) {
inq.clear();
tl = dfs(i);
order.insert(order.begin(), tl.begin(), tl.end());
}
}
if (fail) {
printf("-1\n");
return 0;
}
list<int>::iterator it;
for (it = order.begin(); it != order.end(); it++)
if ((*it) < m) {
printf("%d ", (*it) + 1);
}
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long ans, res;
int n, m, cnt, k, valy[3050], suf[3050], pre[3050], f[3050];
struct P {
int x, y;
} p[3050];
bool cmpy(P a, P b) { return a.y < b.y; }
bool cmpx(P a, P b) { return a.x < b.x; }
void ins(int x) { suf[pre[x]] = x, pre[suf[x]] = x; }
void del(int x) { suf[pre[x]] = suf[x], pre[suf[x]] = pre[x]; }
int main() {
scanf("%d%d%d%d", &n, &m, &cnt, &k), res = 0;
for (int i = 1; i <= cnt; i++) scanf("%d%d", &p[i].x, &p[i].y);
sort(p + 1, p + 1 + cnt, cmpy), valy[0] = 0;
for (int i = 1; i <= cnt; i++) valy[i] = p[i].y, p[i].y = i;
for (int i = cnt + 1; i <= cnt + k; i++) valy[i] = m + 1;
sort(p + 1, p + 1 + cnt, cmpx);
for (int i = 1, l = 1, nw, x; i <= n; i++) {
while (l <= cnt && p[l].x < i) l++;
if (l > cnt) break;
for (int j = 0; j <= cnt + k; j++) pre[j] = j - 1, suf[j] = j + 1;
for (int j = 1; j < l; j++) del(p[j].y);
for (int j = cnt; j >= l; j--) del(p[j].y);
nw = l, ans = 0, f[cnt + 1] = cnt + k;
for (int j = i; j <= n; j++) {
while (nw <= cnt && p[nw].x <= j) {
ins(x = p[nw].y), f[x] = x;
for (int o = 1; o < k; o++) f[x] = suf[f[x]];
ans += 1ll * (valy[x] - valy[pre[x]]) * (valy[f[suf[x]]] - valy[f[x]]);
for (int o = 1; o < k; o++) {
x = pre[x];
if (!x) break;
ans +=
1ll * (valy[x] - valy[pre[x]]) * (valy[f[x]] - valy[pre[f[x]]]);
f[x] = pre[f[x]];
}
nw++;
}
res += ans;
}
}
printf("%I64d\n", res);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int zhao(int n, int m) {
int c;
int a = m, b = n;
while (b) {
c = a % b;
a = b;
b = c;
}
return m * n / a;
}
void solve() {
int l, r;
cin >> l >> r;
int i;
bool bad = false;
if (l == 1) {
cout << l << " " << r << '\n';
return;
}
if (r == l + 1) {
cout << -1 << " " << -1 << endl;
return;
}
if (r < 2 * l) {
cout << -1 << " " << -1 << endl;
} else {
cout << l << " " << 2 * l << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
if (n == 2 && x == 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
if (n % 4 == 0) {
for (int i = 610000; i < 610000 + n - 4; i++) cout << i << " ";
cout << (x + 13) << " " << (x + 17) << " " << (x + 23) << " "
<< (x ^ (x + 17) ^ (x + 13) ^ (x + 23)) << endl;
} else if (n % 4 == 1) {
for (int i = 610000; i < 610000 + n - 1; i++) cout << i << " ";
cout << x << endl;
} else if (n % 4 == 2) {
if (x == 0) {
for (int i = 610000; i < 610000 + n - 6; i++) cout << i << " ";
cout << (x + 13) << " " << (x + 17) << " " << (x + 73) << " " << (x + 101)
<< " " << (x + 53) << " "
<< (x ^ (x + 13) ^ (x + 17) ^ (x + 73) ^ (x + 101) ^ (x + 53))
<< endl;
} else {
for (int i = 610000; i < 610000 + n - 2; i++) cout << i << " ";
cout << (x + 13) << " " << (x ^ (x + 13)) << endl;
}
} else if (n % 4 == 3) {
for (int i = 610000; i < 610000 + n - 3; i++) cout << i << " ";
cout << (x + 13) << " " << (x + 17) << " " << (x ^ (x + 17) ^ (x + 13))
<< endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
int n;
int nxt[N];
vector<int> g[N];
int res[N];
int cur;
bool used[N];
int nxt2[N];
void dfs(int v) {
used[v] = true;
for (int u : g[v]) {
if (!used[u]) dfs(u);
}
res[v] = cur++;
}
void build() {
vector<int> st;
for (int i = 0; i < n; i++) {
while (!st.empty() && res[st.back()] < res[i]) {
nxt2[st.back()] = i;
st.pop_back();
}
st.push_back(i);
}
for (int i : st) nxt2[i] = n;
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> nxt[i];
if (nxt[i] != -1) nxt[i]--;
}
for (int i = 0; i < n; i++) g[i].clear();
vector<int> st;
for (int i = 0; i < n; i++) {
while (!st.empty() && nxt[st.back()] <= i) {
g[i].push_back(st.back());
st.pop_back();
}
if (!st.empty()) g[st.back()].push_back(i);
st.push_back(i);
}
for (int i = 0; i < n; i++) used[i] = false;
cur = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) dfs(i);
}
build();
bool ok = true;
for (int i = 0; i < n; i++) ok &= nxt[i] == -1 || nxt[i] == nxt2[i];
if (ok) {
for (int i = 0; i < n; i++) cout << res[i] + 1 << " ";
} else {
cout << "-1";
}
cout << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n + 1];
for (long long i = 1; i <= n; i++) cin >> a[i];
long long result = 0;
for (long long i = 2; i < n; i++) {
if (a[i] > a[i - 1] && a[i] > a[i + 1])
result++;
else if (a[i] < a[i - 1] && a[i] < a[i + 1])
result++;
}
cout << result;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T v) {
cerr << v << " ";
return *this;
}
} dbg;
int gap(int a, int b) {
if (b >= a)
return b - a;
else
return b + 10 - a;
}
int shift(int a, int b) { return (a + b + 10) % 10; }
int digit(int ans) {
int cnt = 0;
while (ans) {
cnt++;
ans /= 10;
}
return cnt;
}
int main() {
ios_base::sync_with_stdio(false);
int i, j, k, n;
string str;
while (cin >> n) {
string ans, ar;
cin >> ar;
ans = ar;
for (i = 0; i < n; i++) {
for (j = 0; j < 10; j++) {
string nw = ar;
nw[0] = j + '0';
int gp = gap(ar[0] - '0', j);
for (k = 1; k < n; k++) {
nw[k] = shift(ar[k] - '0', gp) + '0';
}
ans = min(ans, nw);
}
char last = ar[n - 1];
for (k = n - 1; k >= 1; k--) ar[k] = ar[k - 1];
ar[0] = last;
}
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000;
const int mod = 1e9 + 7;
long long h[maxn + 10], f[maxn + 10], g[maxn + 10];
int inv(int x, int y) {
int s = 1;
while (y) {
if (y & 1) s = 1LL * s * x % mod;
x = 1LL * x * x % mod;
y >>= 1;
}
return s;
}
int main() {
h[0] = 1;
for (int i = 1; i <= maxn; ++i) h[i] = h[i - 1] * i % mod;
g[maxn] = inv(h[maxn], mod - 2);
for (int i = maxn - 1; i >= 0; --i) g[i] = g[i + 1] * (i + 1) % mod;
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i <= k; ++i) f[i] = 0;
long long ans = 0;
long long s = 0;
for (int i = k + 1; i < n; ++i) {
f[i] = 1LL * (i - k + s + mod) * h[i - 1] % mod;
s = (s - f[i - k] * g[i - k] % mod + mod + f[i] * g[i] % mod) % mod;
ans = (ans + 1LL * h[n - 1] * g[i] % mod * f[i] % mod) % mod;
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, a, b;
cin >> t;
while (t--) {
cin >> n >> a >> b;
int temp;
int mx1 = 0, mx2 = 0;
for (int i = 0; i < a; i++) {
cin >> temp;
mx1 = max(mx1, temp);
}
for (int i = 0; i < b; i++) {
cin >> temp;
mx2 = max(mx2, temp);
}
if (mx1 > mx2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 2e5 + 5;
int n, q, v, a[sz], arr[sz], Tree[sz * 3], Lazy[sz * 3], Time = 0;
vector<int> x[sz];
pair<int, int> Range[sz];
string s;
void dfs(int u, int par) {
Range[u].first = ++Time;
arr[Time] = u;
for (auto i : x[u]) {
if (i != par) {
dfs(i, u);
}
}
Range[u].second = Time;
}
void Propagate(int node, int b, int e) {
if (Lazy[node]) {
Tree[node] = (e - b + 1) - Tree[node];
if (b != e) {
Lazy[node * 2] ^= 1;
Lazy[node * 2 + 1] ^= 1;
}
Lazy[node] = 0;
}
}
void Build(int node, int b, int e) {
if (b == e) {
Tree[node] = a[arr[b]];
return;
}
int mid = (b + e) / 2, left = node * 2, right = left + 1;
Build(left, b, mid);
Build(right, mid + 1, e);
Tree[node] = Tree[left] + Tree[right];
}
void Update(int node, int b, int e, int i, int j) {
Propagate(node, b, e);
if (b > j || e < i) return;
if (b >= i && e <= j) {
Lazy[node] = 1;
Propagate(node, b, e);
return;
}
int mid = (b + e) / 2, left = node * 2, right = left + 1;
Update(left, b, mid, i, j);
Update(right, mid + 1, e, i, j);
Tree[node] = Tree[left] + Tree[right];
}
int Query(int node, int b, int e, int i, int j) {
Propagate(node, b, e);
if (b > j || e < i) return 0;
if (b >= i && e <= j) return Tree[node];
int mid = (b + e) / 2, left = node * 2, right = left + 1;
int p = Query(left, b, mid, i, j);
int q = Query(right, mid + 1, e, i, j);
return p + q;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> v;
x[v].push_back(i);
}
dfs(1, -1);
for (int i = 1; i <= n; i++) cin >> a[i];
Build(1, 1, n);
cin >> q;
while (q--) {
cin >> s >> v;
if (s == "pow")
Update(1, 1, n, Range[v].first, Range[v].second);
else
cout << Query(1, 1, n, Range[v].first, Range[v].second) << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, h, s;
int main() {
int i, j, d, tot = 0, our = 0;
scanf("%d %d %d", &n, &m, &h);
--n;
for (i = 1; i <= m; ++i) {
scanf("%d", &s);
if (i == h) {
our = s - 1;
tot += s - 1;
} else
tot += s;
}
if (n > tot) {
printf("-1.0\n");
return 0;
}
if (our == 0) {
printf("0.0\n");
return 0;
}
if (n == tot) {
if (n > 0)
printf("1.0\n");
else
printf("0.0\n");
return 0;
}
long double ans = 0.0;
for (int k = 1; k <= min(our, n); ++k) {
vector<int> num, denom;
for (i = our; i > our - k; --i) num.push_back(i);
for (i = k; i >= 2; --i) denom.push_back(i);
for (i = tot - our; i > (tot - our) - (n - k); --i) num.push_back(i);
for (i = n - k; i >= 2; --i) denom.push_back(i);
for (i = n; i >= 2; --i) num.push_back(i);
for (i = tot; i > tot - n; --i) denom.push_back(i);
long double cr = 1.0;
sort(num.begin(), num.end());
sort(denom.begin(), denom.end());
int pt = (int)min(num.size(), denom.size());
for (i = 0; i < pt; ++i) {
cr *= (double)num[i];
cr /= (double)denom[i];
}
for (i = pt; i < num.size(); ++i) cr *= (double)num[i];
for (i = pt; i < denom.size(); ++i) cr /= (double)denom[i];
ans += cr;
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string ch = "";
string chr = "";
string table[1000000];
string cht[1000000];
string cht2[1000000];
string mat[100][100];
long long int t[1000000];
long long int t2[1000000];
long long int t3[1000000];
long long int t4[1000000];
long long int n, m, k, s, s1, p, x, y, z;
string str;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> t[i];
}
s1 = 0;
for (int j = 0; j < n; ++j) {
s = 0;
for (int i = 0; i < n; ++i) {
if (t[i] == t[j]) {
s++;
}
}
if (s > s1) {
s1 = s;
}
}
cout << s1;
}
| 0 |
#include <bits/stdc++.h>
const int N = 100500;
using namespace std;
int main() {
long long l, n, a[N];
cin >> n >> l;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
double mini = a[1];
mini = max((long long)mini, l - a[n]);
for (int i = 1; i <= n; i++) {
mini = max(mini, (a[i] - a[i - 1]) / 2.0);
}
printf("%.10f\n", mini);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 155;
int n, m;
struct Matrix {
int n, m;
bool a[N][N];
Matrix(int _n = 0, int _m = 0) {
n = _n, m = _m;
memset(a, 0, sizeof(a));
}
bool* operator[](int x) { return a[x]; }
const bool* operator[](int x) const { return a[x]; }
};
Matrix operator*(const Matrix& A, const Matrix& B) {
Matrix res(A.n, B.m);
for (int i = 0; i < A.n; ++i)
for (int j = 0; j < A.m; ++j)
if (A[i][j])
for (int k = 0; k < B.m; ++k) res[i][k] |= A[i][j] && B[j][k];
return res;
}
struct edge {
int x, y, t;
bool operator<(const edge& R) const { return t < R.t; }
} e[N];
int T[N], D;
Matrix F[N], g[N][30], G;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].t);
--e[i].x, --e[i].y;
T[D++] = e[i].t;
}
e[m++] = (edge){n - 1, n - 1, 0};
T[D++] = 0;
sort(T, T + D);
D = unique(T, T + D) - T;
sort(e, e + m);
F[0].n = 1, F[0].m = n, F[0][0][0] = 1;
G.n = G.m = n;
for (int i = 0, j = 0; i < D; ++i) {
while (j < m && e[j].t == T[i]) {
G[e[j].x][e[j].y] = 1;
++j;
}
g[i][0] = G;
for (int k = 1; k < 30; ++k) g[i][k] = g[i][k - 1] * g[i][k - 1];
if (i + 1 < D) {
F[i + 1] = F[i];
int K = T[i + 1] - T[i];
for (int k = 0; k < 30 && K; ++k)
if (K >> k & 1) {
K ^= (1 << k);
F[i + 1] = F[i + 1] * g[i][k];
}
}
}
int l = 0, r = 1e9 + 200, v;
while (l < r) {
int v = l + r >> 1;
int j = upper_bound(T, T + D, v) - T - 1;
Matrix f = F[j];
int K = v - T[j];
for (int k = 0; k < 30 && K; ++k)
if (K >> k & 1) {
K ^= (1 << k);
f = f * g[j][k];
}
if (f[0][n - 1])
r = v;
else
l = v + 1;
}
if (r == 1000000200)
puts("Impossible");
else
printf("%d\n", r);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, k1, k2, k3;
int main() {
cin >> a >> b;
for (int i = 1; i <= 6; i++) {
if (abs(i - a) < abs(i - b)) k1++;
if (abs(i - b) < abs(i - a)) k3++;
if (abs(i - a) == abs(i - b)) k2++;
}
cout << k1 << " " << k2 << " " << k3;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105, mo = 1e9 + 9;
int n, m, i, j, k, ans, inv[N], fac[N], x, y, d[N], g[N][N], f[N];
queue<int> q;
bool inq[N], vi[N];
vector<int> e[N], F = {1};
int xb, dfn[N], be[N], en[N], sz[N];
void getdfn(int x, int fa) {
vi[x] = 1;
dfn[be[x] = ++xb] = x;
sz[x] = f[x] = 1;
for (int y : e[x])
if (inq[y] && y != fa)
getdfn(y, x), f[x] = 1ll * f[x] * f[y] % mo, sz[x] += sz[y];
en[x] = xb;
f[x] = 1ll * inv[sz[x]] * f[x] % mo;
}
inline void addto(vector<int>& a, const vector<int>& b) {
for (int i = 0; i < b.size(); ++i) a[i] = (a[i] + b[i]) % mo;
}
inline vector<int> mul(const vector<int>& a, const vector<int>& b) {
vector<int> c;
c.resize(a.size() + b.size() - 1);
for (int i = 0; i < a.size(); ++i)
for (int j = 0; j < b.size(); ++j)
c[i + j] = (c[i + j] + 1ll * a[i] * b[j]) % mo;
return c;
}
inline vector<int> work(int i) {
xb = 0;
getdfn(i, 0);
memset(g[xb + 1] + 1, 0, xb << 2);
g[xb + 1][0] = 1;
for (j = xb; j; --j) {
memcpy(g[j], g[j + 1], xb + 1 << 2);
y = sz[x = dfn[j]];
for (k = 0; k + y <= xb - j + 1; ++k)
g[j][k + y] = (g[j][k + y] + 1ll * g[en[x] + 1][k] * f[x]) % mo;
}
return vector<int>(g[1], g[1] + xb + 1);
}
int main() {
for (i = *fac = 1; i < N; ++i)
inv[i] = i == 1 ? 1 : 1ll * inv[mo % i] * (mo - mo / i) % mo,
fac[i] = 1ll * fac[i - 1] * i % mo;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; ++i)
scanf("%d%d", &x, &y), e[x].push_back(y), e[y].push_back(x);
for (i = 1; i <= n; ++i) {
d[i] = e[i].size();
if (d[i] < 2) q.push(i), inq[i] = 1;
}
for (; !q.empty();) {
x = q.front();
q.pop();
for (int y : e[x])
if (--d[y] < 2 && !inq[y]) q.push(y), inq[y] = 1;
}
for (i = 1; i <= n; ++i)
if (d[i] == 1) F = mul(F, work(i));
for (i = 1; i <= n; ++i)
if (!vi[i] && inq[i]) {
xb = 0;
getdfn(i, 0);
vector<int> v(dfn + 1, dfn + xb + 1), tot(xb + 1);
for (int x : v) addto(tot, work(x));
for (j = 0; j < xb; ++j) tot[j] = 1ll * inv[xb - j] * tot[j] % mo;
F = mul(F, tot);
}
for (i = 0; i <= n; ++i)
printf("%lld\n", i < F.size() ? 1ll * fac[i] * F[i] % mo : 0);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10, L = 30 + 10;
long long n, h[N], wei[N], str[N], q, out = 0, t = 0, par[N][L];
vector<pair<long long, long long> > mat[N];
set<pair<long long, long long> > nodes;
set<pair<long long, long long> >::iterator it;
void input();
void process();
int main() {
input();
process();
return 0;
}
void input() {
cin >> n;
for (long long i = 0, u, v, w; i < n - 1; i++) {
scanf("%lld%lld%lld", &u, &v, &w);
mat[u].push_back(make_pair(v, w));
mat[v].push_back(make_pair(u, w));
}
}
void dfs(int v, int p, int lev) {
par[v][0] = p;
h[v] = lev;
str[v] = (++t);
for (int i = 0; i < (int)mat[v].size(); i++) {
int u = mat[v][i].first;
if (u != p) {
wei[u] = wei[v] + mat[v][i].second;
dfs(u, v, lev + 1);
}
}
}
long long lca(int u, int v) {
if (u == v) return u;
if (h[u] > h[v]) swap(u, v);
for (int i = L - 1; i >= 0; i--)
if ((((h[v] - h[u]) >> i) & 1) == 1 and par[v][i] != 0) v = par[v][i];
if (u == v) return v;
for (int i = L - 1; i >= 0; i--)
if (par[u][i] != par[v][i]) u = par[u][i], v = par[v][i];
return par[u][0];
}
void change(int u, int v, int w, bool c) {
long long x = lca(w, v), y = lca(w, u), z = lca(u, v);
long long tmp = 2 * (wei[w] + wei[z] - wei[x] - wei[y]);
if (c == true)
out += tmp;
else
out -= tmp;
}
void del(int v) {
nodes.erase(make_pair(str[v], v));
if (nodes.empty() == true) return;
it = nodes.lower_bound(make_pair(str[v], v));
long long bef, aft;
if (it == nodes.begin()) it = nodes.end();
it--;
bef = (*it).second;
it = nodes.upper_bound(make_pair(str[v], v));
if (it == nodes.end()) it = nodes.begin();
aft = (*it).second;
change(bef, aft, v, false);
}
void add(int v) {
if (nodes.find(make_pair(str[v], v)) != nodes.end()) return;
if (nodes.empty() == true) {
nodes.insert(make_pair(str[v], v));
return;
}
it = nodes.lower_bound(make_pair(str[v], v));
long long bef, aft;
if (it == nodes.begin()) it = nodes.end();
it--;
bef = (*it).second;
it = nodes.upper_bound(make_pair(str[v], v));
if (it == nodes.end()) it = nodes.begin();
aft = (*it).second;
change(bef, aft, v, true);
nodes.insert(make_pair(str[v], v));
}
void process() {
dfs(1, 0, 0);
for (int l = 1; l <= 30; l++)
for (int u = 1; u <= n; u++) par[u][l] = par[par[u][l - 1]][l - 1];
cin >> q;
for (int i = 0; i < q; i++) {
char c;
scanf("%s", &c);
if (c == '?')
printf("%lld\n", out / 2);
else {
int q;
scanf("%d", &q);
if (c == '+')
add(q);
else
del(q);
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100001;
const long long MOD = 1000000007;
const long long INF = 1e18;
long long add(long long a, long long b) { return (a + b) % MOD; }
long long sub(long long a, long long b) { return (a - b + MOD) % MOD; }
long long mul(long long a, long long b) { return (a * b) % MOD; }
long long ADD(long long &a, long long b) { return a = add(a, b); }
long long SUB(long long &a, long long b) { return a = sub(a, b); }
long long MUL(long long &a, long long b) { return a = mul(a, b); }
long long n, m;
vector<vector<int>> grid;
long long dp[1 << 15][2][2], temp[1 << 15][2][2];
int main(int argc, const char *argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
if (n <= m) {
grid = vector<vector<int>>(n, vector<int>(m, 0));
for (int i = (0); i < (n); i++)
for (int j = (0); j < (m); j++) {
char x;
cin >> x;
if (x == 'x') grid[i][j] = 1;
}
} else {
grid = vector<vector<int>>(m, vector<int>(n, 0));
for (int j = (0); j < (n); j++)
for (int i = (0); i < (m); i++) {
char x;
cin >> x;
if (x == 'x') grid[i][j] = 1;
}
swap(n, m);
}
for (int j = (0); j < (m); j++) {
for (int i = (0); i < (n); i++) {
if (!i && !j) {
if (!grid[i][j]) {
dp[1][1][0] = 1;
dp[0][0][1] = 1;
} else
dp[0][0][0] = 1;
continue;
}
if (grid[i][j]) {
for (int mask = (0); mask < (1 << n); mask++)
for (int k1 = (0); k1 < (2); k1++)
for (int k2 = (0); k2 < (2); k2++)
ADD(temp[mask & (~(1 << i))][0][k2], dp[mask][k1][k2]);
for (int mask = (0); mask < (1 << n); mask++)
for (int k1 = (0); k1 < (2); k1++)
for (int k2 = (0); k2 < (2); k2++)
dp[mask][k1][k2] = temp[mask][k1][k2], temp[mask][k1][k2] = 0;
continue;
}
for (int mask = (0); mask < (1 << n); mask++)
for (int k1 = (0); k1 < (2); k1++) {
if (k1 || mask & (1 << i)) {
ADD(temp[mask][k1][0], dp[mask][k1][0]);
ADD(temp[mask][k1][1], dp[mask][k1][1]);
} else
ADD(temp[mask][k1][1], dp[mask][k1][0]);
}
for (int mask = (0); mask < (1 << n); mask++)
for (int k1 = (0); k1 < (2); k1++)
for (int k2 = (0); k2 < (2); k2++)
ADD(temp[mask | (1 << i)][1][k2], dp[mask][k1][k2]);
for (int mask = (0); mask < (1 << n); mask++)
for (int k1 = (0); k1 < (2); k1++)
for (int k2 = (0); k2 < (2); k2++)
dp[mask][k1][k2] = temp[mask][k1][k2], temp[mask][k1][k2] = 0;
}
for (int mask = (0); mask < (1 << n); mask++)
for (int k2 = (0); k2 < (2); k2++)
ADD(dp[mask][0][k2], dp[mask][1][k2]), dp[mask][1][k2] = 0;
}
long long ans = 0;
for (int mask = (0); mask < (1 << n); mask++)
for (int k1 = (0); k1 < (2); k1++)
for (int k2 = (0); k2 < (2); k2++) ADD(ans, dp[mask][k1][k2]);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
double dp[2][10010][210], p[2], ans;
int n, x, y, a[2], t[2], l[2], r[2];
int main() {
for (int i = 0; i < 2; i++)
scanf("%d%d%d%d%lf", &a[i], &t[i], &l[i], &r[i], &p[i]);
if (abs(p[0] - 100.0) < (1e-8)) {
puts("0.000000");
return 0;
}
if (abs(p[1] - 100.0) < (1e-8)) {
puts("1.000000");
return 0;
}
dp[0][0][a[0]] = dp[1][0][a[1]] = 1, p[0] /= 100.0, p[1] /= 100.0;
for (x = 1; x <= 10000; x++) {
for (int i = 0; i < 2; i++)
for (int j = 1; j <= a[i]; j++) {
if (dp[i][x - 1][j] <= (1e-8)) continue;
for (int k = l[i ^ 1]; k <= r[i ^ 1]; k++)
dp[i][x][max(0, j - k)] +=
dp[i][x - 1][j] * (1 - p[i ^ 1]) / (r[i ^ 1] - l[i ^ 1] + 1);
dp[i][x][j] += dp[i][x - 1][j] * p[i ^ 1];
}
dp[0][x][0] += dp[0][x - 1][0];
}
for (int i = 1; i <= x; i++) {
y = ((i - 1) * t[0] + t[1] - 1) / t[1];
if (y > x) break;
ans += (1 - dp[0][y][0]) * dp[1][i][0];
}
printf("%.6lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int n, a[2005], b[2005];
int dp[2005][9][10][10][10];
int solve(int i, int f, int x, int y, int z) {
if (i == n && x == 9 && y == 9 && z == 9) return 0;
if (dp[i][f][x][y][z] != -1) return dp[i][f][x][y][z];
int ans = INF;
if (x != 9) ans = min(ans, solve(i, x, 9, y, z) + abs(f - x));
if (y != 9) ans = min(ans, solve(i, y, x, 9, z) + abs(f - y));
if (z != 9) ans = min(ans, solve(i, z, x, y, 9) + abs(f - z));
if (i < n) {
if (x == 9)
ans = min(ans, solve(i + 1, a[i], b[i], y, z) + abs(f - a[i]));
else if (y == 9)
ans = min(ans, solve(i + 1, a[i], x, b[i], z) + abs(f - a[i]));
else if (z == 9)
ans = min(ans, solve(i + 1, a[i], x, y, b[i]) + abs(f - a[i]));
else {
ans = min(ans,
solve(i + 1, b[i], x, y, z) + abs(f - a[i]) + abs(a[i] - b[i]));
ans =
min(ans, solve(i + 1, x, b[i], y, z) + abs(f - a[i]) + abs(a[i] - x));
ans =
min(ans, solve(i + 1, y, x, b[i], z) + abs(f - a[i]) + abs(a[i] - y));
ans =
min(ans, solve(i + 1, z, x, y, b[i]) + abs(f - a[i]) + abs(a[i] - z));
}
}
return dp[i][f][x][y][z] = ans;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
}
memset(dp, -1, sizeof dp);
cout << solve(0, 0, 9, 9, 9) + 2 * n << '\n';
}
| 8 |
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
typedef long long ll;
void mmin(int &a, int b) {
a = min(a, b);
}
void mmax(int &a, int b) {
a = max(a, b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, a, b;
cin >> n >> a >> b;
string s;
cin >> s;
vector<pair<int, int>> p(26, {n, -1});
vector<int> cnt(26);
int m = 0;
for (int i = 0; i < n; i++) {
mmin(p[s[i] - 'a'].first, i);
mmax(p[s[i] - 'a'].second, i);
if (!cnt[s[i] - 'a']) m++;
cnt[s[i] - 'a']++;
}
sort(p.begin(), p.end());
vector<bool> dp(1 << m);
dp[0] = true;
for (int mask = 1; mask < (1 << m); mask++) {
int total = 0;
int left = n, right = -1;
for (int i = 0; i < m; i++) {
if ((1 << i) & mask) {
total += cnt[s[p[i].first] - 'a'];
mmin(left, p[i].first);
mmax(right, p[i].second);
}
}
if (a * (right - left + 1) <= b * total) {
for (int i = 0; i < m && !dp[mask]; i++) {
if (!((1 << i) & mask)) continue;
dp[mask] = dp[mask] || dp[mask ^ (1 << i)];
}
}
for (int i = 0; i < m - 1 && !dp[mask]; i++) {
dp[mask] = dp[mask] || (dp[mask & ~((1 << (i + 1)) - 1)] && dp[mask & ((1 << (i + 1)) - 1)]);
}
}
vector<char> answer;
for (int i = 0; i < m; i++) {
if (dp[~(1 << i) & ((1 << m) - 1)])
answer.push_back(s[p[i].first]);
}
sort(answer.begin(), answer.end());
cout << answer.size();
for (char i : answer) {
cout << ' ' << i ;
}
cout << '\n';
} | 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
cin >> TESTS;
while (TESTS--) {
long long n;
cin >> n;
long long a[200005];
for (long long int i = 0; i < n + 1; i++) a[i] = 0;
for (long long int i = 0; i < n; i++) {
long long temp;
cin >> temp;
a[temp]++;
}
long long ans = 0;
sort(a, a + n + 1);
long long cur = a[n];
ans = a[n];
cur--;
for (long long i = n - 1; i >= 1; i--) {
if (a[i] >= cur) {
if (cur <= 0) break;
ans += cur;
cur--;
} else {
if (cur <= 0) break;
cur = a[i];
ans += cur;
cur--;
}
}
cout << ans << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int MAX = 1e3 + 5;
using namespace std;
int edge, mx, ans, seen[MAX], a, n, m, k, spec[MAX], check[MAX][MAX];
vector<int> adj[MAX];
vector<int> cur;
void dfs(int node) {
if (seen[node] == 1) return;
seen[node] = 1;
cur.push_back(node);
for (int i = int(0); i <= int(adj[node].size() - 1); i++) dfs(adj[node][i]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (int i = int(1); i <= int(k); i++) cin >> a, spec[a] = 1;
for (int i = int(1); i <= int(m); i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
check[u][v] = check[v][u] = 1;
}
for (int i = int(1); i <= int(n); i++)
if (spec[i] == 1) {
dfs(i);
mx = max(int(cur.size()), mx);
int comb = (cur.size() == 1 ? 0 : (cur.size() * (cur.size() - 1) / 2));
for (int i = int(0); i <= int(cur.size() - 1); i++) {
for (int j = int(i + 1); j <= int(cur.size() - 1); j++)
edge += check[cur[i]][cur[j]];
}
ans += comb - edge;
cur.clear();
edge = 0;
}
for (int i = int(1); i <= int(n); i++) {
if (seen[i] == 1) continue;
dfs(i);
int comb = (cur.size() == 1 ? 0 : (cur.size() * (cur.size() - 1) / 2));
for (int i = int(0); i <= int(cur.size() - 1); i++) {
for (int j = int(i + 1); j <= int(cur.size() - 1); j++)
edge += check[cur[i]][cur[j]];
}
ans += comb - edge;
ans += mx * int(cur.size());
mx += cur.size();
cur.clear();
edge = 0;
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
inline void amax(T &x, U y) {
if (x < y) x = y;
}
template <int MOD>
struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
ModInt(signed long long sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
};
ModInt<7340033> memo[32][1001][5];
ModInt<7340033> rec(int d, int k, int i) {
ModInt<7340033> &r = memo[d][k][i];
if (r.x != -1) return r;
if (i == 4) return r = k == 1 ? 1 : 0;
r = ModInt<7340033>();
r += rec(d, k, i + 1);
if (d > 0)
for (int(a) = (int)(1); (a) <= (int)(k); ++(a))
r += rec(d - 1, a, 0) * rec(d, k - a, i + 1);
return r;
}
int main() {
memset(memo, -1, sizeof(memo));
int T;
scanf("%d", &T);
for (int ii = 0; ii < T; ++ii) {
int n, k;
scanf("%d%d", &n, &k);
int p = 0;
while (n > 1 && (n - 1) % 2 == 0) ++p, n = (n - 1) / 2;
ModInt<7340033> ans = k == 0 ? 1 : p == 0 ? 0 : rec(p - 1, k, 0);
printf("%d\n", ans.get());
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
vector<pair<int, int> > a;
int rev[200005];
int n, m;
vector<pair<int, int> > s;
int model(int p, int l, int d) {
if (l == 0) return p;
int id = lower_bound(a.begin(), a.end(), make_pair(a[p].first + l * d, -1)) -
a.begin();
if (id == n) id--;
if (a[p].first + l * d == a[id].first) return id;
if (l < abs(a[id].first - a[p].first)) id--;
if (p != id) {
if (!s.empty() && s[s.size() - 1].first == id &&
s[s.size() - 1].second == p) {
int div = l / abs(a[p].first - a[id].first);
int mod = l % abs(a[p].first - a[id].first);
return model((div & 1) ? id : p, mod, (div & 1) ? d * -1 : d);
}
s.push_back(make_pair(p, id));
return model(id, l - abs(a[p].first - a[id].first), d * -1);
}
d *= -1;
id = lower_bound(a.begin(), a.end(), make_pair(a[p].first + l * d, -1)) -
a.begin();
if (id == n) id--;
if (a[p].first + l * d == a[id].first) return id;
if (l < abs(a[id].first - a[p].first)) id--;
if (id == p) return p;
s.push_back(make_pair(p, id));
return model(id, l - abs(a[p].first - a[id].first), d * -1);
}
int main() {
scanf("%d%d", &n, &m);
a.resize(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].first);
a[i].second = i;
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) rev[a[i].second] = i;
for (int i = 0; i < m; i++) {
int p, l;
scanf("%d%d", &p, &l);
p--;
p = rev[p];
s.clear();
int res = model(p, l, 1);
printf("%d\n", a[res].second + 1);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - 48;
ch = getchar();
}
return x * f;
}
template <typename T>
inline bool Max(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool Min(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int N = 54;
int n, R;
int mark[N][N];
int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
struct data {
int x, y, id;
bool operator<(const data &rhs) const {
if (x != rhs.x) return x < rhs.x;
return y < rhs.y;
}
} s[N];
vector<data> ans1, ans2;
void move(data &s, data t, vector<data> &ans) {
int d = 0;
if (t.y < s.y) d = 1;
if (t.x < s.x) d = 2;
if (t.y > s.y) d = 3;
while (!(s.x == t.x && s.y == t.y)) {
int tx = s.x + dx[d], ty = s.y + dy[d];
if (mark[tx][ty]) break;
mark[tx][ty] = 1, mark[s.x][s.y] = 0;
ans.push_back((data){s.x, s.y, d});
s = (data){tx, ty, s.id};
}
}
void solve(data *d, vector<data> &ans) {
sort(d + 1, d + 1 + n);
for (int i = 1, j = 1; i <= n; i = j + 1, j = i) {
while (j + 1 <= n && d[j + 1].x == d[j].x) ++j;
while (1) {
int fg = 0;
for (int k = i; k <= j; ++k)
if (d[k].y != k) fg = 1, move(d[k], (data){d[k].x, k, 0}, ans);
if (!fg) break;
}
}
for (int i = 1; i <= n; ++i) move(d[i], (data){d[i].id, d[i].y, 0}, ans);
for (int i = 1; i <= n; ++i) move(d[i], (data){d[i].x, d[i].id, 0}, ans);
}
int main() {
R = gi(), n = gi();
for (int i = 1; i <= n; ++i) {
s[i].x = gi(), s[i].y = gi(), s[i].id = i;
mark[s[i].x][s[i].y] = 1;
}
solve(s, ans1);
memset(mark, 0, sizeof mark);
for (int i = 1; i <= n; ++i) {
s[i].x = gi(), s[i].y = gi(), s[i].id = i;
mark[s[i].x][s[i].y] = 1;
}
solve(s, ans2);
reverse(ans2.begin(), ans2.end());
printf("%d\n", ans1.size() + ans2.size());
for (int i = 0; i < ans1.size(); ++i)
printf("%d %d %d %d\n", ans1[i].x, ans1[i].y, ans1[i].x + dx[ans1[i].id],
ans1[i].y + dy[ans1[i].id]);
for (int i = 0; i < ans2.size(); ++i)
printf("%d %d %d %d\n", ans2[i].x + dx[ans2[i].id],
ans2[i].y + dy[ans2[i].id], ans2[i].x, ans2[i].y);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e5 + 5;
const long long mod = 1e9 + 7;
long long pw(long long b, long long r, long long md = mod) {
b = b % md;
long long ans = 1;
while (r) {
if (r & 1) ans = (ans * b) % md;
b = (b * b) % md;
r >>= 1;
}
return ans;
}
long long dp2[(1LL << 20)];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T = 1;
while (T--) {
long long n;
cin >> n;
long long arr[n];
for (long long i = 0; i <= n - 1; ++i) cin >> arr[i];
for (long long i = 0; i <= n - 1; ++i) arr[i]--;
long long dp[20][20];
memset(dp, 0, sizeof dp);
;
long long mx[20];
for (long long i = 0; i <= 19; ++i) mx[i] = -1;
for (long long i = 0; i <= n - 1; ++i) mx[arr[i]] = i;
for (long long i = 0; i <= 19; ++i) {
long long prev = -1;
long long counter = 0;
for (long long j = mx[i]; j >= 0; j--) {
if (arr[j] == i) {
counter++;
continue;
}
dp[i][arr[j]] += counter;
}
}
for (long long i = 0; i <= (1LL << 20) - 1; ++i) dp2[i] = 1e16;
dp2[0] = 0;
for (long long i = 0; i <= (1LL << 20) - 1; ++i) {
for (long long j = 0; j <= 19; ++j) {
if ((1LL << j) & i) continue;
long long nb = i ^ (1LL << j);
long long req = 0;
for (long long k = 0; k <= 19; ++k) {
if ((1LL << k) & i) continue;
req += dp[j][k];
}
dp2[nb] = min(dp2[nb], dp2[i] + req);
}
}
long long ans = dp2[(1LL << 20) - 1];
cout << ans << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct SAM {
int trans[26], len, fa;
} sam[2000005];
int tot, root, tail;
char s[2000005], ch;
void add(int ch, int len) {
int p = tail, np = ++tot, q, r;
sam[np].len = len;
for (; p && !sam[p].trans[ch]; p = sam[p].fa) sam[p].trans[ch] = np;
tail = np;
if (!p)
sam[np].fa = root;
else if (sam[sam[p].trans[ch]].len == sam[p].len + 1)
sam[np].fa = sam[p].trans[ch];
else {
q = sam[p].trans[ch];
r = ++tot;
sam[r] = sam[q];
sam[r].len = sam[p].len + 1;
sam[q].fa = sam[np].fa = r;
for (; p && sam[p].trans[ch] == q; p = sam[p].fa) sam[p].trans[ch] = r;
}
}
int T, l, i, j, k;
int tmp, cnt[2000005], sum[2000005], id[2000005];
int use[2000005];
long long ans;
int main() {
root = tail = tot = 1;
scanf("%s", s + 1);
l = strlen(s + 1);
for (i = 1; i <= l; ++i) add(s[i] - 'a', i);
k = root;
for (i = 1; i <= l; ++i) cnt[k = sam[k].trans[s[i] - 'a']] = 1;
for (i = 2; i <= tot; ++i) ++sum[sam[i].len];
for (i = l; i >= 1; --i) sum[i] += sum[i + 1];
for (i = 2; i <= tot; ++i) id[sum[sam[i].len]--] = i;
for (i = 1; i < tot; ++i) cnt[sam[id[i]].fa] += cnt[id[i]];
scanf("%d", &T);
for (; T; --T) {
scanf("%s", s + 1);
l = strlen(s + 1);
for (i = 1; i <= l; ++i) s[i + l] = s[i];
l += l;
k = root;
ans = tmp = 0;
for (i = 1; i < l; ++i) {
ch = s[i] - 'a';
if (sam[k].trans[ch])
++tmp, k = sam[k].trans[ch];
else {
for (; k && !sam[k].trans[ch]; k = sam[k].fa)
;
if (!k)
tmp = 0, k = root;
else {
tmp = sam[k].len + 1;
k = sam[k].trans[ch];
}
}
if (tmp >= l / 2) {
for (; sam[sam[k].fa].len >= l / 2; k = sam[k].fa)
;
if (sam[k].len < tmp) tmp = sam[k].len;
if (use[k] != T) ans += cnt[k], use[k] = T;
}
}
printf("%I64d\n", ans);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a, b, c;
cin >> a >> b >> c;
cout << min(a, min(b - 1, c - 2)) * 3 + 3 << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string z[2000];
string st;
char bl;
long tests, er, bad[2000];
char gett(char x) {
if (x >= 'A' && x <= 'Z') return x - 'A' + 'a';
return x;
}
long flag;
bool upper(char x) {
if (x >= 'A' && x <= 'Z') return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> tests;
for (int i = 1; i <= tests; i++) {
cin >> z[i];
}
cin >> st;
cin >> bl;
for (int i = 0; i < st.size(); i++) {
for (int j = 1; j <= tests; j++) {
er = 0;
if (i + z[j].size() > st.size()) continue;
for (int p = 0; p < z[j].size(); p++) {
if (gett(z[j][p]) != gett(st[i + p])) er = 1;
}
if (er == 0)
for (int p = 0; p < z[j].size(); p++) bad[p + i] = 1;
}
}
for (int i = 0; i < st.size(); i++) {
if (bad[i] == 0) {
cout << st[i];
continue;
}
flag = 0;
if (upper(st[i])) {
st[i] = st[i] - 'A' + 'a';
flag = 1;
}
if (st[i] == bl && bl == 'a')
st[i] = 'b';
else if (st[i] == bl && bl != 'a')
st[i] = 'a';
else
st[i] = bl;
if (flag) {
st[i] = st[i] - 'a' + 'A';
}
cout << st[i];
}
cout << endl;
cin.get();
cin.get();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, a, b, i, k = 0, j;
cin >> n >> m;
vector<int> id(n + 1, 0);
vector<vector<int> > vec((n / 3) + 1, vector<int>());
for (i = 0; i < m; ++i) {
cin >> a >> b;
if (id[a] == 0 && id[b] == 0) {
k++;
if (k > (n / 3)) {
cout << -1;
return 0;
}
id[a] = k;
id[b] = k;
vec[k].push_back(a);
vec[k].push_back(b);
} else if (id[a] == 0 && id[b] > 0) {
id[a] = id[b];
vec[id[b]].push_back(a);
} else if (id[b] == 0 && id[a] > 0) {
id[b] = id[a];
vec[id[a]].push_back(b);
} else if (id[a] != id[b]) {
cout << -1;
return 0;
} else {
continue;
}
}
stack<int> st;
int y;
for (i = 1; i < n + 1; ++i) {
if (id[i] == 0) st.push(i);
if ((i < k + 1) && vec[i].size() > 3) {
cout << -1;
return 0;
}
}
for (i = 1; i < n / 3 + 1; ++i) {
for (auto j : vec[i]) cout << j << " ";
while (vec[i].size() != 3) {
y = st.top();
cout << y << " ";
st.pop();
vec[i].push_back(y);
}
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
int n, m;
struct ufind {
int p[100005], t;
void init() { memset(p, 0, sizeof(p)); }
void set_friend(int i, int j) {
for (; p[t = i]; i = p[i], p[t] = (p[i] ? p[i] : i))
;
for (; p[t = j]; j = p[j], p[t] = (p[j] ? p[j] : j))
;
p[i] = (i == j ? 0 : j);
}
int is_friend(int i, int j) {
for (; p[t = i]; i = p[i], p[t] = (p[i] ? p[i] : i))
;
for (; p[t = j]; j = p[j], p[t] = (p[j] ? p[j] : j))
;
return i == j && i;
}
} U;
int main() {
while (cin >> n >> m) {
int a, b;
U.init();
long long ret = 0;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &a, &b);
if (U.is_friend(a, b)) {
ret *= 2;
++ret;
ret %= 1000000009;
} else {
U.set_friend(a, b);
}
cout << ret << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int T;
long long sum, cnt, cnt1;
string s;
int main() {
cin >> T;
while (T--) {
cnt = 0;
cnt1 = 0;
sum = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
sum = sum + (s[i] - '0');
if (s[i] == '0') {
cnt++;
}
if ((s[i] - '0') % 2 == 0) {
cnt1++;
}
}
if (cnt > 1) {
if (sum % 3 == 0 && cnt > 1) {
cout << "red" << endl;
} else {
cout << "cyan" << endl;
}
} else if (cnt == 1) {
if (sum % 3 == 0 && cnt1 >= 2) {
cout << "red" << endl;
} else {
cout << "cyan" << endl;
}
} else {
cout << "cyan" << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll t;
cin >> t;
while (t--) {
ll n;
cin >> n;
vector<ll> sides(n);
for (int i = 0; i < (n); ++i) cin >> sides[i];
if (sides[1] > (sides[n - 1] - sides[0]))
cout << -1 << "\n";
else
cout << "1 2 " << n << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
double n, x;
cin >> n >> x;
long long mx = INT_MIN, md = INT_MIN;
for (long long i = 0; i < n; i++) {
long long d, h;
cin >> d >> h;
if (mx < d - h) mx = d - h;
md = max(md, d);
}
if (mx <= 0) {
if (md >= x)
cout << 1 << endl;
else
cout << -1 << endl;
return;
} else {
x -= md;
x = x > 0 ? x : 0.0;
long long ans = ceil(x / mx) + 1;
cout << ans << endl;
}
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, d, e, f, sum = 0, Min = 0, flag;
cin >> a >> b >> c >> d >> e >> f;
long long Max = max(e, f);
if (Max == f) {
Min = min(b, c);
Min = min(Min, d);
sum = sum + Min * f;
d = d - Min;
b = b - Min;
c = c - Min;
flag = 1;
}
if (Max == e) {
Min = min(a, d);
sum = sum + Min * e;
d = d - Min;
a = a - Min;
flag = 0;
}
if (flag && d != 0 && a != 0) {
Min = min(a, d);
sum = sum + Min * e;
}
if (flag == 0 && d != 0 && b != 0 && c != 0) {
Min = min(b, c);
Min = min(Min, d);
sum = sum + Min * f;
}
cout << sum << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Vi = vector<int>;
void run();
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(18);
run();
return 0;
}
int uplg(int n) { return 32 - __builtin_clz(n); }
int uplg(ll n) { return 64 - __builtin_clzll(n); }
void run() {
int n;
cin >> n;
string s;
cin >> s;
int tmp = 0, sm = 0, smPos = 0;
for (int i = (0); i < (n); i++) {
tmp += (s[i] == '(' ? 1 : -1);
if (tmp < sm) {
sm = tmp;
smPos = i + 1;
}
}
if (tmp != 0) {
cout << "0\n1 1\n";
return;
}
rotate(s.begin(), s.begin() + smPos, s.end());
Vi prefs = {0};
tmp = 0;
for (int i = (0); i < (n); i++) {
tmp += (s[i] == '(' ? 1 : -1);
prefs.push_back(tmp);
}
Vi cnt[3];
for (int i = (0); i < (3); i++) cnt[i].push_back(0);
for (auto& p : (prefs))
for (int i = (0); i < (3); i++) cnt[i].push_back(cnt[i].back() + (p == i));
int best = cnt[0].back() - 1;
int bestL = 0, bestR = 0;
int last = 0;
for (int i = (1); i < (n + 1); i++)
if (prefs[i] == 0) {
int alt = cnt[1][i] - cnt[1][last];
if (alt > best) {
best = alt;
bestL = last;
bestR = i - 1;
}
last = i;
}
last = 1;
for (int i = (2); i < (n + 1); i++)
if (prefs[i] == 1) {
if (prefs[i - 1] != 0) {
int alt = cnt[0].back() + cnt[2][i] - cnt[2][last] - 1;
if (alt > best) {
best = alt;
bestL = last;
bestR = i - 1;
}
}
last = i;
}
bestL = (bestL + smPos) % n;
bestR = (bestR + smPos) % n;
cout << best << '\n';
cout << bestL + 1 << ' ' << bestR + 1 << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 3000005;
string to_stringa(long long a) {
string ans;
while (a) {
char c = a % 10 + '0';
ans = c + ans;
a /= 10;
}
return ans;
}
int main() {
long long n, t;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<long long> v(100000, 0);
long long c = 0;
for (long long i = 1; i < 100000; i++) {
v[i] = 1 + v[i - 1] + log10(i);
}
cin >> t;
while (t--) {
cin >> n;
long long sum = 0;
long long i = 1;
while (sum + v[i] < n) {
sum += v[i];
i++;
}
long long x = n - sum;
i = 1;
while (v[i] < x) {
i++;
}
x = x - v[i - 1];
char ans;
string a = to_stringa(i);
for (long long i = 0; i < x; i++) ans = a[i];
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int maxn = 100000010;
struct person {
int atk, hp, def;
};
int a, b, c;
person least_hp, least_atk, least_def;
person yang, mon;
long ans = maxn;
bool survive(int i, int j, int k) {
int yangatk = yang.atk + i;
int yanghp = yang.hp + j;
int yangdef = yang.def + k;
int round = mon.hp / (yangatk - mon.def);
if (mon.hp % (yangatk - mon.def) != 0) round++;
if (yanghp > round * (mon.atk - yangdef)) return true;
return false;
}
int main() {
scanf("%d%d%d", &yang.hp, &yang.atk, &yang.def);
scanf("%d%d%d", &mon.hp, &mon.atk, &mon.def);
scanf("%d%d%d", &a, &b, &c);
int chu = 0;
int mo = 0;
if (yang.atk <= mon.def) chu = mon.def - yang.atk + 1;
mo = mon.hp + mon.def - yang.atk;
if (mo < 0) mo = 0;
int bao = 100 - yang.def;
long count = 0;
for (int i = chu; i <= mo; i++) {
for (int j = 0; j <= 5000; j++) {
for (int k = 0; k <= bao; k++) {
if (survive(i, j, k) == true) {
count = i * b + a * j + c * k;
if (count < ans) {
ans = count;
}
}
}
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
int w, h, x1, y1, x2, y2, a, b;
cin >> t;
while (t--) {
cin >> w >> h;
cin >> x1 >> y1 >> x2 >> y2;
cin >> a >> b;
int delW = w - x2, delW2 = x1;
int delH = h - y2, delH2 = y1;
int ans = 2e9;
if (delW >= delW2 && delH <= delH2) {
if (w - a >= x2 || b <= y1)
ans = 0;
else {
if (x2 - (w - a) <= x1) ans = min(ans, x2 - (w - a));
if (b - y1 <= h - y2) ans = min(ans, b - y1);
}
} else if (delW < delW2 && delH <= delH2) {
if (a <= x1 || b <= y1)
ans = 0;
else {
if (a - x1 <= w - x2) ans = min(ans, a - x1);
if (b - y1 <= h - y2) ans = min(ans, b - y1);
}
} else if (delW >= delW2 && delH > delH2) {
if (h - b >= y2 || w - a >= x2)
ans = 0;
else {
if (y2 - (h - b) <= y1) ans = min(ans, y2 - (h - b));
if (x2 - (w - a) <= x1) ans = min(ans, x2 - (w - a));
}
} else if (delW < delW2 && delH > delH2) {
if (h - b >= y2 || a <= x1)
ans = 0;
else {
if (y2 - (h - b) <= y1) ans = min(ans, y2 - (h - b));
if (a - x1 <= w - x2) ans = min(ans, a - x1);
}
}
cout << (ans == 2e9 ? -1 : ans) << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str[3];
for (int i = 0; i < 3; i++) {
cin >> str[i];
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (str[i][j] != str[2 - i][2 - j]) {
cout << "NO";
return 0;
}
}
}
cout << "YES";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void doRoutine() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
srand(322179);
}
const int C = 5010;
int tr[C * 8];
bool cross(pair<pair<int, int>, int> hor, pair<int, pair<int, int> > vert) {
return (vert.second.first <= hor.second &&
hor.second <= vert.second.second) &&
(hor.first.first <= vert.first && vert.first <= hor.first.second);
}
void init() {
for (int i = 0; i < C * 8; ++i) {
tr[i] = 0;
}
}
int get(int l, int r, int lb = -C, int rb = C, int v = 0) {
if (l == lb && r == rb) {
return tr[v];
} else {
int mb = (lb + rb) / 2;
if (r <= mb) {
return get(l, r, lb, mb, v * 2 + 1);
} else if (l >= mb) {
return get(l, r, mb, rb, v * 2 + 2);
} else {
return get(l, mb, lb, mb, v * 2 + 1) + get(mb, r, mb, rb, v * 2 + 2);
}
}
}
void add(int i, int x, int lb = -C, int rb = C, int v = 0) {
if (lb + 1 == rb) {
tr[v] += x;
} else {
int mb = (lb + rb) / 2;
if (i < mb) {
add(i, x, lb, mb, v * 2 + 1);
} else if (i >= mb) {
add(i, x, mb, rb, v * 2 + 2);
}
tr[v] = tr[v * 2 + 1] + tr[v * 2 + 2];
}
}
signed main() {
doRoutine();
int n;
cin >> n;
vector<pair<int, pair<int, int> > > verts;
vector<pair<pair<int, int>, int> > hors;
for (int i = 0; i < n; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 > x2) {
swap(x1, x2);
}
if (y1 > y2) {
swap(y1, y2);
}
if (x1 == x2) {
verts.push_back({x1, {y1, y2}});
} else {
hors.push_back({{x1, x2}, y1});
}
}
sort(verts.begin(), verts.end());
long long ans = 0;
for (int i = 0; i < verts.size(); ++i) {
vector<pair<int, int> > events;
for (auto seg : hors) {
if (cross(seg, verts[i])) {
events.push_back({seg.first.second, seg.second});
}
}
if (!events.empty()) {
sort(events.begin(), events.end());
reverse(events.begin(), events.end());
int ptr = 0;
init();
for (int j = (int)verts.size() - 1; j > i; --j) {
while ((ptr < events.size() && events[ptr].first >= verts[j].first)) {
add(events[ptr].second, 1);
++ptr;
}
int cnt = get(verts[j].second.first, verts[j].second.second + 1);
ans += cnt * (cnt - 1) / 2;
}
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
vector<pair<int, int>> a(3), ans;
for (int i = 0; i < 3; i++) {
int x, y;
cin >> x >> y;
a[i] = {x, y};
}
sort(a.begin(), a.end());
if ((a[0].second - a[1].second) * (a[2].second - a[1].second) > 0) {
int ind = a[1].second;
for (int i = a[1].second; i != a[2].second && i != a[0].second;
a[1].second > a[0].second ? i-- : i++) {
ans.push_back({a[1].first, i});
ind = i;
}
int lst = a[0].second;
for (int j = a[0].second; j != ind; a[0].second < a[1].second ? j++ : j--) {
ans.push_back({a[0].first, j});
lst = j;
}
for (int j = a[2].second; j != ind; a[2].second < a[1].second ? j++ : j--) {
ans.push_back({a[2].first, j});
}
for (int i = a[0].first + 1; i < a[2].first; i++) {
ans.push_back({i, lst});
}
} else {
int ind = a[1].second;
for (int j = a[0].second; j != ind; a[0].second < a[1].second ? j++ : j--) {
ans.push_back({a[0].first, j});
}
for (int j = a[2].second; j != ind; a[2].second < a[1].second ? j++ : j--) {
ans.push_back({a[2].first, j});
}
for (int i = a[0].first; i <= a[2].first; i++) {
ans.push_back({i, ind});
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << ' ' << ans[i].second << endl;
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
void solve()
{
int n,odd=0,even=0;
cin>>n;
for(int i=1; i<=2*n; i++)
{
int x;
cin>>x;
(x&1)?odd++:even++;
}
if(odd == even)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
}
int main()
{
int t;
cin>>t;
while(t--)
solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
int h[n + 1];
for (int i = 1; i <= n; i++) {
cin >> h[i];
}
int pos;
int count = 0;
for (int i = 1; i <= n; i++) {
pos = i;
int count1 = 1;
for (int i = pos - 1; i > 0; i--) {
if (h[i] > h[i + 1])
break;
else
count1++;
}
for (int i = pos + 1; i <= n; i++) {
if (h[i] > h[i - 1])
break;
else
count1++;
}
count = max(count, count1);
}
cout << count << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void sci(T& t) {
cin >> t;
}
template <typename T, typename... Ts>
void sci(T& t, Ts&... ts) {
sci(t);
sci(ts...);
}
int c[111111];
vector<int> g[111111];
long long ans[111111];
map<int, int>* cnt[111111];
set<pair<int, int>>* cs[111111];
long long ca[111111];
void dfs(int v, int p) {
cnt[v] = new map<int, int>;
cnt[v]->operator[](c[v])++;
cs[v] = new set<pair<int, int>>;
cs[v]->insert({1, c[v]});
ca[v] = c[v];
for (int i : g[v]) {
if (i == p) {
continue;
}
dfs(i, v);
if (cnt[v]->size() < cnt[i]->size()) {
swap(cnt[v], cnt[i]);
swap(cs[v], cs[i]);
swap(ca[v], ca[i]);
}
for (auto p : (*cnt[i])) {
auto it = cnt[v]->find(p.first);
int omx = cs[v]->rbegin()->first;
if (it != cnt[v]->end()) {
cs[v]->erase({it->second, it->first});
}
cnt[v]->operator[](p.first) += p.second;
it = cnt[v]->find(p.first);
cs[v]->insert({it->second, it->first});
if (omx < cs[v]->rbegin()->first) {
ca[v] = 0;
}
if (it->second == cs[v]->rbegin()->first) {
ca[v] += 1LL * it->first;
}
}
}
ans[v] = ca[v];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
sci(n);
for (int i = 0; i < n; i++) {
sci(c[i]);
}
for (int i = 1; i < n; i++) {
int x, y;
sci(x, y);
--x;
--y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(0, -1);
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
map<int, int> mp;
int main() {
int n;
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j++) {
if (i + j > (i ^ j) && (i ^ j) <= n && (i ^ j) >= j) {
cnt++;
}
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void program();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
program();
}
const int MX = 19, BIT = 1 << MX;
int n, bit, sbit;
string s[MX];
bitset<MX> knows[MX];
long long dp[BIT][MX];
long long g[MX][BIT];
vector<int> v;
map<vector<int>, vector<int> > mp;
long long ans[BIT];
long long d[BIT];
long long savedD[BIT][MX];
void fillAns(int tot = 0, int last = 1) {
if (tot == n) {
long long add = 0;
int x = bit - 1;
for (int i = int(0); i < int(bit); i++) {
if (__builtin_popcount(i) % 2)
add -= d[i ^ x];
else
add += d[i ^ x];
}
vector<int>& f = mp[v];
for (int i : f) ans[i] = add;
return;
}
if (tot + last > n) return;
for (int i = int(0); i < int(bit); i++) savedD[i][tot] = d[i];
for (int i = int(last); i < int(n - tot + 1); i++) {
if (tot + i != n && tot + i + i > n) continue;
v.push_back(i);
for (int j = int(0); j < int(bit); j++) d[j] *= g[i][j];
fillAns(tot + i, i);
for (int j = int(0); j < int(bit); j++) d[j] = savedD[j][tot];
v.pop_back();
}
}
void program() {
cin >> n;
for (int i = int(0); i < int(n); i++) cin >> s[i];
for (int i = int(0); i < int(n); i++) knows[i].reset();
for (int i = int(0); i < int(n); i++)
for (int j = int(0); j < int(n); j++)
if (s[i][j] == '1') knows[i][j] = 1;
for (int i = int(0); i < int(BIT); i++)
for (int j = int(0); j < int(MX); j++) dp[i][j] = 0;
for (int i = int(0); i < int(n); i++) dp[1 << i][i] = 1;
bit = (1 << n);
sbit = (1 << (n - 1));
for (int i = int(0); i < int(bit); i++)
for (int j = int(0); j < int(n); j++) {
for (int k = int(0); k < int(n); k++)
if (!((i >> k) & 1))
if (knows[j][k]) {
dp[i | (1 << k)][k] += dp[i][j];
}
}
for (int j = int(0); j < int(bit); j++) {
int i = __builtin_popcount(j);
for (int k = int(0); k < int(n); k++) g[i][j] += dp[j][k];
}
for (int i = int(0); i < int(n + 1); i++) {
for (int j = int(0); j < int(n); j++)
for (int mask = int(0); mask < int(bit); mask++)
if ((mask >> j) & 1) g[i][mask] += g[i][mask ^ (1 << j)];
}
for (int i = int(0); i < int(sbit); i++) {
int cnt = 1;
v.clear();
for (int j = int(0); j < int(n - 1); j++) {
if ((i >> j) & 1) {
cnt++;
} else {
v.push_back(cnt);
cnt = 1;
}
}
v.push_back(cnt);
sort(v.begin(), v.end());
mp[v].push_back(i);
ans[i] = 0;
}
for (int i = int(0); i < int(bit); i++) d[i] = 1;
v.clear();
fillAns();
for (int i = int(0); i < int(n - 1); i++)
for (int mask = int(0); mask < int(sbit); mask++)
if (!((mask >> i) & 1)) ans[mask] -= ans[mask | (1 << i)];
for (int i = int(0); i < int(sbit); i++)
cout << (i == 0 ? "" : " ") << ans[i];
cout << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int64_t dp[305][3];
char s[305];
int32_t main() {
{
cin.tie(0);
ios_base::sync_with_stdio(false);
};
cin >> s;
int64_t n = strlen(s);
s[n] = s[0];
dp[0][0] = 1;
for (int64_t i = 1; i <= n; i++) {
if (s[i - 1] == 'A') {
dp[i][0] = dp[i - 1][0] + dp[i - 1][1];
} else
dp[i][0] = dp[i - 1][1];
if (s[i] == 'A' && s[i - 1] == 'B')
dp[i][1] = dp[i - 1][0];
else if (s[i] == 'B')
dp[i][1] = dp[i - 1][1];
}
int64_t ans = 0;
ans += dp[n][0];
dp[0][0] = 0;
dp[0][1] = 1;
for (int64_t i = 1; i <= n; i++) {
if (s[i - 1] == 'A') {
dp[i][0] = dp[i - 1][0] + dp[i - 1][1];
} else
dp[i][0] = dp[i - 1][1];
if (s[i] == 'A' && s[i - 1] == 'B')
dp[i][1] = dp[i - 1][0];
else if (s[i] == 'B')
dp[i][1] = dp[i - 1][1];
}
cout << ans + dp[n][1] << '\n';
return 0;
}
| 6 |
// 2020.12.13
// Code by LTb
// #pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
// #define int long long
#define debug puts("QwQ");
inline int read(){
int x=0,f=1;
char ch;
while(ch<'0'||ch>'9') {if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9') {x=x*10+ch-'0';ch=getchar();}
return f*x;
}
inline char readch(){
char ch=getchar();
while (ch==' '||ch=='\n') ch=getchar();
return ch;
}
inline string readstr(){
char ch=getchar();
string ans="";
while (ch==' '||ch=='\n') ch=getchar();
while (ch!=' '&&ch!='\n') {ans+=ch;ch=getchar();}
return ans;
}
inline void chmax(int &x,int y){x=max(x,y);}
inline void chmin(int &x,int y){x=min(x,y);}
const int MAXN=100005;
int n;
int a[MAXN];
bool Plus,Minus,Multiple;
int dp[MAXN],bel[MAXN];
char ans[MAXN];
int nex[MAXN];
int P=1e7;
void sol1(){
for (int i=2;i<=n;i++)
if (Plus) ans[i]='+';
else ans[i]='-';
}
void sol2(){
for (int i=2;i<=n;i++)
ans[i]='*';
}
void sol3(){
int pos=0;
for (int i=1;i<=n;i++)
if (!pos && a[i]==0) pos=i;
for (int i=2;i<=n;i++){
if (i==pos) ans[i]='-';
else ans[i]='*';
}
}
void init(){
int cur=0;
for (int i=n;i>=1;i--){
nex[i]=cur;
if (a[i]!=1) cur=i;
}
}
void foo(int l,int r){
int cnt=1;
dp[l-1]=0;
for (int i=l;i<=r;i++){
if (cnt<P) cnt*=a[i];
dp[i]=bel[i]=0;
// cout<<i<<' '<<nex[i]<<endl;
}
if (cnt>=P){
for (int i=l+1;i<=r;i++)
ans[i]='*';
return ;
}
for (int i=l;i<=r;i++){
cnt=1;
for (int j=i;j<=r && j;j=nex[j]){
cnt*=a[j];
if (dp[i-1]+cnt>dp[j]){
dp[j]=dp[i-1]+cnt;
bel[j]=i-1;
}
}
}
int cur=r;
while (cur>=l){
int tmp=bel[cur];
ans[tmp+1]='+';
for (int i=tmp+2;i<=cur;i++)
ans[i]='*';
cur=tmp;
}
}
void sol4(){
init();
for (int i=1;i<=n;i++){
if (a[i]==0){
ans[i+1]=ans[i]='+';
continue;
}
int cur=i;
while (cur<n && a[cur+1]!=0) cur++;
int l=i,r=cur;
while (l<=r && a[l]==1) ans[++l]='+';
while (l<=r && a[r]==1) ans[r--]='+';
if (l<=r) foo(l,r);
i=cur;
}
}
void print(){
cout<<a[1];
for (int i=2;i<=n;i++)
cout<<ans[i]<<a[i];
cout<<endl;
}
signed main()
{
n=read();P=2*n;
for (int i=1;i<=n;i++)
a[i]=read();
string allowed=readstr();
for (auto i:allowed){
if (i=='+') Plus=true;
else if (i=='-') Minus=true;
else Multiple=true;
}
if (!Multiple) sol1();
else{
if (!Plus && !Minus) sol2();
else if (!Plus) sol3();
else sol4();
}
print();
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
long double PI = 3.14159265359;
int inf = 1000000000000000007;
int mod = 1000000007;
int mod1 = 998244353;
const bool multi = 0;
vector<int> G[2500007];
vector<int> RG[2500007];
bool odw[2500007];
int scc[2500007];
vector<int> post;
void dfs(int v) {
odw[v] = 1;
for (auto u : RG[v])
if (!odw[u]) dfs(u);
post.push_back(v);
}
void dfsS(int v, int k) {
scc[v] = k;
for (auto u : G[v])
if (scc[u] == 0) dfsS(u, k);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt;
if (multi)
cin >> tt;
else
tt = 1;
while (tt--) {
int n, p, M, m, a, b;
cin >> n >> p >> M >> m;
for (int i = 0; i < n; i++) {
cin >> a >> b;
G[2 * a + 1].push_back(2 * b);
G[2 * b + 1].push_back(2 * a);
}
for (int i = p + 1; i < p + M; i++) {
G[2 * i].push_back(2 * (i + M + 1) + 1);
G[2 * (i + M + 1) + 1].push_back(2 * i);
G[2 * (i + M + 1)].push_back(2 * i + 1);
G[2 * i + 1].push_back(2 * (i + M + 1));
G[2 * i].push_back(2 * (i + 1));
G[2 * (i + 1) + 1].push_back(2 * i + 1);
G[2 * (i + M) + 1].push_back(2 * (i + M + 1) + 1);
G[2 * (i + M + 1)].push_back(2 * (i + M));
}
G[2 * (p + M) + 1].push_back(2 * (p + M));
G[2 * (p + M + 1) + 1].push_back(2 * (p + M + 1));
for (int i = 1; i <= p; i++) {
cin >> a >> b;
if (a != 1) {
G[2 * i].push_back(2 * (p + a - 1) + 1);
G[2 * (p + a - 1)].push_back(2 * i + 1);
}
if (b != M) {
G[2 * i].push_back(2 * (p + M + b + 1) + 1);
G[2 * (p + M + b + 1)].push_back(2 * i + 1);
}
}
for (int i = 0; i < m; i++) {
cin >> a >> b;
G[2 * a].push_back(2 * b + 1);
G[2 * b].push_back(2 * a + 1);
}
for (int i = 2; i <= 2 * (p + M * 2) + 1; i++)
for (auto x : G[i]) RG[x].push_back(i);
for (int i = 2; i <= 2 * (p + M * 2) + 1; i++)
if (!odw[i]) dfs(i);
reverse(post.begin(), post.end());
int it = 1;
for (auto x : post)
if (!scc[x]) dfsS(x, it++);
vector<int> res;
for (int i = 1; i <= p + 2 * M; i++) {
if (scc[2 * i] == scc[2 * i + 1]) {
cout << -1;
return 0;
}
}
int k = -1;
for (int i = 1; i <= p; i++)
if (scc[2 * i] < scc[2 * i + 1]) res.push_back(i);
for (int i = p + 1; i <= p + M; i++)
if (scc[2 * i] < scc[2 * i + 1] &&
scc[2 * (i + M)] < scc[2 * (i + M) + 1])
k = i - p;
cout << (int)(res).size() << " " << k << '\n';
for (auto x : res) cout << x << " ";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mx = (1 << 22);
long long f[mx], ans[mx];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
memset(ans, -1, sizeof(ans));
for (long long i = 0; i < n; i++) {
f[a[i]]++;
ans[a[i]] = a[i];
}
for (long long j = 0; j < 22; j++)
for (long long i = 0; i < mx; i++)
if (i & (1 << j)) {
f[i] += f[i ^ (1 << j)];
if (f[i ^ (1 << j)]) ans[i] = ans[i ^ (1 << j)];
}
for (long long i = 0; i < n; i++) {
long long p = (mx - 1) & (~a[i]);
cout << ans[p] << " ";
}
cout << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
scanf("%d %d", &x, &y);
int ans = (x + y) / 3;
if (y > 2 * x) ans = x;
if (x > 2 * y) ans = y;
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
unsigned long long int t;
cin >> t;
while (t--) {
unsigned long long int n;
cin >> n;
if (n > 14 && n % 14 <= 6 && n % 14 > 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, a, b, c, cnt = 0;
scanf("%d", &n);
while (n) {
scanf("%d%d%d", &a, &b, &c);
if (a + b + c >= 2) {
cnt++;
}
n--;
}
printf("%d\n", cnt);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int maxn = 5e6 + 5;
const int base = 13331;
char s[maxn];
unsigned long long p[maxn], sum[maxn], suf[maxn];
int f[maxn];
int idx(char c) {
if (c >= 'a' && c <= 'z') return c - 'a' + 1;
if (c >= 'A' && c <= 'Z') return c - 'A' + 27;
return c - '0' + 53;
}
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
p[0] = 1;
for (int i = 1; i <= n; i++) {
p[i] = p[i - 1] * base;
sum[i] = sum[i - 1] * base + idx(s[i]);
}
for (int i = n; i >= 1; i--) suf[i] = suf[i + 1] * base + idx(s[i]);
int ans = 1;
f[1] = 1;
for (int i = 2; i <= n; i++) {
int p1 = i / 2, p2 = i - i / 2 + 1;
unsigned long long tmp1 = sum[p1], tmp2 = suf[p2] - suf[i + 1] * p[i / 2];
if (tmp1 == tmp2) {
f[i] = f[i / 2] + 1;
ans += f[i];
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
namespace caide {
template <typename C>
int SZ(const C& c) {
return (int)c.size();
}
template <typename T>
vector<vector<T>> makeVector(int n, int m) {
return vector<vector<T>>(n, vector<T>(m));
}
} // namespace caide
namespace caide {
class ModInt {
public:
static unsigned long long MOD;
public:
ModInt(int val);
unsigned long long getValue() const;
ModInt& operator*=(const ModInt& rhs);
private:
unsigned long long value;
};
} // namespace caide
using namespace caide;
class Solution {
public:
pair<int, int> solve(const vector<string>& s) {
const int n = SZ(s);
auto hsums2 = makeVector<int>(n, n + 1);
auto vsums2 = makeVector<int>(n, n + 1);
auto hsums3 = makeVector<int>(n, n + 1);
auto vsums3 = makeVector<int>(n, n + 1);
vector<vector<int>> hz(n), vz(n);
for (int i = 0; i < n; ++i) {
hz[i].push_back(-1);
for (int j = 0; j < n; ++j)
if (s[i][j] == '0') hz[i].push_back(j);
hz[i].push_back(n);
vz[i].push_back(-1);
for (int j = 0; j < n; ++j)
if (s[j][i] == '0') vz[i].push_back(j);
vz[i].push_back(n);
for (int j = 0; j < n; ++j) {
hsums2[i][j + 1] = hsums2[i][j] + (int)(s[i][j] == '2');
hsums3[i][j + 1] = hsums3[i][j] + (int)(s[i][j] == '3');
vsums2[i][j + 1] = vsums2[i][j] + (int)(s[j][i] == '2');
vsums3[i][j + 1] = vsums3[i][j] + (int)(s[j][i] == '3');
}
}
int p2 = 0, p3 = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (s[i][j] != '0') {
auto it = lower_bound(std::begin(hz[i]), std::end(hz[i]), j);
int j1 = *it;
--it;
int j0 = *it;
it = lower_bound(std::begin(vz[j]), std::end(vz[j]), i);
int i1 = *it;
--it;
int i0 = *it;
int w = min(min(j1 - j, j - j0), min(i1 - i, i - i0));
j0 = j - w;
j1 = j + w;
i0 = i - w;
i1 = i + w;
int hn2 = hsums2[i][j1] - hsums2[i][j0 + 1];
int hn3 = hsums3[i][j1] - hsums3[i][j0 + 1];
int vn2 = vsums2[j][i1] - vsums2[j][i0 + 1];
int vn3 = vsums3[j][i1] - vsums3[j][i0 + 1];
int n2 = hn2 + vn2;
int n3 = hn3 + vn3;
if (s[i][j] == '2') --n2;
if (s[i][j] == '3') --n3;
if (better(n2, n3, p2, p3)) {
p2 = n2;
p3 = n3;
}
}
return make_pair(p2, p3);
}
bool better(int n2, int n3, int p2, int p3) {
return (n2 - p2) * log(2) > (p3 - n3) * log(3);
}
bool better(pair<int, int> p1, pair<int, int> p2) {
return p1 == p2 || better(p1.first, p1.second, p2.first, p2.second);
}
void solve(istream& in, ostream& out) {
int n;
in >> n;
vector<string> s(n);
for (auto& t : s) in >> t;
bool haveNonZero = false;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (s[i][j] != '0') haveNonZero = true;
if (!haveNonZero) {
out << 0 << endl;
return;
}
auto p1 = solve(s);
pair<int, int> p2, p3;
{
vector<string> t(n, string(n, '0'));
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if ((i + j) % 2 == 0) t[(i + j) / 2][(i - j + n) / 2] = s[i][j];
p2 = solve(t);
}
{
vector<string> t(n, string(n, '0'));
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if ((i + j) % 2 == 1) t[(i + j) / 2][(i - j + n) / 2] = s[i][j];
p3 = solve(t);
}
pair<int, int> p;
if (better(p1, p2) && better(p1, p3))
p = p1;
else if (better(p2, p1) && better(p2, p3))
p = p2;
else
p = p3;
ModInt::MOD = 1000000007ULL;
ModInt res = 1;
while (p.first--) res *= 2;
while (p.second--) res *= 3;
out << res.getValue() << endl;
}
};
void solve(istream& in, ostream& out) {
out << std::setprecision(12);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
namespace caide {
unsigned long long ModInt::MOD = 0ULL;
static unsigned long long init(long long val, unsigned long long mod) {
if (val >= 0)
return (unsigned long long)val % mod;
else
return (mod - (unsigned long long)(-val) % mod) % mod;
}
ModInt::ModInt(int val) : value(init(val, MOD)) {}
unsigned long long ModInt::getValue() const { return value; }
ModInt& ModInt::operator*=(const ModInt& that) {
value = value * that.value % MOD;
return *this;
}
} // namespace caide
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
for (int i = 0; i < n; ++i) {
long long x;
scanf("%lld", &x);
a[i] = __builtin_popcountll(x);
}
long long answer = 0;
vector<int> sum(n + 1);
for (int i = 0; i < n; ++i) {
sum[i + 1] = sum[i] + a[i];
}
vector<int> zero(n + 1);
for (int i = 0; i < n; ++i) {
zero[i + 1] = zero[i] ^ (a[i] & 1);
}
vector<int> sum_zero(n + 2);
for (int i = 0; i <= n; ++i) {
sum_zero[i + 1] = sum_zero[i] + zero[i];
}
auto query = [&](int l, int r, int t) {
long long result = 0;
for (int i = l, j = l - 1, k = l; i <= r; ++i) {
if (j < i) {
for (j = i; j <= r && a[j] != t; ++j)
;
if (j > r) {
return result;
}
}
for (k = max(k, j); k <= r && sum[k + 1] - sum[i] < (t << 1); ++k)
;
if (k > r) {
return result;
}
if (zero[i]) {
result += sum_zero[r + 2] - sum_zero[k + 1];
} else {
result += r - k + 1;
result -= sum_zero[r + 2] - sum_zero[k + 1];
}
}
return result;
};
for (int t = 0; t < 60; ++t) {
int last = 0;
for (int i = 0; i < n; ++i) {
if (a[i] > t) {
answer += query(last, i - 1, t);
last = i + 1;
}
}
answer += query(last, n - 1, t);
}
printf("%lld\n", answer);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pos, l, r;
while (cin >> n >> pos >> l >> r) {
if (l == 1 && r == n)
cout << 0 << endl;
else if (l == 1)
cout << (abs(r - pos) + 1) << endl;
else if (r == n)
cout << (abs(l - pos) + 1) << endl;
else if (pos < l || pos > r)
cout << (max(abs(r - pos), abs(l - pos)) + 2) << endl;
else
cout << (r - l + min(abs(r - pos), abs(l - pos)) + 2) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dis[100009], par[100009], road[100009];
vector<pair<int, int> > v[100009];
queue<pair<int, int> > q;
set<pair<int, int> > s;
vector<pair<int, int> > res;
pair<int, int> dif(int x, int y) {
if (x > y) swap(x, y);
return {x, y};
}
int main() {
scanf("%d%d", &n, &m);
while (m--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
v[a].push_back({b, c});
v[b].push_back({a, c});
if (a > b) swap(a, b);
if (c) s.insert({a, b});
}
memset(dis, 0x3f, sizeof(dis));
q.push({1, 0});
dis[1] = 0;
while (!q.empty()) {
int cur = q.front().first, is = q.front().second;
q.pop();
if (cur == n) break;
for (auto next : v[cur]) {
int nxt = next.first;
int is1 = next.second;
if (dis[nxt] > dis[cur] + 1) {
dis[nxt] = dis[cur] + 1;
par[nxt] = cur;
road[nxt] = is + !is1;
q.push({nxt, road[nxt]});
} else if (dis[nxt] == dis[cur] + 1 && road[nxt] > is + !is1) {
dis[nxt] = dis[cur] + 1;
par[nxt] = cur;
road[nxt] = is + !is1;
q.push({nxt, road[nxt]});
}
}
}
int x = n;
while (x != 1) {
if (s.count(dif(x, par[x])))
s.erase(dif(x, par[x]));
else
res.push_back({x, par[x]});
x = par[x];
}
printf("%d\n", s.size() + res.size());
for (auto pp : res) printf("%d %d 1\n", pp.first, pp.second);
for (auto pp : s) printf("%d %d 0\n", pp.first, pp.second);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int INF = 2147483647;
using namespace std;
int n, a[50005];
int solve(int l, int r) {
int num = r - l + 1;
if (num <= 0) return 0;
if (num == 1) return 1;
int times = 0, minh = INF;
for (int i = l; i <= r; i++) minh = min(minh, a[i]);
times = minh;
for (int i = l; i <= r; i++) a[i] -= minh;
int stp = l;
while (a[stp] == 0 && stp <= r) stp++;
for (int i = stp; i <= r; i++) {
if (a[i] == 0) {
times += solve(stp, i - 1);
stp = i + 1;
}
}
times += solve(stp, r);
return min(times, num);
}
int main() {
while (~scanf("%d", &n)) {
int minh = INF;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
minh = min(minh, a[i]);
}
printf("%d\n", solve(1, n));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int taxi = 0, k, a, all[5] = {0};
cin >> a;
for (int i = 0; i < a; i++) {
cin >> k;
all[k]++;
}
taxi += all[4];
taxi += all[3];
all[1] = all[1] - all[3];
all[1] = all[1] < 0 ? 0 : all[1];
taxi += all[2] / 2 + all[2] % 2;
all[1] = all[1] - 2 * (all[2] % 2);
if (all[1] > 0) {
taxi += all[1] / 4;
if (all[1] % 4 > 0) {
taxi++;
}
}
cout << taxi;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
inline int min(const int& x, const int& y) { return (x - y >> 31) ? x : y; }
namespace ST {
int lg[N], t[20][N];
inline void build(int* a, int n) {
copy(a + 1, a + 1 + n, t[0] + 1);
for (int i = 2; i <= n; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= 19; i++)
for (int j = 1; j <= n - (1 << i); j++)
t[i][j] = min(t[i - 1][j], t[i - 1][j + (1 << i - 1)]);
}
inline int ask(int l, int r) {
int p = lg[r - l];
return min(t[p][l], t[p][r - (1 << p)]);
}
} // namespace ST
namespace SA {
int n, m, sa[N], x[N], y[N], c[N], h[N];
char* st;
inline void input(char* a, int len) {
n = len, m = 128, st = a;
for (int i = 1; i <= n; i++) x[i] = st[i], sa[i] = i;
}
inline void radix_sort() {
for (int i = 1; i <= m; i++) c[i] = 0;
for (int i = 1; i <= n; i++) c[x[i]]++;
for (int i = 1; i <= m; i++) c[i] += c[i - 1];
for (int i = n; i >= 1; i--) sa[c[x[y[i]]]--] = y[i];
}
inline void init() {
for (int k = 0, p = 0; k <= n; k = k << 1 | !k) {
for (int i = n - k + 1; i <= n; i++) y[++p] = i;
for (int i = 1; i <= n; i++)
if (sa[i] > k) y[++p] = sa[i] - k;
radix_sort(), swap(x, y), p = 0;
for (int i = 1; i <= n; i++)
x[sa[i]] = p +=
y[sa[i]] != y[sa[i - 1]] || y[sa[i] + k] != y[sa[i - 1] + k];
if (p >= n) break;
m = p, p = 0;
}
for (int i = 1; i <= n; i++) {
int& p = h[x[i]] = max(0, h[x[i - 1]] - 1);
while (st[i + p] == st[sa[x[i] + 1] + p]) h[x[i]]++;
}
ST::build(h, n);
}
} // namespace SA
struct tree {
set<int> mp;
long long int val;
inline void init() { mp.clear(), mp.insert(0), mp.insert(N), val = 0; }
inline int pre(int x) { return *--mp.lower_bound(x); }
inline int nxt(int x) { return *mp.upper_bound(x); }
inline void add(int x, int y, int w) {
if (x && y != N) val += ST::ask(x, y) * w;
}
inline void ins(int x) {
int p = pre(x), q = nxt(x);
add(p, q, 1), add(p, x, -1), add(x, q, -1), mp.insert(x);
}
} t[N];
namespace SAM {
int n, tot, last, top;
int fa[N], len[N], ch[N][26], d[N], sta[N], pos[N];
inline void cpy(int x, int y) {
for (int i = 0; i <= 25; i++) ch[x][i] = ch[y][i];
}
inline void ins(int x) {
int p(last), np, q, nq;
len[np = last = ++tot] = len[p] + 1;
while (p && !ch[p][x]) ch[p][x] = np, p = fa[p];
if (!p) return void(fa[np] = 1);
if (len[q = ch[p][x]] == len[p] + 1) return void(fa[np] = q);
cpy(nq = ++tot, q), len[nq] = len[p] + 1, fa[nq] = fa[q], fa[q] = fa[np] = nq;
while (p && ch[p][x] == q) ch[p][x] = nq, p = fa[p];
}
inline void input(char* a, int len) {
n = len, tot = last = pos[0] = 1;
for (int i = 1; i <= n; i++) ins(a[i] - 'a'), pos[i] = last;
}
inline void merge(tree& x, tree& y) {
if (x.mp.size() < y.mp.size()) swap(x, y);
for (int v : y.mp)
if (v && v != N) x.ins(v), x.val += n - SA::sa[v] + 1;
}
inline void work() {
long long int ans = 0;
for (int i = 0; i <= tot; i++) d[fa[i]]++, t[i].init();
for (int i = 1; i <= tot; i++)
if (!d[i]) sta[++top] = i;
for (int i = 0; i <= n - 2; i++)
t[pos[i]].ins(SA::x[i + 2]), t[pos[i]].val += n - i - 1;
for (int i = 1; i <= tot; i++) ans += len[i] - len[fa[i]] << (i != pos[n]);
while (int u = sta[top--]) {
ans += t[u].val * (len[u] - len[fa[u]]);
if (fa[u]) merge(t[fa[u]], t[u]);
if (!--d[fa[u]]) sta[++top] = fa[u];
}
cout << ans + t[1].val + 2;
}
}; // namespace SAM
int n;
char a[N];
int main() {
scanf("%s", a + 1), n = strlen(a + 1), SA::input(a, n);
SA::init(), SAM::input(a, n), SAM::work();
return 0;
}
| 13 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.