solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
vector<int> vis, lvl, tab;
vector<vector<pair<int, int> > > Adjlist;
int n;
int res = 0;
void bfs(int x) {
vis[x] = 1;
lvl[x] = 1;
res = max(lvl[x], res);
queue<int> q;
q.push(x);
while (!q.empty()) {
int s = q.front();
q.pop();
for (int i = 0; i < (int)Adjlist[s].size(); i++) {
if (vis[Adjlist[s][i].first] == 0) {
vis[Adjlist[s][i].first] = 1;
q.push(Adjlist[s][i].first);
lvl[Adjlist[s][i].first] = lvl[s] + 1;
res = max(res, lvl[s] + 1);
}
}
}
}
int main() {
cin >> n;
Adjlist.resize(n);
vis.resize(n);
lvl.resize(n);
tab.resize(n);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
tab[i] = x;
if (x != -1) {
Adjlist[x - 1].push_back(pair<int, int>(i, 1));
}
}
for (int i = 0; i < n; i++) {
if (tab[i] == -1) {
bfs(i);
}
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
const long double EPS = 1e-10;
string operator*(const string& s, int k) {
if (k == 0) return "";
string p = (s + s) * (k / 2);
if (k % 2 == 1) p += s;
return p;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct Edge {
long long to, cap, rev;
Edge(long long _to, long long _cap, long long _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
void add_edge(vector<vector<Edge>>& G, long long from, long long to,
long long cap, bool revFlag, long long revCap) {
G[from].push_back(Edge(to, cap, (long long)G[to].size()));
if (revFlag)
G[to].push_back(Edge(from, revCap, (long long)G[from].size() - 1));
}
long long max_flow_dfs(vector<vector<Edge>>& G, long long v, long long t,
long long f, vector<bool>& used) {
if (v == t) return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge& e = G[v][i];
if (!used[e.to] && e.cap > 0) {
long long d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
long long max_flow(vector<vector<Edge>>& G, long long s, long long t) {
long long flow = 0;
for (;;) {
vector<bool> used(G.size());
for (int(i) = (int)(0); i < (int)(used.size()); i++) used[i] = false;
long long f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(vector<vector<Edge>>& G, long long s, vector<long long>& d,
vector<long long>& negative) {
d.resize(G.size());
negative.resize(G.size());
for (int(i) = (int)(0); i < (int)(d.size()); i++) d[i] = INF;
for (int(i) = (int)(0); i < (int)(d.size()); i++) negative[i] = false;
d[s] = 0;
for (int(k) = (int)(0); k < (int)(G.size() - 1); k++) {
for (int(i) = (int)(0); i < (int)(G.size()); i++) {
for (int(j) = (int)(0); j < (int)(G[i].size()); j++) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
for (int(k) = (int)(0); k < (int)(G.size() - 1); k++) {
for (int(i) = (int)(0); i < (int)(G.size()); i++) {
for (int(j) = (int)(0); j < (int)(G[i].size()); j++) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true) negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(vector<vector<Edge>>& G, long long s, vector<long long>& d) {
d.resize(G.size());
for (int(i) = (int)(0); i < (int)(d.size()); i++) d[i] = INF;
d[s] = 0;
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
q;
q.push(make_pair(0, s));
while (!q.empty()) {
pair<long long, long long> a = q.top();
q.pop();
if (d[a.second] < a.first) continue;
for (int(i) = (int)(0); i < (int)(G[a.second].size()); i++) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(vector<vector<Edge>>& G, vector<vector<long long>>& d) {
d.resize(G.size());
for (int(i) = (int)(0); i < (int)(d.size()); i++) d[i].resize(G.size());
for (int(i) = (int)(0); i < (int)(d.size()); i++) {
for (int(j) = (int)(0); j < (int)(d[i].size()); j++) {
d[i][j] = ((i != j) ? INF : 0);
}
}
for (int(i) = (int)(0); i < (int)(G.size()); i++) {
for (int(j) = (int)(0); j < (int)(G[i].size()); j++) {
chmin(d[i][G[i][j].to], G[i][j].cap);
}
}
for (int(i) = (int)(0); i < (int)(G.size()); i++) {
for (int(j) = (int)(0); j < (int)(G.size()); j++) {
for (int(k) = (int)(0); k < (int)(G.size()); k++) {
chmin(d[j][k], d[j][i] + d[i][k]);
}
}
}
}
bool tsort(vector<vector<Edge>>& graph, vector<int>& order) {
int n = graph.size(), k = 0;
vector<long long> in(n);
for (auto& es : graph)
for (auto& e : es) in[e.to]++;
priority_queue<long long, vector<long long>, greater<long long>> que;
for (int(i) = (int)(0); i < (int)(n); i++)
if (in[i] == 0) que.push(i);
while (que.size()) {
int v = que.top();
que.pop();
order.push_back(v);
for (auto& e : graph[v])
if (--in[e.to] == 0) que.push(e.to);
}
if (order.size() != n)
return false;
else
return true;
}
class lca {
public:
const int n = 0;
const int log2_n = 0;
std::vector<std::vector<int>> parent;
std::vector<int> depth;
lca() {}
lca(const vector<vector<Edge>>& g, int root)
: n(g.size()),
log2_n(log2(n) + 1),
parent(log2_n, std::vector<int>(n)),
depth(n) {
dfs(g, root, -1, 0);
for (int k = 0; k + 1 < log2_n; k++) {
for (int v = 0; v < (int)g.size(); v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
void dfs(const vector<vector<Edge>>& g, int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
for (auto& e : g[v]) {
if (e.to != p) dfs(g, e.to, v, d + 1);
}
}
int get(int u, int v) {
if (depth[u] > depth[v]) std::swap(u, v);
for (int k = 0; k < log2_n; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v) return u;
for (int k = log2_n - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
};
void visit(const vector<vector<Edge>>& g, int v, vector<vector<long long>>& scc,
stack<long long>& S, vector<long long>& inS, vector<long long>& low,
vector<long long>& num, int& time) {
low[v] = num[v] = ++time;
S.push(v);
inS[v] = true;
for (decltype((g[v]).begin()) e = (g[v]).begin(); e != (g[v]).end(); ++e) {
int w = e->to;
if (num[w] == 0) {
visit(g, w, scc, S, inS, low, num, time);
low[v] = min(low[v], low[w]);
} else if (inS[w])
low[v] = min(low[v], num[w]);
}
if (low[v] == num[v]) {
scc.push_back(vector<long long>());
while (1) {
int w = S.top();
S.pop();
inS[w] = false;
scc.back().push_back(w);
if (v == w) break;
}
}
}
void stronglyConnectedComponents(const vector<vector<Edge>>& g,
vector<vector<long long>>& scc) {
const int n = g.size();
vector<long long> num(n), low(n);
stack<long long> S;
vector<long long> inS(n);
int time = 0;
for (int(u) = (int)(0); u < (int)(n); u++)
if (num[u] == 0) visit(g, u, scc, S, inS, low, num, time);
}
class UnionFind {
vector<int> data;
long long num;
public:
UnionFind(int size) : data(size, -1), num(size) {}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
num -= (x != y);
return x != y;
}
bool findSet(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
int numSet() { return num; }
};
class SumSegTree {
private:
long long _sum(long long a, long long b, long long k, long long l,
long long r) {
if (r <= a || b <= l) return 0;
if (a <= l && r <= b)
return dat[k];
else {
long long s1 = _sum(a, b, 2 * k + 1, l, (l + r) / 2);
long long s2 = _sum(a, b, 2 * k + 2, (l + r) / 2, r);
return s1 + s2;
}
}
public:
long long n, height;
vector<long long> dat;
SumSegTree(long long _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<long long>(2 * n - 1, 0);
}
void add(long long i, long long x) {
i += n - 1;
dat[i] += x;
while (i > 0) {
i = (i - 1) / 2;
dat[i] += x;
}
}
long long sum(long long a, long long b) { return _sum(a, b, 0, 0, n); }
};
class RmqTree {
private:
long long _find(long long a, long long b, long long k, long long l,
long long r) {
if (r <= a || b <= l) return INF;
if (a <= l && r <= b)
return dat[k];
else {
long long s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2);
long long s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r);
return min(s1, s2);
}
}
public:
long long n, height;
vector<long long> dat;
RmqTree(long long _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<long long>(2 * n - 1, INF);
}
void update(long long i, long long x) {
i += n - 1;
dat[i] = x;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
long long find(long long a, long long b) { return _find(a, b, 0, 0, n); }
};
void divisor(long long n, vector<long long>& ret) {
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
}
void divisor_prime(long long n, vector<pair<long long, long long>>& ret) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back({i, 0});
while (n % i == 0) {
n /= i;
ret[ret.size() - 1].second++;
}
}
}
if (n != 1) ret.push_back({n, 1});
}
long long mod_pow(long long x, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long mod_inv(long long x, long long mod) {
return mod_pow(x, mod - 2, mod);
}
class Combination {
public:
vector<long long> fact;
vector<long long> inv;
long long mod;
long long mod_inv(long long x) {
long long n = mod - 2LL;
long long res = 1LL;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
long long nCr(long long n, long long r) {
return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod;
}
long long nPr(long long n, long long r) {
return (fact[n] * inv[n - r]) % mod;
}
long long nHr(long long n, long long r) { return nCr(r + n - 1, r); }
Combination(long long n, long long _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
for (int(i) = (int)(0); i < (int)(n); i++) {
fact[i + 1] = (fact[i] * (i + 1LL)) % mod;
}
inv.resize(n + 1);
inv[n] = mod_inv(fact[n]);
for (int i = n; i > 0; i--) {
inv[i - 1] = inv[i] * i % mod;
}
}
};
long long gcd(long long m, long long n) {
if (n == 0) return m;
return gcd(n, m % n);
}
long long lcm(long long m, long long n) { return m / gcd(m, n) * n; }
long long popcount(long long x) {
x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
x = (x & 0x0F0F0F0F0F0F0F0F) + (x >> 4 & 0x0F0F0F0F0F0F0F0F);
x = (x & 0x00FF00FF00FF00FF) + (x >> 8 & 0x00FF00FF00FF00FF);
x = (x & 0x0000FFFF0000FFFF) + (x >> 16 & 0x0000FFFF0000FFFF);
x = (x & 0x00000000FFFFFFFF) + (x >> 32 & 0x00000000FFFFFFFF);
return x;
}
class SegmentTree {
private:
pair<long long, long long> _find(long long a, long long b, long long k,
long long l, long long r) {
if (r <= a || b <= l) return {INF, INF};
if (a <= l && r <= b)
return dat[k];
else {
pair<long long, long long> s1 = _find(a, b, 2 * k + 1, l, (l + r) / 2);
pair<long long, long long> s2 = _find(a, b, 2 * k + 2, (l + r) / 2, r);
return min(s1, s2);
}
}
public:
long long n, height;
vector<pair<long long, long long>> dat;
SegmentTree(long long _n) {
n = 1;
height = 1;
while (n < _n) {
n *= 2;
height++;
}
dat = vector<pair<long long, long long>>(2 * n - 1, {INF, INF});
}
void update(long long i, long long x) {
i += n - 1;
dat[i] = {x, i - (n - 1)};
while (i > 0) {
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
pair<long long, long long> find(long long a, long long b) {
return _find(a, b, 0, 0, n);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
string s;
cin >> s;
vector<long long> ans(n);
long long cnt = 0;
set<pair<long long, long long>> st;
st.insert({INF, INF});
for (int(i) = (int)(0); i < (int)(n); i++) {
long long a = s[i] - 'a';
auto itr = st.upper_bound({a, INF});
if (itr == st.begin()) {
cnt++;
ans[i] = cnt;
st.insert({a, cnt});
} else {
itr--;
long long num = (*itr).second;
ans[i] = num;
st.erase(itr);
st.insert({a, num});
}
}
cout << cnt << endl;
for (int(i) = (int)(0); i < (int)(n); i++)
cout << ans[i] << (i != n - 1 ? ' ' : '\n');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 30030;
const int MAXK = 220;
const int inf = 1e9;
int fp[MAXN][MAXK];
int fn[MAXN][MAXK];
int bestp[MAXK], bestn[MAXN];
int a[MAXN];
int s[MAXN];
int main(void) {
int n, k;
scanf("%d %d", &n, &k);
for (int i = (0); i < (n); ++i) scanf("%d", a + i);
s[0] = 0;
for (int i = (0); i < (n); ++i) s[i + 1] = s[i] + a[i];
for (int i = (0); i < (n + 1); ++i)
for (int j = (0); j < (k + 1); ++j) fn[i][j] = fp[i][j] = -inf;
fp[n][0] = fn[n][0] = 0;
for (int i = n - 1; i >= 0; --i)
for (int j = (0); j < (k + 1); ++j) {
fn[i][j] = fn[i + 1][j];
fp[i][j] = fp[i + 1][j];
if (j > 0)
for (int ni = i + 1; ni <= n; ++ni) {
int sum = s[ni] - s[i];
bool first = j == k;
bool last = j == 1;
fp[i][j] =
max(fp[i][j], !last * (sum + fn[ni][j - 1]) + !first * sum);
fn[i][j] =
max(fn[i][j], !last * (sum + fn[ni][j - 1]) - !first * sum);
fp[i][j] =
max(fp[i][j], !last * (-sum + fp[ni][j - 1]) + !first * sum);
fn[i][j] =
max(fn[i][j], !last * (-sum + fp[ni][j - 1]) - !first * sum);
}
bestp[j] = max(bestp[j], fp[i][j]);
bestn[j] = max(bestn[j], fn[i][j]);
}
printf("%d\n", fp[0][k]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& p) {
return o << "(" << p.first << "," << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& vc) {
o << "{";
for (const T& v : vc) o << v << ",";
o << "}";
return o;
}
long long n, q, a[100005], b[100005];
pair<long long, long long> p[100005];
long long ans(long long l, long long r) {
long long ans = 0;
long long sum = 0;
long long cur = 0;
for (long long i = l; i < r; i++) {
long long range = 1;
while (cur && p[cur].first <= b[i]) {
sum -= (p[cur].first * p[cur].second);
range += p[cur].second;
cur--;
}
p[++cur].first = b[i];
p[cur].second = range;
sum += range * b[i];
ans += sum;
}
return ans;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i < n; i++) b[i] = abs(a[i] - a[i + 1]);
while (q--) {
long long l, r;
cin >> l >> r;
cout << ans(l, r) << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, t, r = 0, n, x, k, a[100005];
stack<int> q;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
q.push(a[0]);
for (i = 1; i < n; i++) {
if (a[i] == q.top()) continue;
if (a[i] > q.top()) {
while (q.size() > 0 && a[i] >= q.top()) {
k = q.top();
q.pop();
if (q.size() > 0) r = max(r, q.top() ^ k);
}
}
q.push(a[i]);
}
while (q.size() > 1) {
k = q.top();
q.pop();
r = max(r, q.top() ^ k);
}
q.pop();
q.push(a[n - 1]);
for (i = n - 2; i >= 0; i--) {
if (a[i] == q.top()) continue;
if (a[i] > q.top()) {
while (q.size() > 0 && a[i] >= q.top()) {
k = q.top();
q.pop();
if (q.size() > 0) r = max(r, q.top() ^ k);
}
}
q.push(a[i]);
}
while (q.size() > 1) {
k = q.top();
q.pop();
r = max(r, q.top() ^ k);
}
cout << r << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
int n, m, in[N], fb[N], ans = 0;
vector<int> e[N], E[N];
int q[N], h, t;
bool to[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; i++)
scanf("%d%d", &x, &y), e[x].push_back(y), ++in[y];
h = 1, t = 0;
for (int i = 1; i <= n; i++)
if (!in[i]) q[++t] = i;
for (; h <= t;) {
int u = q[h++];
if (h > t)
fb[u] += n - t;
else if (h == t) {
for (auto v : e[q[h]])
if (in[v] == 1) fb[u] = -2000000000;
if (fb[u] != -2000000000) fb[u] += n - t;
} else
fb[u] = -2000000000;
for (auto v : e[u])
if (!(--in[v])) q[++t] = v;
}
for (int i = 1; i <= n; i++) E[i] = e[i], e[i].clear(), in[i] = 0;
for (int i = 1; i <= n; i++)
for (auto v : E[i]) e[v].push_back(i), ++in[i];
h = 1, t = 0;
for (int i = 1; i <= n; i++)
if (!in[i]) q[++t] = i;
for (; h <= t;) {
int u = q[h++];
if (h > t)
fb[u] += n - t;
else if (h == t) {
for (auto v : e[q[h]])
if (in[v] == 1) fb[u] = -2000000000;
if (fb[u] != -2000000000) fb[u] += n - t;
} else
fb[u] = -2000000000;
for (auto v : e[u])
if (!(--in[v])) q[++t] = v;
}
for (int i = 1; i <= n; i++)
if (fb[i] >= n - 2) ++ans;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long arr[n + 1], vis[n + 1];
memset(vis, 0, sizeof(vis));
arr[0] = 0;
vis[0] = 1;
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
if (arr[i] == 0) vis[i] = 1;
}
long long x[2 * n], y[2 * n];
memset(x, 0, sizeof(x));
memset(y, 0, sizeof(y));
long long count = 0, next_2 = 1, next_3 = 1;
for (long long i = 1; i <= n; i++) {
if (arr[i] == 1 && vis[i] == 0) {
x[count] = i;
y[count] = i;
vis[i] = 1;
count++;
} else if (arr[i] == 2) {
next_2 = max(next_2, i);
long long j = next_2 + 1;
for (j = next_2 + 1; j <= n; j++) {
if (arr[j] == 1 && vis[j] == 0) {
if (vis[i] != 1) {
x[count] = i;
y[count] = i;
vis[i] = 1;
count++;
}
x[count] = i;
y[count] = j;
vis[j] = 1;
count++;
next_2 = j;
break;
}
}
if (j >= n + 1) {
cout << -1;
return 0;
}
} else if (arr[i] == 3) {
next_3 = max(next_3, i);
long long j = next_3 + 1;
for (j = next_3 + 1; j <= n; j++) {
if (arr[j] > 0 && vis[j] == 0) {
if (vis[i] != 1) {
x[count] = i;
y[count] = i;
vis[i] = 1;
count++;
}
x[count] = i;
y[count] = j;
vis[j] = 1;
count++;
x[count] = j;
y[count] = j;
count++;
next_3 = j;
break;
}
}
if (j >= n + 1) {
cout << -1;
return 0;
}
}
}
cout << count << "\n";
for (long long i = 0; i < count; i++) {
cout << x[i] << " " << y[i] << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10;
int a[MAXN][2], b[MAXN][2];
int n, m;
int main() {
int i, j, k;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%d%d", &a[i][0], &a[i][1]);
for (i = 0; i < m; i++) scanf("%d%d", &b[i][0], &b[i][1]);
int z = 1, zl = -1;
for (i = 0; i < n; i++) {
int x = 0, y = 0;
for (j = 0; j < m; j++) {
if (min(a[i][1], a[i][0]) == min(b[j][1], b[j][0]) &&
max(a[i][1], a[i][0]) == max(b[j][1], b[j][0]))
continue;
if (a[i][0] == b[j][0] || a[i][0] == b[j][1]) x++;
if (a[i][1] == b[j][0] || a[i][1] == b[j][1]) y++;
}
if (x > 0 && y > 0) {
z = -1;
break;
} else if (z == 1 && (x > 0 || y > 0)) {
if (zl == -1) {
if (x > 0)
zl = a[i][0];
else if (y > 0)
zl = a[i][1];
} else {
if (x > 0 && zl != a[i][0])
z = 0;
else if (y > 0 && zl != a[i][1])
z = 0;
}
}
}
for (i = 0; i < m; i++) {
int x = 0, y = 0;
for (j = 0; j < n; j++) {
if (min(a[j][1], a[j][0]) == min(b[i][1], b[i][0]) &&
max(a[j][1], a[j][0]) == max(b[i][1], b[i][0]))
continue;
if (b[i][0] == a[j][0] || b[i][0] == a[j][1]) x++;
if (b[i][1] == a[j][0] || b[i][1] == a[j][1]) y++;
}
if (x > 0 && y > 0) {
z = -1;
break;
} else if (z == 1 && (x > 0 || y > 0)) {
if (zl == -1) {
if (x > 0)
zl = b[i][0];
else if (y > 0)
zl = b[i][1];
} else {
if (x > 0 && zl != b[i][0])
z = 0;
else if (y > 0 && zl != b[i][1])
z = 0;
}
}
}
if (z > 0)
printf("%d\n", zl);
else
printf("%d\n", z);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int x, y;
long long total(long long t) {
if (!t) return 1;
return 1 + 2 * t * t + 2 * t;
}
long long soma(long long meio) {
if (meio <= 0) return 0;
return (1 + meio) * meio - meio;
}
long long dist(long long a, long long b) { return abs(a - x) + abs(b - y); }
long long getFolga(long long a, long long b, long long t) {
long long d = dist(a, b), folga = t - d + 1;
if (folga <= t && folga > 0) return ((1 + folga) * folga) / 2;
return 0;
}
long long getArea(long long t) {
long long area = total(t);
if (0) cout << "Area " << area << endl;
area -= soma(x + t - n + 1);
if (0) cout << "1: " << soma(x + t - n + 1) << endl;
area -= soma(y + t - n + 1);
if (0) cout << "2: " << soma(y + t - n + 1) << endl;
area -= soma(-(x - t));
if (0) cout << "3: " << soma(-(x - t)) << endl;
area -= soma(-(y - t));
if (0) cout << "4: " << soma(-(y - t)) << endl;
area += getFolga(-1, -1, t);
if (0) cout << "5: " << getFolga(-1, -1, t) << endl;
area += getFolga(n, n, t);
if (0) cout << "6: " << getFolga(n, n, t) << endl;
area += getFolga(-1, n, t);
if (0) cout << "7: " << getFolga(-1, n, t) << endl;
area += getFolga(n, -1, t);
if (0) cout << "8: " << getFolga(n, -1, t) << endl;
return area;
}
int main() {
long long c;
cin >> n >> x >> y >> c;
--x;
--y;
long long ini = 0, fim = 2000000000LL, resp = -1;
if (0) cout << getArea(3) << endl;
while (ini <= fim) {
long long t = (ini + fim) / 2;
long long area = getArea(t);
if (area >= c) {
resp = t;
fim = t - 1;
} else
ini = t + 1;
}
cout << resp << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char buf[1000];
bool result;
int N;
map<string, int> mask;
map<string, string> macro;
vector<string> name, value;
string expr;
int operind[256];
inline int addsus(int typ, int ret) {
if (!(ret & 16)) {
if (((ret & 2) && (typ & 4)) || ((ret & 2) && typ == 3) ||
((ret & 4) && typ == 5))
ret |= 16;
}
return ret;
}
int Dfs(int typ, string s) {
if (mask.find(s) != mask.end()) return addsus(typ, mask[s]);
int brk = 0;
for (int i = s.size() - 1; i >= 0; --i)
if (s[i] == '(')
--brk;
else if (s[i] == ')')
++brk;
else if (!brk && (operind[s[i]] & 2)) {
int ret = operind[s[i]];
if ((Dfs(operind[s[i]] | 8, s.substr(0, i)) & 16) ||
(Dfs(operind[s[i]], s.substr(i + 1, s.size() - i - 1)) & 16))
ret |= 16;
return addsus(typ, ret);
}
brk = 0;
for (int i = s.size() - 1; i >= 0; --i)
if (s[i] == '(')
--brk;
else if (s[i] == ')')
++brk;
else if (!brk && (operind[s[i]] & 4)) {
int ret = operind[s[i]];
if ((Dfs(operind[s[i]] | 8, s.substr(0, i)) & 16) ||
(Dfs(operind[s[i]], s.substr(i + 1, s.size() - i - 1)) & 16))
ret |= 16;
return addsus(typ, ret);
}
if (s[0] == '(' && s[s.size() - 1] == ')') {
int ret = 1;
if (Dfs(1, s.substr(1, s.size() - 2)) & 16) ret |= 16;
return addsus(typ, ret);
}
return 1;
}
int main() {
operind['+'] = 2;
operind['-'] = 3;
operind['*'] = 4;
operind['/'] = 5;
sscanf(gets(buf), "%d", &N);
name.clear();
value.clear();
macro.clear();
mask.clear();
result = true;
for (int i = 0; i < N; ++i) {
gets(buf);
istringstream sin(buf);
string t, v, u;
while (sin >> t, t != "define" && t != "#define")
;
sin >> t;
name.push_back(t);
v = "";
while (sin >> u) v += u;
value.push_back(v);
macro[t] = v;
mask[t] = Dfs(1, v);
}
gets(buf);
int L = strlen(buf);
expr.clear();
for (int i = 0; i < L; ++i)
if (!isspace(buf[i])) expr.push_back(buf[i]);
if (Dfs(1, expr) & 16)
puts("Suspicious");
else
puts("OK");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string st;
cin >> st;
int k, fi, se, cnt = 0;
cin >> k;
for (int i = 0; i < k; i++) {
char a, b;
cin >> a >> b;
fi = se = 0;
for (int j = 0; j < st.length(); j++) {
if (st[j] == a)
fi++;
else if (st[j] == b)
se++;
else {
cnt += min(fi, se);
fi = se = 0;
}
}
cnt += min(fi, se);
}
cout << cnt << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
getchar();
string line, search;
stack<int> timestamp;
int cp = 0, id;
for (int i = 0; i < n; ++i) {
getline(cin, line);
replace(line.begin(), line.end(), '(', ' ');
replace(line.begin(), line.end(), ')', ' ');
replace(line.begin(), line.end(), ',', ' ');
stringstream toks(line);
string cmd, excp, msg;
toks >> cmd;
if (cmd == "throw") {
cp = i;
toks >> search;
}
if (cmd == "try") {
timestamp.push(i);
}
if (cmd == "catch") {
id = timestamp.top();
timestamp.pop();
if (id < cp) {
toks >> excp;
if (excp == search) {
string msg;
getline(toks, msg);
msg.erase(0, msg.find('"') + 1);
msg.erase(msg.find('"'), msg.size());
cout << msg << "\n";
return 0;
}
}
}
}
cout << "Unhandled Exception";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, n, m, x, i, j;
cin >> t;
while (t--) {
cin >> n >> m;
vector<long long int> a(n), b;
map<long long int, bool> p;
for (i = 0; i < a.size(); i++) cin >> a[i];
;
for (i = 0; i < m; i++) {
cin >> x;
p[x] = true;
}
b = a;
sort(a.begin(), a.end());
for (i = 0; i < n; i++)
for (j = 0; j < n - i - 1; j++)
if (p[j + 1] && b[j] > b[j + 1]) swap(b[j], b[j + 1]);
for (i = 0; i < n; i++)
if (a[i] != b[i]) break;
if (i == n)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
int t,n;
scanf("%d",&t);
while(t--){
scanf("%d",&n);
int i=sqrt(2*n-1);
int j=(i-1)/2;
printf("%d\n",j);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m;
string s;
cin >> n >> m;
cin >> s;
for (int i = 0; i < m; i++) {
int l, r;
char c1, c2;
cin >> l >> r >> c1 >> c2;
for (int j = l - 1; j < r; j++) {
if (s[j] == c1) s[j] = c2;
}
}
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200005];
struct node {
node *l, *r;
int a, b;
int last;
pair<int, int> Min;
node(int _a, int _b) : a(_a), b(_b), l(NULL), r(NULL) { last = 0; }
} * root;
node *Clone(node *n, int i) {
if (n->last == i) return n;
node *res = new node(n->a, n->b);
res->last = i;
res->Min = n->Min;
res->l = n->l;
res->r = n->r;
return res;
}
void pull(node *n) { n->Min = min(n->l->Min, n->r->Min); }
void build(node *n) {
if (n->a == n->b) {
n->Min = make_pair(n->a, n->a);
return;
}
int mid = (n->a + n->b) / 2;
n->l = new node(n->a, mid);
n->r = new node(mid + 1, n->b);
build(n->l);
build(n->r);
pull(n);
}
void revise(node *n, int first, int k, int i) {
if (n->a == n->b) {
n->Min.first = k;
return;
}
int mid = (n->a + n->b) / 2;
if (first <= mid) {
revise(n->l, first, k, i);
} else {
revise(n->r, first, k, i);
}
pull(n);
}
pair<int, int> query(node *n, int l, int r) {
if (n->a >= l && n->b <= r) {
return n->Min;
}
if (n->b < l || n->a > r) return make_pair(1e9, 0);
return min(query(n->l, l, r), query(n->r, l, r));
}
void solve() {
for (int i = 1; i <= 200000; i++) {
for (int j = i; j <= 200000; j += i) {
v[j].push_back(i);
}
}
root = new node(1, 200000);
build(root);
long long n, m, l, r;
scanf("%lld %lld %lld %lld", &n, &m, &l, &r);
vector<vector<long long> > ans;
int last = 0;
int now = 1;
for (int i = n; i >= 1; i--) {
long long yl = (l + i - 1) / i, yr = min(r / i, m);
int ok = 0;
if (yl > yr) {
ans.push_back({-1});
continue;
}
while (now < yl) {
for (auto it : v[now]) {
revise(root, it, now + it, now);
}
now++;
}
for (auto it : v[i]) {
long long x1 = i;
long long Max = n / (x1 / it);
long long y1;
long long target;
tie(y1, target) = query(root, it + 1, Max);
if (y1 > yr) {
continue;
}
long long x2 = x1 / it * target;
long long y2 = x1 * y1 / x2;
if (y1 <= yr && x2 <= n) {
ans.push_back({x1, y1, x2, y2});
ok = 1;
break;
}
}
if (!ok) {
ans.push_back({-1});
}
}
reverse(ans.begin(), ans.end());
for (auto it : ans) {
for (auto it2 : it) {
printf("%lld ", it2);
}
printf("\n");
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
}
| 11 |
#include <bits/stdc++.h>
int solve() {
int N, M;
std::cin >> N >> M;
int ans = N + 1;
for (int i = 0; i < M; ++i) {
int l, r;
std::cin >> l >> r;
--l;
int dist = r - l;
if (dist < ans) ans = dist;
}
std::cout << ans << '\n';
for (int i = 0; i < N; ++i) {
std::cout << (i % ans) << ' ';
}
return 0;
}
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
int test_count = 1;
while (test_count--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int w = 1, s = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = 0;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = (s << 1) + (s << 3) + ch - '0';
ch = getchar();
}
return w ? s : -s;
}
const int N = 1001;
struct point {
int x, y, num;
} p[N];
struct square {
int x, y, r;
} s[N];
int opp[N], bel[N];
bool num[N];
int n, m, k, ans;
vector<int> f[N];
bool cmp1(point a, point b) { return a.x < b.x; }
bool cmp2(square a, square b) { return a.x - a.r < b.x - b.r; }
bool solve(int x) {
if (x == 0) return 1;
return 0;
}
void content() {
n = read(), m = read(), k = read();
for (int i = 1; i <= n; i++) p[i].x = read(), p[i].y = read(), p[i].num = i;
sort(p + 1, p + n + 1, cmp1);
for (int i = 1; i <= n; i++) opp[p[i].num] = i;
for (int i = 1; i <= m; i++) {
s[i].r = read();
s[i].x = read(), s[i].y = read();
}
sort(s + 1, s + m + 1, cmp2);
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (p[j].x < s[i].x - s[i].r) continue;
if (p[j].x > s[i].x + s[i].r) break;
int a = p[j].x, b = p[j].y, c = s[i].x, d = s[i].y;
double lc = sqrt(pow((a - c), 2) + pow((b - d), 2));
if (lc < s[i].r) f[p[j].num].push_back(i);
}
}
for (int i = 1; i <= k; i++) {
int x = read(), y = read();
for (int j = 0; j < f[x].size(); j++) num[f[x][j]] = solve(num[f[x][j]]);
for (int j = 0; j < f[y].size(); j++) num[f[y][j]] = solve(num[f[y][j]]);
for (int i = 1; i <= m; i++)
if (num[i]) ans++;
printf("%d\n", ans);
ans = 0;
memset(num, 0, sizeof(num));
}
}
int main() {
content();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long a[N], b[N];
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n, p = 0, q = 0;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) {
long long mn = min(i + 2, (long long)30);
for (long long j = 2; j <= mn; j++) {
if (a[i] % j != 0) {
p = 1;
break;
}
}
if (!p) {
q = 1;
break;
}
p = 0;
}
cout << (q ? "NO\n" : "YES\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const long long mod = 1e9 + 7;
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
long long reset(long long n, long long pos) { return n = n & ~(1LL << pos); }
bool check(long long n, long long pos) { return (bool)(n & (1LL << pos)); }
long long msb(long long mask) { return (mask & (-mask)); }
struct lca {
long long u, v, lc;
} LCA[105];
long long edge[22];
long long n, m, q;
long long dp[15][(1LL << 13) + 2];
bool vis[15][(1LL << 13) + 2];
bool checkEdge(long long childMask, long long childRoot, long long root) {
if ((edge[childRoot] & (childMask | (1 << root))) == edge[childRoot])
return true;
return false;
}
bool checkLCA(long long childMask) {
for (long long i = 1; i <= q; i++) {
if (childMask & (1 << LCA[i].lc)) {
if ((~childMask & (1 << LCA[i].u)) || (~childMask & (1 << LCA[i].v)))
return false;
} else {
if ((childMask & (1 << LCA[i].u)) && (childMask & (1 << LCA[i].v)))
return false;
}
}
return true;
}
long long solve(long long root, long long mask) {
long long &ret = dp[root][mask];
bool &v = vis[root][mask];
if (v) return ret;
v = true;
if (check(mask, root) == 0) return ret = 0;
if (__builtin_popcountll(mask) == 1) return ret = 1;
ret = 0;
long long xmask = reset(mask, root);
long long temp = msb(xmask);
for (long long nmask = xmask; nmask; nmask = (nmask - 1) & xmask) {
if (!(nmask & temp)) continue;
for (long long nroot = 0; nroot < n; nroot++) {
if (!check(nmask, nroot)) continue;
if (checkEdge(nmask, nroot, root) && checkLCA(nmask)) {
ret += (solve(nroot, nmask) * solve(root, nmask ^ mask));
}
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int T;
T = 1;
for (int cs = 1; cs <= T; cs++) {
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
long long u, v;
cin >> u >> v;
u--;
v--;
edge[u] = Set(edge[u], v);
edge[v] = Set(edge[v], u);
}
for (int i = 1; i <= q; i++) {
cin >> LCA[i].u >> LCA[i].v >> LCA[i].lc;
LCA[i].u--;
LCA[i].v--;
LCA[i].lc--;
}
cout << solve(0, ((1LL << n) - 1));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 5e5 + 10;
int c[sz], an[sz];
vector<pair<int, int> > sp;
set<int> us;
map<int, int> se;
multiset<int, greater<int> > be;
void add(int l, int r) {
se[l] = r - l;
be.insert(r - l);
sp.push_back({l, r});
}
void ins(int p) {
auto it = se.upper_bound(p);
int l = 0, r = 0;
if (it != se.end()) {
if ((*it).first == p + 1) r = (*it).second;
}
if (it != se.begin()) {
it--;
if ((*it).first + (*it).second == p) l = (*it).second;
}
if (l) {
be.erase(be.find(l));
se.erase(p - l);
}
if (r) {
be.erase(be.find(r));
se.erase(p + 1);
}
add(p - l, p + 1 + r);
}
void del(int p) {
auto it = se.upper_bound(p);
it--;
int l = (*it).first, r = l + (*it).second;
be.erase(be.find(r - l));
se.erase(it);
if (l < p) add(l, p);
if (r > p + 1) add(p + 1, r);
}
int main() {
int n;
cin >> n;
pair<int, int> ar[n];
for (int a = 0; a < n; a++) {
scanf("%d", &ar[a].first);
ar[a].second = a;
us.insert(us.end(), a);
}
sort(ar, ar + n);
reverse(ar, ar + n);
int yk = 0, ma = 0;
while (yk < n) {
int x = ar[yk].first;
while (yk < n and ar[yk].first == x) {
int i = ar[yk].second, q = 0;
c[i] = 1;
if (i) {
if (c[i - 1])
del(i - 1), q++;
else
ins(i - 1);
} else
q++;
if (i + 1 < n) {
if (c[i + 1])
del(i), q++;
else
ins(i);
} else
q++;
if (q) {
if (i and c[i - 1]) an[i - 1] = max(an[i - 1], x);
an[i] = max(an[i], x);
if (i + 1 < n and c[i + 1]) an[i + 1] = max(an[i + 1], x);
}
yk++;
}
if (be.size()) ma = max(ma, (*be.begin()) >> 1);
for (int a = 0; a < sp.size(); a++) {
int l = sp[a].first, r = sp[a].second;
auto it = se.find(l);
if (it != se.end() and (*it).second == r - l) {
if (c[l] and c[r])
l++;
else if (c[l])
l++, r = (l + r) >> 1;
else if (c[r])
l++, l = (l + r) >> 1;
else
l = 1e9;
auto it = us.lower_bound(l);
while (it != us.end() and (*it) < r) {
an[*it] = max(an[*it], x);
auto it2 = it++;
us.erase(it2);
}
}
}
sp.clear();
}
cout << ma << "\n";
for (int a = 0; a < n; a++) printf("%d ", an[a]);
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s, a[500005], b[500005], h[500005], c;
int main() {
scanf("%d %d %d %d", &n, &m, &k, &s);
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]);
for (int i = (1); i <= (s); i++) {
int x;
scanf("%d", &x);
if (!b[x]) c++;
b[x]++;
}
int j = 0;
for (int i = (1); i <= (n); i++) {
h[a[i]]++;
if (h[a[i]] == b[a[i]]) c--;
if (!c) {
while (j < i - 1 && h[a[j + 1]] - 1 >= b[a[j + 1]]) {
j++;
h[a[j]]--;
}
int range = i - j;
int remove = max(0, range - m);
int maxremove = range - s;
int from = j / m * m + 1;
int to = from + m - 1;
int dis = max(0, i - remove - to);
int add = min(dis, maxremove - remove);
remove += add;
dis -= add;
if (dis <= j) {
int tot = remove + dis;
if (n - tot >= m * k) {
printf("%d\n", tot);
for (int k = (j + 1); k <= (i); k++) {
if (remove && h[a[k]] - 1 >= b[a[k]]) {
printf("%d\n", k);
h[a[k]]--;
remove--;
}
if (!remove) break;
}
for (int k = (j - 1); k >= (j - dis); k--) printf("%d\n", k);
return 0;
}
}
}
}
puts("-1");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int infi = 1e9 + 7;
const long long infl = 1e18 + 7;
int ar[200500];
vector<int> len;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> ar[i];
int flag = 0;
for (int i = 0; i < n; ++i)
if (ar[i] < 0) flag = 1;
if (!flag) {
cout << 0;
return 0;
}
int w = 0;
for (int i = 0; i < n; ++i) {
if (ar[i] >= 0) continue;
++w;
int j = i - 1;
for (; j >= 0 && ar[j] >= 0; --j)
;
if (j == -1) continue;
len.push_back(i - j - 1);
}
if (w > k) {
cout << -1;
return 0;
}
int w1 = w;
int ans = 2 + len.size() * 2;
int ans1 = ans;
sort(len.begin(), len.end());
for (int i = 0; i < (int)len.size(); ++i) {
if (w + len[i] > k) break;
w += len[i];
ans1 -= 2;
}
w = w1;
for (int i = n - 1; i >= 0 && ar[i] >= 0; --i) ++w;
int ans2 = ans - 1;
for (int i = 0; i < (int)len.size(); ++i) {
if (w + len[i] > k) break;
w += len[i];
ans2 -= 2;
}
if (w > k) ans2 = infi;
cout << min(ans1, ans2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define IOS ios_base::sync_with_stdio(false); cin.tie (nullptr)
#define PREC cout.precision (10); cout << fixed
#ifdef CONVICTION
#include "/home/convict/Dropbox/myfiles/sport_coding/cplib/snippets/debug.h"
#else
#define debug(x...)
#endif
typedef long long Int;
typedef long double ff;
#define F first
#define S second
//Don’t practice until you get it right. Practice until you can’t get it wrong
void preproc() { }
void reset() { }
void solve()
{
const vector <int> dx{0, 1, -1, 0};
const vector <int> dy{1, 0, 0, -1};
int n, m;
Int w;
cin >> n >> m >> w;
vector <vector <int>> mat(n, vector <int> (m));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
cin >> mat[i][j];
function <vector <vector<int>> (int, int)> bfs
= [&] (int sx, int sy) {
vector <vector<bool>> vis(n, vector <bool>(m));
vector <vector <int>> dist(n, vector <int> (m, INT_MAX));
dist[sx][sy] = 0;
vis[sx][sy] = true;
queue <pair <int, int>> q;
q.push({sx, sy});
while (!q.empty()) {
auto [ux, uy] = q.front();
int& d = dist[ux][uy];
q.pop();
for (int rot = 0; rot < 4; ++rot) {
int vx = ux + dx[rot];
int vy = uy + dy[rot];
if (vx >= 0 and vx < n and vy >= 0 and vy < m
and mat[vx][vy] != -1 and vis[vx][vy] == false) {
vis[vx][vy] = true;
q.push({vx, vy});
dist[vx][vy] = d + 1;
}
}
}
return dist;
};
Int res, fs, ft;
res = fs = ft = LLONG_MAX;
vector <vector<int>> ds = bfs(0, 0);
vector <vector<int>> dt = bfs(n-1, m-1);
if (ds[n-1][m-1] != INT_MAX)
res = min(res, w*ds[n-1][m-1]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (mat[i][j] > 0) {
if (ds[i][j] != INT_MAX)
fs = min(fs, w*ds[i][j] + mat[i][j]);
if (dt[i][j] != INT_MAX)
ft = min(ft, w*dt[i][j] + mat[i][j]);
}
if (fs != LLONG_MAX and ft != LLONG_MAX)
res = min(res, fs + ft);
cout << (res == LLONG_MAX ? -1 : res) << '\n';
}
signed main()
{
IOS; PREC;
preproc();
int tc = 1;
// cin >> tc;
for (int Tt = 1; Tt <= tc; ++Tt) {
// debug(Tt);
// cout << "Case #" << Tt << ": ";
reset();
solve();
}
return EXIT_SUCCESS;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
vector<int> dp;
vector<int> ans;
vector<vector<int>> g;
void dfs(int v, int p = -1) {
dp[v] = a[v];
for (auto to : g[v]) {
if (to == p) continue;
dfs(to, v);
dp[v] += max(dp[to], 0);
}
}
void dfs2(int v, int p = -1) {
ans[v] = dp[v];
for (auto to : g[v]) {
if (to == p) continue;
dp[v] -= max(0, dp[to]);
dp[to] += max(0, dp[v]);
dfs2(to, v);
dp[to] -= max(0, dp[v]);
dp[v] += max(0, dp[to]);
}
}
int main() {
int n;
cin >> n;
a = dp = ans = vector<int>(n);
g = vector<vector<int>>(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] == 0) a[i] = -1;
}
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(0);
dfs2(0);
for (auto it : ans) cout << it << " ";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int n, m;
cin >> n >> m;
long long int a[n], b[m];
long long int aux[n];
for (long long int i = 0; i < n; ++i) {
cin >> a[i];
if (i == 0)
aux[i] = a[i];
else
aux[i] = aux[i - 1] + a[i];
}
for (long long int i = 0; i < m; ++i) cin >> b[i];
long long int j = 0;
for (long long int i = 0; i < m; ++i) {
while (j < n && aux[j] < b[i]) ++j;
if (j == 0)
cout << j + 1 << " " << b[i] << endl;
else
cout << j + 1 << " " << b[i] - aux[j - 1] << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1004000], n;
int MD = 998244353;
long long cum[1004000], pwr[1004000];
;
long long pw(int x) {
if (x == n) return 1;
int zb = n - x;
long long res = 0;
res += pwr[zb - 1] * 2;
res %= MD;
if (zb >= 2) res += (1ll * pwr[zb - 2] * (zb - 1)) % MD;
res %= MD;
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
pwr[0] = 1;
for (int i = 1; i <= n; i++) {
cum[i] = cum[i - 1] + a[i];
cum[i] %= MD;
pwr[i] = pwr[i - 1] * 2;
pwr[i] %= MD;
}
long long zbr = 0, ans = 0;
for (int i = 1; i <= n; i++) {
ans += (1ll * pw(i) * cum[i]) % MD;
ans %= MD;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[3003];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long co = 0;
for (int i = 1; i < n; i++) {
if (a[i] <= a[i - 1]) {
co += a[i - 1] - a[i] + 1;
a[i] = a[i - 1] + 1;
}
}
cout << co << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
double ans;
scanf("%d%d%d", &n, &m, &k);
if (n + k < m) {
ans = 0;
} else {
ans = 1;
for (int i = 0; i <= k; i++) ans *= (double)(m - i) / (n + i + 1);
ans = 1 - ans;
}
printf("%.6lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct Edge {
int from, to;
T cap, flow;
int index;
Edge(int from, int to, T cap, T flow, int index)
: from(from), to(to), cap(cap), flow(flow), index(index) {}
};
template <class T>
struct PushRelabel {
int n;
vector<vector<Edge<T>>> adj;
vector<T> excess;
vector<int> heights, count;
vector<bool> active;
vector<vector<int>> buckets;
int max_height;
queue<int> Q;
const int source = 0, sink = 1;
PushRelabel() : n(2), adj(2) {}
int add_vertex() {
adj.push_back({});
return n++;
}
void add_edge(int from, int to, int cap) {
adj[from].push_back(Edge<T>(from, to, cap, 0, int(adj[to].size())));
if (from == to) {
adj[from].back().index++;
}
adj[to].push_back(Edge<T>(to, from, 0, 0, int(adj[from].size()) - 1));
}
void Enqueue(int v) {
if (!active[v] && excess[v] > 0 && heights[v] < n) {
active[v] = true;
buckets[heights[v]].push_back(v);
max_height = max(max_height, heights[v]);
}
}
void Gap(int k) {
for (int v = 0; v < n; v++)
if (heights[v] >= k) {
count[heights[v]]--;
heights[v] = max(heights[v], n);
assert(heights[v] == n);
count[heights[v]]++;
Enqueue(v);
}
}
void Relabel(int v) {
count[heights[v]]--;
heights[v] = n;
for (auto e : adj[v])
if (e.cap - e.flow > 0) {
heights[v] = min(heights[v], heights[e.to] + 1);
}
count[heights[v]]++;
Enqueue(v);
}
T maxflow() {
heights = vector<int>(n, 0);
excess = vector<T>(n, 0);
count = vector<int>(n + 1, 0);
active = vector<bool>(n, false);
buckets = vector<vector<int>>(n);
max_height = 0;
for (auto &e : adj[source]) excess[source] += e.cap;
count[0] = n;
Enqueue(source);
active[sink] = true;
while (max_height >= 0) {
if (!buckets[max_height].empty()) {
int v = buckets[max_height].back();
buckets[max_height].pop_back();
active[v] = false;
for (auto &e : adj[v]) {
if (excess[v] == 0) break;
const auto delta = min(excess[e.from], e.cap - e.flow);
if (heights[e.to] == heights[e.from] - 1 && delta) {
e.flow += delta;
adj[e.to][e.index].flow -= delta;
excess[e.to] += delta;
excess[e.from] -= delta;
Enqueue(e.to);
}
}
if (excess[v] > 0) {
if (count[heights[v]] == 1)
Gap(heights[v]);
else
Relabel(v);
}
} else
max_height--;
}
return excess[sink];
}
};
int main() {
ios::sync_with_stdio(false);
auto network = PushRelabel<int>();
int n;
cin >> n;
auto vertices = array<vector<int>, 2>{};
for (auto &vs : vertices) vs = vector<int>(4 * n);
const function<int(int, int, int, bool)> build =
[&](const int i, const int l, const int r, const bool direction) {
const auto v = vertices[direction][i] = network.add_vertex();
if (r - l == 1) {
if (direction)
network.add_edge(network.source, v, 1);
else
network.add_edge(v, network.sink, 1);
} else {
const auto m = (l + r) / 2;
const auto w1 = build(2 * i, l, m, direction);
const auto w2 = build(2 * i + 1, m, r, direction);
if (direction) {
network.add_edge(w1, v, n);
network.add_edge(w2, v, n);
} else {
network.add_edge(v, w1, n);
network.add_edge(v, w2, n);
}
}
return v;
};
for (auto direction : {true, false}) build(1, 0, n, direction);
using Segment = array<int, 2>;
using Rectangle = array<Segment, 2>;
const auto add_rectangle = [&](const Rectangle q) {
if (q[0][0] == q[0][1] || q[1][0] == q[1][1]) return;
const auto v = network.add_vertex();
for (const auto direction : {true, false}) {
const auto ql = q[direction][0], qr = q[direction][1];
const function<void(int, int, int)> connect =
[&](const int i, const int l, const int r) {
if (ql >= r || l >= qr)
return;
else if (ql <= l && r <= qr) {
if (direction)
network.add_edge(vertices[direction][i], v, n);
else
network.add_edge(v, vertices[direction][i], n);
} else {
const auto m = (l + r) / 2;
connect(2 * i, l, m);
connect(2 * i + 1, m, r);
}
};
connect(1, 0, n);
}
};
int q;
cin >> q;
struct Event {
bool type;
int x;
Segment y;
};
auto events = vector<Event>();
for (auto i = 0; i < q; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1--;
y1--;
x2--;
y2--;
events.push_back({true, x1, {y1, y2 + 1}});
events.push_back({false, x2 + 1, {y1, y2 + 1}});
}
events.push_back({false, 0, {0, n}});
events.push_back({true, n, {0, n}});
const auto event_compare = [](const Event a, const Event b) {
if (a.x != b.x)
return a.x < b.x;
else
return a.type < b.type;
};
sort(begin(events), end(events), event_compare);
struct PartialRectangle {
int x1;
Segment y;
};
const auto rect_compare = [](const PartialRectangle a,
const PartialRectangle b) {
return a.y[0] < b.y[0];
};
auto active = set<PartialRectangle, decltype(rect_compare)>(rect_compare);
for (const auto e : events) {
if (e.type) {
auto to_insert = vector<PartialRectangle>();
auto i = active.lower_bound({0, e.y[0]});
if (i != begin(active) && prev(i)->y[1] > e.y[0]) i = prev(i);
while (i != end(active) && i->y[0] < e.y[1]) {
if (i->y[0] < e.y[0]) to_insert.push_back({e.x, {i->y[0], e.y[0]}});
if (e.y[1] < i->y[1]) to_insert.push_back({e.x, {e.y[1], i->y[1]}});
add_rectangle({{{i->x1, e.x}, i->y}});
active.erase(i++);
}
for (const auto r : to_insert) active.insert(r);
} else
active.insert({e.x, e.y});
}
cout << network.maxflow() << endl;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
string second, t;
string smallest(string second) {
if ((int)second.size() % 2 == 1) return second;
int m = (int)second.size() / 2;
string s1 = smallest(second.substr(0, m));
string s2 = smallest(second.substr(m, (int)second.size()));
if (s1 < s2)
return s1 + s2;
else
return s2 + s1;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> second >> t;
if (smallest(second) == smallest(t))
cout << "Yes\n";
else
cout << "No\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-5;
int R, G, B;
int main() {
while (cin >> R >> G >> B) {
int res = -1;
if (R != 0) {
res = max(res, 30 + ((R - 1) / 2) * 3);
}
if (G != 0) {
res = max(res, 31 + ((G - 1) / 2) * 3);
}
if (B != 0) {
res = max(res, 32 + ((B - 1) / 2) * 3);
}
cout << res << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[20], b[20];
int main() {
string str;
cin >> str;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
for (int i = 0; str[i]; i++) {
a[str[i] - '0']++;
}
a[2] += a[5];
a[5] = a[2];
a[6] += a[9];
a[9] = a[6];
cin >> str;
for (int i = 0; str[i]; i++) {
b[str[i] - '0']++;
}
b[2] += b[5];
b[5] = b[2];
b[6] += b[9];
b[9] = b[6];
int ans = 1000000;
for (int i = 0; i < 10; i++)
if (a[i]) {
ans = min(ans, b[i] / a[i]);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k, r, a[100100], b[100100];
bool u[100100];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + n);
for (i = 0; i < n; i++) a[i] = lower_bound(b, b + n, a[i]) - b;
for (i = 0; i < n; i++)
if (!u[i]) {
for (j = i; !u[j]; j = a[j]) u[j] = true;
r++;
}
cout << r << endl;
for (i = 0; i < n; i++)
if (u[i]) {
for (k = 0, j = i; u[j]; j = a[j], k++) {
b[k] = j;
u[j] = false;
}
sort(b, b + k);
cout << k;
for (j = 0; j < k; j++) cout << ' ' << b[j] + 1;
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 222222;
int n, k;
int a[N];
long long s[2][N];
pair<long long, int> dp[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
s[0][i] = s[0][i - 1] + a[i];
}
for (int i = n; i >= 1; --i) {
s[1][i] = s[1][i + 1] + a[i];
}
for (int i = n - k + 1; i >= 1; --i) {
long long t = s[1][i] - s[1][i + k];
if (t >= dp[i + 1].first) {
dp[i] = {t, i};
} else {
dp[i] = dp[i + 1];
}
}
pair<int, int> ans;
long long mx = 0;
for (int i = k; i <= n - k; ++i) {
if (s[0][i] - s[0][i - k] + dp[i + 1].first > mx) {
mx = s[0][i] - s[0][i - k] + dp[i + 1].first;
ans = {i - k + 1, dp[i + 1].second};
}
}
cout << ans.first << ' ' << ans.second << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long pot(long long b, long long e) {
long long res = 1;
b %= (1000000000 + 7);
while (e) {
if (e & 1) {
res = (res * b) % (1000000000 + 7);
}
b = (b * b) % (1000000000 + 7);
e /= 2;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> vet1(n);
for (auto& p : vet1) {
cin >> p;
}
long long m;
cin >> m;
vector<long long> vet2(m);
for (auto& p : vet2) {
cin >> p;
}
long long p1 = 0, p2 = 0;
sort(vet1.begin(), vet1.end());
sort(vet2.begin(), vet2.end());
pair<long long, pair<long long, long long> > res{-0x3f3f3f3f3f3f3f3fLL,
{-1, -1}};
vet1.push_back(0x3f3f3f3f3f3f3f3fLL);
vet2.push_back(0x3f3f3f3f3f3f3f3fLL);
while (p1 <= n) {
if (p2 <= m) {
while (p2 < m && vet2[p2] < vet1[p1]) {
long long a = (n - p1) * 3 + p1 * 2;
long long b = (m - p2) * 3 + p2 * 2;
res = max(res, {a - b, {a, b}});
++p2;
while (p2 + 1 < m && vet2[p2] == vet2[p2 - 1]) {
++p2;
}
}
}
long long a = (n - p1) * 3 + p1 * 2;
long long b = (m - p2) * 3 + p2 * 2;
res = max(res, {a - b, {a, b}});
++p1;
while (p1 + 1 < n && vet1[p1] == vet1[p1 - 1]) {
++p1;
}
}
long long a = (n - p1) * 3 + p1 * 2;
long long b = (m - p2) * 3 + p2 * 2;
res = max(res, {a - b, {a, b}});
cout << res.second.first << ":" << res.second.second << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const double PI = acos(-1.0);
int mod = 998244353;
const long long INF = 1e9 + 47;
const long long LINF = INF * INF;
int a[200000];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, s;
cin >> n >> s;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long ans = 0;
int mid = n / 2;
ans += abs(a[mid] - s);
mid = n / 2 + 1;
while (mid < n && a[mid] < s) {
ans += abs(a[mid] - s);
mid++;
}
mid = n / 2 - 1;
while (mid >= 0 && a[mid] > s) {
ans += abs(a[mid] - s);
mid--;
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool a[8000];
vector<int> prime;
int main() {
for (int j = 2; j < 8000; j++) {
if (!a[j]) {
prime.emplace_back(j);
for (int i = j; i < 8000; i += j) a[i] = true;
}
}
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cout << prime[i] << " \n"[i == n - 1];
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (b) {
long long t = a % b;
a = b;
b = t;
}
return a;
}
int main() {
int n;
long long p, q, b;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld%lld%lld", &p, &q, &b);
if (p % q == 0) {
printf("Finite\n");
continue;
}
q /= gcd(q, p);
long long x = gcd(q, b);
while (x != 1) {
while (q % x == 0) q /= x;
x = gcd(b, q);
}
if (q == 1)
printf("Finite\n");
else
printf("Infinite\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const long long inf = numeric_limits<long long>::max();
struct edge {
int idx, w, to;
edge() {}
edge(int idx, int w, int to) : idx(idx), w(w), to(to) {}
};
struct item {
long long dist;
int v;
bool operator<(const item &o) const { return dist > o.dist; }
};
int n, m, k;
long long d[N];
vector<edge> g[N];
vector<int> ans;
int l[N];
bool vis[N];
void dijkstra() {
if (k == 0) return;
fill(d, d + n, inf);
d[0] = 0;
priority_queue<item> pq;
pq.push({0, 0});
while (!pq.empty()) {
item curr = pq.top();
pq.pop();
if (vis[curr.v])
continue;
else if (curr.v != 0) {
ans.emplace_back(l[curr.v]);
k--;
if (k == 0) return;
}
vis[curr.v] = true;
for (auto u : g[curr.v])
if (d[u.to] > d[curr.v] + u.w) {
d[u.to] = d[curr.v] + u.w;
pq.push({d[u.to], u.to});
l[u.to] = u.idx;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int a, b, w;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
cin >> a >> b >> w;
g[a - 1].emplace_back(edge(i, w, b - 1));
g[b - 1].emplace_back(edge(i, w, a - 1));
}
dijkstra();
cout << ans.size() << endl;
for (auto u : ans) cout << u + 1 << " ";
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long ans = 0;
for (long long i = 1; i < s.size(); i++) {
if (((s[i - 1] - '0') * 10 + s[i] - '0') % 4 == 0) {
ans += i;
}
}
for (long long i = 0; i < s.size(); i++) {
if ((s[i] - '0') % 4 == 0) {
ans++;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
constexpr ll mod = 998244353;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> deg(n);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
++deg[a];
++deg[b];
}
vector<ll> f(n);
f[0] = 1;
for (int i = 1; i <= n - 1; i++) {
f[i] = (i * f[i - 1]) % mod;
}
ll res = 1;
for (int i = 0; i < n; i++) {
res = (res * f[deg[i]]) % mod;
}
cout << (n * res) % mod << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int p[100005] = {0};
int used[100005] = {0};
vector<pair<int, int> > ans;
vector<int> v;
int main() {
int n;
cin >> n;
if (n <= 2) {
cout << "0" << endl;
return 0;
}
int lim = n / 2;
for (int i = 3; i <= lim; i += 2) {
if (p[i] == 0) {
int t = i + i;
v.push_back(i);
while (t <= n) {
if (used[t] == 0) v.push_back(t);
p[t] = 1;
t += i;
}
if (v.size() % 2 == 0) {
for (int j = 0; j < v.size(); j += 2) {
ans.push_back(make_pair(v[j], v[j + 1]));
used[v[j]] = used[v[j + 1]] = 1;
}
} else {
if (v.size() > 1) {
ans.push_back(make_pair(v[0], v[2]));
used[v[0]] = used[v[2]] = 1;
}
for (int j = 3; j < v.size(); j += 2) {
ans.push_back(make_pair(v[j], v[j + 1]));
used[v[j]] = used[v[j + 1]] = 1;
}
}
v.clear();
}
}
for (int i = 2; i <= n; i += 2) {
if (used[i] == 0) v.push_back(i);
}
if (v.size() % 2 == 0) {
for (int j = 0; j < v.size(); j += 2) {
ans.push_back(make_pair(v[j], v[j + 1]));
used[v[j]] = used[v[j + 1]] = 1;
}
} else {
if (v.size() > 1) {
ans.push_back(make_pair(v[0], v[2]));
used[v[0]] = used[v[2]] = 1;
}
for (int j = 3; j < v.size(); j += 2) {
ans.push_back(make_pair(v[j], v[j + 1]));
used[v[j]] = used[v[j + 1]] = 1;
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
bool caase(char c1, char c2) {
char a1, a2, b1, b2;
if (c1 >= 'a' && c1 <= 'z') {
a1 = c1;
a2 = c1 - 32;
} else if (c1 >= 'A' && c1 <= 'Z') {
a2 = c1;
a1 = c1 + 32;
}
if (a1 == c2 || a2 == c2)
return true;
else
return false;
}
bool comp(string a, string b) {
int i = 0, j = 0, k, l1 = a.length(), l2 = b.length();
while (i < l1 && j < l2) {
if (a[i] == '_' || a[i] == ';' || a[i] == '-') {
i++;
continue;
}
if (b[j] == '_' || b[j] == ';' || b[j] == '-') {
j++;
continue;
}
if (!caase(a[i], b[j])) {
return false;
}
i++;
j++;
}
if (i == l1) {
while (j < l2) {
if (b[j] == '_' || b[j] == ';' || b[j] == '-') {
j++;
continue;
}
return false;
}
return true;
}
if (j == l2) {
while (i < l1) {
if (a[i] == '_' || a[i] == ';' || a[i] == '-') {
i++;
continue;
}
return false;
}
return true;
}
return true;
}
string str[3];
int main() {
string a, b, c;
int n;
cin >> str[0] >> str[1] >> str[2];
cin >> n;
while (n--) {
bool x = false;
cin >> a;
sort(str, str + 3);
do {
b.assign("");
b.assign(str[0]);
b.append(str[1]);
b.append(str[2]);
x = x || comp(a, b);
} while (next_permutation(str, str + 3));
if (x)
cout << "ACC" << endl;
else
cout << "WA" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ans = 0;
vector<int> vertical;
vector<int> poz_verti;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
vertical.push_back(x);
}
sort(vertical.begin(), vertical.end());
for (int i = 0; i < m; i++) {
int x1, x2, y;
cin >> x1 >> x2 >> y;
if (x1 == 1) {
if (x2 >= 1e9)
ans++;
else
poz_verti.push_back(x2);
}
}
sort(poz_verti.begin(), poz_verti.end());
if (poz_verti.size() == 0) {
cout << ans;
} else {
int i = 0;
for (int j = 0; j < poz_verti.size(); j++) {
if (i >= n)
j = poz_verti.size() + 1;
else {
if (poz_verti[j] >= vertical[i]) {
i++;
ans++;
}
}
}
cout << ans;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
int main() {
long long p, k;
while (cin >> p >> k) {
long long ans = 1;
if (k == 0) {
for (int i = 0; i < p - 1; i++) ans = (ans * p) % MOD;
} else if (k == 1) {
for (int i = 0; i < p; i++) ans = (ans * p) % MOD;
} else {
long long s = k;
long long e = 1;
while (s != 1) {
e++;
s = (s * k) % p;
}
for (int i = 0; i < (p - 1) / e; i++) ans = (ans * p) % MOD;
}
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
queue<long long> q;
q.push(1);
long long i = 1, ans = 0;
while (!q.empty() && i < n) {
long long sz = q.size();
while (sz && (i < n)) {
sz--;
q.pop();
q.push(v[i]);
long long j = i + 1;
while ((j < n) && (v[j] > v[i])) {
q.push(v[j]);
i++;
j++;
}
i = j;
}
ans++;
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] == 1) {
cout << n + 1 << " ";
for (int i = 0; i < n; i++) {
cout << i + 1 << " ";
}
return;
}
if (a[n - 1] == 0) {
for (int i = 0; i <= n; i++) {
cout << i + 1 << " ";
}
return;
}
bool f = 0;
for (int i = 0; i < n; i++) {
cout << i + 1 << " ";
if (a[i] == 0 and a[i + 1] == 1 and !f) {
f = 1;
cout << n + 1 << " ";
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[2010], s[2010];
int dp[2010][4010];
long long p2[2010];
const int mod = 1000000007;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i] >>= 1;
}
p2[0] = 1;
for (int i = 0; i < n; i++) {
p2[i + 1] = (p2[i] << 1);
p2[i + 1] %= mod;
}
for (int i = n - 1; i >= 0; i--) {
s[i] = s[i + 1] + (a[i] == 0);
}
k--;
int ret = 0;
dp[0][0] = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << k); j++) {
if (!dp[i][j]) {
continue;
}
if (a[i] == 1 || a[i] == 0) {
dp[i + 1][j + 1] += dp[i][j];
dp[i + 1][j + 1] %= mod;
}
if (a[i] == 2 || a[i] == 0) {
if (j & 1) {
dp[i + 1][2] += dp[i][j];
dp[i + 1][2] %= mod;
} else {
dp[i + 1][j + 2] += dp[i][j];
dp[i + 1][j + 2] %= mod;
}
}
}
for (int j = (1 << k); j <= 4000; j++) {
if (!dp[i + 1][j]) {
continue;
}
ret += (p2[s[i + 1]]) % mod * dp[i + 1][j] % mod;
ret %= mod;
}
}
printf("%d\n", ret);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (d > 2 * c || 2 * d < c || d >= b) {
printf("-1\n");
return 0;
}
int tmp = max(c, d);
cout << max(d * 2 + 2, a) << endl;
cout << max(d * 2 + 1, b) << endl;
cout << tmp << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long fa[100005];
long long num[100005];
long long belong[100005];
long long mpt[505][505];
long long find(long long x) {
if (x != fa[x]) fa[x] = find(fa[x]);
return fa[x];
}
void hebing(long long x, long long y) {
x = find(x);
y = find(y);
fa[y] = x;
}
bool judge() {
long long i, j, p;
p = 1;
for (i = 1; i <= k; i++) {
int x = find(p);
for (j = 1; j <= num[i]; j++)
if (find(p++) != x) return 0;
}
return 1;
}
void floyd() {
for (long long p = 1; p <= k; p++) {
for (long long i = 1; i <= k; i++) {
for (long long j = 1; j <= k; j++) {
mpt[i][j] = min(mpt[i][j], mpt[i][p] + mpt[p][j]);
}
}
}
}
int main() {
long long i, j, p;
while (scanf("%I64d%I64d%I64d", &n, &m, &k) != EOF) {
memset(mpt, 0x3f3f3f3f, sizeof(mpt));
for (i = 1; i <= k; i++)
for (j = 1; j <= k; j++) {
if (i == j)
mpt[i][j] = mpt[j][i] = 0;
else
mpt[i][j] = mpt[j][i] = 0x3f3f3f3f;
}
for (i = 1; i <= n; i++) fa[i] = i;
p = 1;
for (i = 1; i <= k; i++) {
scanf("%I64d", &num[i]);
for (j = 1; j <= num[i]; j++) belong[p++] = i;
}
long long u, v, w, uu, vv;
while (m--) {
scanf("%I64d%I64d%I64d", &u, &v, &w);
if (!w) hebing(u, v);
uu = belong[u];
vv = belong[v];
mpt[uu][vv] = mpt[vv][uu] = min(mpt[uu][vv], w);
}
if (!judge()) {
printf("No\n");
continue;
}
printf("Yes\n");
floyd();
for (i = 1; i <= k; i++) {
for (j = 1; j <= k; j++) {
if (i == j) mpt[i][j] = 0;
if (mpt[i][j] == 0x3f3f3f3f) mpt[i][j] = -1;
if (j < k)
printf("%I64d ", mpt[i][j]);
else
printf("%I64d", mpt[i][j]);
}
printf("\n");
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double Y1, Y2, w, x, y, r;
int main() {
scanf("%lf%lf%lf%lf%lf%lf", &Y1, &Y2, &w, &x, &y, &r);
w -= r;
double s = 0, e = x - 1e-10, ans = -1;
for (int i = 0; i < 50; ++i) {
double m = (s + e) / 2;
double dx = m - x, dy = w - y;
double p = -1.0 * dy / dx;
double DX = r / sqrt(1 + (-1.0 / p) * (-1.0 / p));
double DY = (-1.0 / p) * DX;
if (DX > 0.0) DX *= -1, DY *= -1;
double q1 = w - r - p * (m);
double q2 = w + DY - p * (m + DX);
if (q2 > Y2 + 1e-10)
s = m;
else if (q1 < Y1 - 1e-10)
e = m;
else {
ans = m;
break;
}
}
if (ans > 0.0)
printf("%.10lf", ans);
else
printf("-1");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[3][3], i, j, b[3][3] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++) cin >> a[i][j];
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
if (a[i][j] % 2 != 0) {
b[i][j] = (b[i][j] == 0) ? 1 : 0;
if ((i + 1) < 3) b[i + 1][j] = (b[i + 1][j] == 0) ? 1 : 0;
if ((i - 1) >= 0) b[i - 1][j] = (b[i - 1][j] == 0) ? 1 : 0;
if ((j + 1) < 3) b[i][j + 1] = (b[i][j + 1] == 0) ? 1 : 0;
if ((j - 1) >= 0) b[i][j - 1] = (b[i][j - 1] == 0) ? 1 : 0;
}
}
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) cout << b[i][j];
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < (1e-10) && fabs(y - p.y) < (1e-10);
}
};
struct Segment {
Point p1, p2;
};
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
class pa3 {
public:
long long x, y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
bool parareru(Point a, Point b, Point c, Point d) {
return abs(cross(a - b, d - c)) < (1e-10);
}
double distance_ls_p(Point a, Point b, Point c) {
if (dot(b - a, c - a) < (1e-10)) return (c - a).absv();
if (dot(a - b, c - b) < (1e-10)) return (c - b).absv();
return abs(cross(b - a, c - a)) / (b - a).absv();
}
bool is_intersected_ls(Segment a, Segment b) {
if (a.p1 == b.p1 || a.p2 == b.p1 || a.p1 == b.p2 || a.p2 == b.p2)
return false;
if (parareru((a.p2), (a.p1), (a.p1), (b.p2)) &&
parareru((a.p2), (a.p1), (a.p1), (b.p1))) {
if (dot(a.p1 - b.p1, a.p1 - b.p2) < (1e-10)) return true;
if (dot(a.p2 - b.p1, a.p2 - b.p2) < (1e-10)) return true;
if (dot(a.p1 - b.p1, a.p2 - b.p1) < (1e-10)) return true;
if (dot(a.p1 - b.p2, a.p2 - b.p2) < (1e-10)) return true;
return false;
} else
return (cross(a.p2 - a.p1, b.p1 - a.p1) * cross(a.p2 - a.p1, b.p2 - a.p1) <
(1e-10)) &&
(cross(b.p2 - b.p1, a.p1 - b.p1) * cross(b.p2 - b.p1, a.p2 - b.p1) <
(1e-10));
}
double segment_dis(Segment a, Segment b) {
if (is_intersected_ls(a, b)) return 0;
double r = distance_ls_p(a.p1, a.p2, b.p1);
r = min(r, distance_ls_p(a.p1, a.p2, b.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2 - b.p1;
double d1 = abs(cross(ba, a.p1 - b.p1));
double d2 = abs(cross(ba, a.p2 - b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2 - a.p1) * t;
}
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1ll;
if (rr == 1) return wa % warukazu;
if (rr % 2 == 1) return (beki(wa, rr - 1, warukazu) * wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
map<long long, long long> ma;
long long saiki(long long r) {
if (ma.find(r) != ma.end()) return ma[r];
long long maa = -1;
for (long long i = 0; i <= 55; i++)
if (r & (1ll << i)) maa = max(maa, i);
return ma[(1ll << maa) - 1] + saiki(r - (1ll << maa)) + (1ll << maa);
}
signed main() {
long long n;
cin >> n;
if (n <= 5)
cout << "-1" << endl;
else {
long long nn = n - 2;
long long a = nn / 2;
long long b = nn - a;
for (long long i = 2; i <= 2 + a; i++) cout << "1 " << i << endl;
for (long long i = 3 + a; i <= 2 + a + b; i++) cout << "2 " << i << endl;
}
for (long long i = 1; i <= n - 1; i++) cout << i << " " << i + 1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
struct node {
int x, y;
} a[2000];
int cmp(const void *a, const void *b) {
struct node *aa = (struct node *)a;
struct node *bb = (struct node *)b;
return aa->y - bb->y;
}
int main(void) {
int i, n, pre, ans, tem;
int b[2000];
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
if (a[i].x > a[i].y) {
tem = a[i].x;
a[i].x = a[i].y;
a[i].y = tem;
}
}
qsort(a + 1, n, sizeof(a[0]), cmp);
for (i = 1, pre = -10001, ans = 0; i <= n; i++) {
if (a[i].x > pre) pre = b[++ans] = a[i].y;
}
printf("%d\n", ans);
for (i = 1; i <= ans; i++) printf("%d%c", b[i], i == ans ? '\n' : ' ');
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
void testCase(int test_case)
{
int n, k;
cin >> n >> k;
vector<int> a(n), b(n + 9), c(n + 9);
for (int i = 0; i < n; i++)
cin >> a[i];
int l = 0, r = 1e7;
while (l + 1 < r)
{
int m = (l + r) / 2;
int rv = 0, mn = 1e18, best = -1e18;
c[0] = 0;
for (int i = 0; i < n; i++)
{
b[i] = (a[i] >= m ? 1 : -1);
rv += b[i];
c[i + 1] = rv;
if (i >= k - 1)
{
mn = min(mn, c[i - k + 1]);
best = max(best, rv - mn);
}
}
if (best > 0)
l = m;
else
r = m;
}
cout << l << '\n';
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int test_cases = 1;
// cin >> test_cases;
for (int test_case = 0; test_case < test_cases; test_case++)
testCase(test_case);
} | 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll tests = 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> tests;
while (tests--) {
ll n;
cin >> n;
string a, b;
cin >> a >> b;
map<char, vector<ll>> mp;
ll yflg = 0;
for (int i = 0; i < n; i++) {
mp[a[i]].push_back(i);
if (a[i] > b[i]) yflg = 1;
}
if (yflg == 1) {
cout << -1 << "\n";
continue;
}
ll ans = 0;
for (auto i : mp) {
char mn = 'z';
ll flg = 0;
for (auto j : i.second) {
if (a[j] != b[j]) {
mn = min(mn, b[j]);
}
}
for (auto j : i.second) {
if (b[j] != a[j]) {
flg = 1;
a[j] = mn;
mp[mn].push_back(j);
}
}
mp[i.first].clear();
if (flg == 1) ans++;
}
cout << ans << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int k, A[1005], choose[1005][1005];
int solve(int pos, int cnt) {
if (pos == 1) return 1;
return ((long long)solve(pos - 1, cnt - A[pos]) *
choose[cnt - 1][A[pos] - 1]) %
mod;
}
int main() {
scanf("%d", &k);
int s = 0;
for (int i = 1; i <= k; i++) {
scanf("%d", &A[i]);
s += A[i];
}
for (int i = 0; i <= 1001; i++) {
choose[i][0] = 1;
}
for (int i = 1; i <= 1001; i++) {
for (int j = 1; j <= 1001; j++) {
choose[i][j] = (choose[i - 1][j] + choose[i - 1][j - 1]) % mod;
}
}
printf("%d\n", solve(k, s));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct item {
int key, prior;
int max, keymax;
int cnt;
int open;
item *l, *r;
item() {}
item(int key, int prior, int open)
: key(key),
prior(prior),
l(NULL),
r(NULL),
max(open),
keymax(key),
open(open),
cnt(1) {}
};
typedef item* pitem;
int cnt(pitem t) { return t ? t->cnt : 0; }
void print(pitem t) {
if (!t) return;
print(t->l);
cout << ' ' << t->key << '-' << t->cnt << ' ' << t->max << '-' << t->keymax
<< ' ';
print(t->r);
}
void push(pitem it) {}
void upd_cnt(pitem t) {
if (t) {
t->cnt = 1 + cnt(t->l) + cnt(t->r);
} else {
return;
}
t->max = t->open;
t->keymax = t->key;
if (t->l and (t->l->max > t->max or
(t->l->max == t->max and t->l->keymax < t->keymax))) {
t->max = t->l->max;
t->keymax = t->l->keymax;
}
if (t->r and (t->r->max > t->max or
(t->r->max == t->max and t->r->keymax < t->keymax))) {
t->max = t->r->max;
t->keymax = t->r->keymax;
}
}
void merge(pitem& t, pitem l, pitem r) {
if (!l || !r) {
t = l ? l : r;
upd_cnt(l);
upd_cnt(r);
} else {
if (l->prior > r->prior)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
}
upd_cnt(t);
}
void split(pitem t, pitem& l, pitem& r, int key, int add = 0) {
if (!t) return void(l = r = 0);
int cur_key = add + cnt(t->l);
if (key <= t->key)
split(t->l, l, t->l, key, add), r = t;
else
split(t->r, t->r, r, key, add + 1 + cnt(t->l)), l = t;
upd_cnt(t);
}
int main() {
int n;
cin >> n;
vector<int> c(n);
int x;
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
c[i] = x - 1;
}
vector<int> ans(n);
vector<int> rr(n);
for (int i = 0; i < n; ++i) {
rr[i] = rand();
}
for (int l = 0; l < n; ++l) {
for (int j = 0; j < n; ++j) {
rr[j] = 0;
}
int curmax = -1;
int curkey = 0;
for (int r = l; r < n; ++r) {
rr[c[r]]++;
if ((rr[c[r]] > curmax) or (rr[c[r]] == curmax and c[r] < curkey)) {
curkey = c[r];
curmax = rr[c[r]];
}
ans[curkey]++;
}
}
for (int i = 0; i < n; ++i) {
printf("%d ", ans[i]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s[101010];
string revs[101010];
int a[101010];
long long dp[101010][2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> s[i];
revs[i] = s[i];
std::reverse(revs[i].begin(), revs[i].end());
}
dp[0][0] = 0;
dp[0][1] = a[0];
for (int i = 1; i < n; ++i) {
dp[i][0] = dp[i][1] = 1000111000111000111LL;
if (s[i] >= s[i - 1]) {
dp[i][0] = min(dp[i][0], dp[i - 1][0]);
}
if (s[i] >= revs[i - 1]) {
dp[i][0] = min(dp[i][0], dp[i - 1][1]);
}
if (revs[i] >= s[i - 1]) {
dp[i][1] = min(dp[i][1], dp[i - 1][0] + a[i]);
}
if (revs[i] >= revs[i - 1]) {
dp[i][1] = min(dp[i][1], dp[i - 1][1] + a[i]);
}
}
long long ans = min(dp[n - 1][0], dp[n - 1][1]);
if (ans == 1000111000111000111LL) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int dist[1005][1005][45];
int arr[1005][1005];
bool vis[1005][1005];
bool visc[45];
vector<pair<int, int>> color[45];
vector<pair<int, int>> dx = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
bool is_inside(int x, int y) { return x > 0 && x <= n && y > 0 && y <= m; }
void solve() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> arr[i][j];
color[arr[i][j]].push_back({i, j});
}
}
for (int i = 1; i <= k; i++) {
memset(vis, 0, sizeof(vis));
memset(visc, 0, sizeof(visc));
queue<pair<pair<int, int>, int>> q;
for (auto u : color[i]) {
q.push({u, 0});
vis[u.first][u.second] = 1;
}
visc[i] = 1;
while (!q.empty()) {
auto tp = q.front();
q.pop();
int x = tp.first.first;
int y = tp.first.second;
int cost = tp.second;
dist[x][y][i] = cost;
if (!visc[arr[x][y]]) {
visc[arr[x][y]] = 1;
for (auto u : color[arr[x][y]]) {
if (!vis[u.first][u.second]) {
vis[u.first][u.second] = 1;
q.push({u, cost + 1});
}
}
}
for (auto u : dx) {
if (is_inside(x + u.first, y + u.second) &&
!vis[x + u.first][y + u.second]) {
vis[x + u.first][y + u.second] = 1;
q.push({{x + u.first, y + u.second}, cost + 1});
}
}
}
}
int q;
cin >> q;
while (q--) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int ans = (abs(x1 - x2) + abs(y1 - y2));
for (int i = 1; i <= k; i++) {
ans = min(ans, dist[x1][y1][i] + dist[x2][y2][i] + 1);
}
cout << ans << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
inline long long input() {
long long n;
cin >> n;
return n;
}
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
const int MAXN = 5e5 + 10;
const int MAXK = 110;
const int MAXLG = 18;
const int MOD = 1e9 + 7;
const int MOD2 = 998244353;
const int INF = 1e9;
int n, k, p;
int a[MAXN];
int ps[MAXN];
int dp[MAXK][MAXN];
int fen[MAXK];
int fen2[MAXK];
void add_val(int ind, int val) {
for (ind += 2; ind < MAXK; ind += (ind & -ind)) {
fen[ind] = min(fen[ind], val);
}
}
void add_val2(int ind, int val) {
for (ind += 2; ind < MAXK; ind += (ind & -ind)) {
fen2[ind] = min(fen2[ind], val);
}
}
int ret_ans(int ind) {
int res = INF;
for (ind += 2; ind; ind -= (ind & -ind)) {
res = min(res, fen[ind]);
}
return res;
}
int ret_ans2(int ind) {
int res = INF;
for (ind += 2; ind; ind -= (ind & -ind)) {
res = min(res, fen2[ind]);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) {
cin >> a[i];
ps[i] = (ps[i - 1] + a[i]) % p;
dp[1][i] = ps[i];
}
for (int i = 2; i <= k; i++) {
fill(fen, fen + MAXK, INF);
fill(fen2, fen2 + MAXK, INF);
for (int j = 1; j <= n; j++) {
dp[i][j] = min(ret_ans2(p - 1 - ps[j]), ret_ans(ps[j])) + ps[j];
add_val(ps[j], dp[i - 1][j] - ps[j]);
add_val2(p - ps[j] - 1, dp[i - 1][j] + p - ps[j]);
}
}
cout << dp[k][n] << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, a, b;
long long sum = 0;
vector<int> v;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
v.push_back(t);
sum += t;
}
double d = (a * v[0]);
if (d / sum >= b) {
cout << "0" << endl;
return 0;
}
sort(v.begin() + 1, v.end(), greater<int>());
for (int i = 1; i < n; i++) {
sum -= v[i];
if ((d / sum) >= b) {
cout << i << endl;
break;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, j;
cin >> n;
for (int i = 1; i <= n; i += 2) {
j = (n - i) / 2;
for (int k = 0; k < j; k++) printf("*");
for (int k = 0; k < i; k++) printf("D");
for (int k = 0; k < j; k++) printf("*");
puts("");
}
for (int i = n - 2; i >= 1; i -= 2) {
j = (n - i) / 2;
for (int k = 0; k < j; k++) printf("*");
for (int k = 0; k < i; k++) printf("D");
for (int k = 0; k < j; k++) printf("*");
puts("");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5;
long long a[N + 10];
int n;
priority_queue<pair<long long, long long> > s;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long p = a[0];
for (int i = 0; i < n; i++) a[i] -= p;
for (int i = 0; i < n - 1; i++) {
if (a[i] + 1 != a[i + 1] && a[i] != a[i + 1]) {
cout << "NO";
return 0;
}
}
int cur = 1;
for (int i = 0; i < n; i++) {
if (i == n - 1) {
if (a[i] == a[0] || a[i] == a[n - 1])
s.push(pair<long long, long long>(a[i], cur - 1));
else
s.push(pair<long long, long long>(a[i], cur - 2));
} else if (a[i] != a[i + 1]) {
if (a[i] == a[0] || a[i] == a[n - 1])
s.push(pair<long long, long long>(a[i], cur - 1));
else
s.push(pair<long long, long long>(a[i], cur - 2));
cur = 1;
} else
cur++;
}
while (!s.empty()) {
if (s.top().second == 0) {
s.pop();
continue;
}
if (s.top().second < 0) {
cout << "NO";
return 0;
}
if (s.size() == 1) {
if (s.top().second > 0) {
cout << "NO";
return 0;
} else
break;
}
int x = s.top().second;
s.pop();
if (x > s.top().second) {
cout << "NO";
return 0;
} else {
int c = s.top().first;
int d = s.top().second;
d -= x;
s.pop();
s.push(pair<long long, long long>(c, d));
}
}
cout << "YES";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d, ans = 0;
scanf("%d%d", &n, &d);
int maxi, t, l;
scanf("%d", &maxi);
for (int i = 1; i < n; i++) {
scanf("%d", &t);
if (t > maxi) {
maxi = t;
continue;
} else {
l = (int)ceil((maxi + 1 - t) / (double)d);
ans += l;
maxi = t + d * l;
}
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 43;
long long pw[mxn + 1];
void prepare() {
pw[0] = 1;
for (long long i = 1; i <= mxn; ++i) {
pw[i] = pw[i - 1] * 2;
}
}
inline bool getbit(long long a, long long pos) { return a & pw[pos]; }
void solve() {
prepare();
long long s, x;
cin >> s >> x;
vector<vector<long long> > dp(mxn + 1, vector<long long>(2));
for (long long p1 = 0; p1 <= 1; ++p1) {
for (long long p2 = 0; p2 <= 1; ++p2) {
long long sm = p1 + p2;
long long xr = p1 ^ p2;
if (sm % 2 != getbit(s, 0) || xr != getbit(x, 0)) continue;
dp[1][sm / 2] += 1;
}
}
for (long long i = 2; i <= mxn; ++i) {
long long vals = getbit(s, i - 1);
long long valx = getbit(x, i - 1);
for (long long j = 0; j <= 1; ++j) {
for (long long pr = 0; pr <= 1; ++pr) {
for (long long p1 = 0; p1 <= 1; ++p1) {
for (long long p2 = 0; p2 <= 1; ++p2) {
long long sm = pr + p1 + p2;
long long xr = p1 ^ p2;
if ((sm % 2 != vals) || (xr != valx) || (sm / 2 != j)) continue;
dp[i][j] += dp[i - 1][pr];
}
}
}
}
}
if (s == x) dp[mxn][0] -= 2;
cout << dp[mxn][0] << "\n";
}
signed main() {
srand(time(0));
cout << fixed;
cout << setprecision(5);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
for (long long i = 0; i < t; ++i) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int lab[4100000], Min[4100000], a[1100][1100], b[1100][1100], g[1100], n, vx,
vy, top, m;
long long ans = 0;
double q[4100000];
int bin(double x) {
int l = 1, r = m;
while (l < r) {
int mid = (l + r) / 2 + 1;
if (x < q[mid] - 1e-9)
r = mid - 1;
else
l = mid;
}
return l;
}
void down(int u, int l, int r) {
if (lab[u] > Min[u]) Min[u] = lab[u];
if (l != r) {
lab[u * 2] = max(lab[u * 2], lab[u]);
lab[u * 2 + 1] = max(lab[u * 2 + 1], lab[u]);
}
lab[u] = 0;
}
void updata(int u, int l, int r) { Min[u] = min(Min[u * 2], Min[u * 2 + 1]); }
void build(int u, int l, int r) {
Min[u] = lab[u] = 0;
if (l == r) return;
int mid = (l + r) / 2;
build(u * 2, l, mid);
build(u * 2 + 1, mid + 1, r);
}
void add(int u, int l, int r, int x, int y, int z) {
down(u, l, r);
if (x > r || y < l) return;
if (x <= l && y >= r) {
lab[u] = z;
down(u, l, r);
return;
}
int mid = (l + r) / 2;
add(u * 2, l, mid, x, y, z);
add(u * 2 + 1, mid + 1, r, x, y, z);
updata(u, l, r);
}
int query(int u, int l, int r, int x, int y) {
down(u, l, r);
if (x > r || y < l) return 1000000000;
if (x <= l && y >= r) return Min[u];
int mid = (l + r) / 2;
return min(query(u * 2, l, mid, x, y), query(u * 2 + 1, mid + 1, r, x, y));
}
int main() {
cin >> n >> vx >> vy;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &a[i][j]);
if (vx == 0) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) g[i] = max(g[i], a[i][j]);
for (int i = 1; i <= n; i++) ans += g[i];
cout << ans << endl;
return 0;
}
if (vy == 0) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) g[j] = max(g[j], a[i][j]);
for (int i = 1; i <= n; i++) ans += g[i];
cout << ans << endl;
return 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
int tx = i, ty = j;
if (vx < 0) tx = n - tx + 1;
if (vy < 0) ty = n - ty + 1;
b[i][j] = a[tx][ty];
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = b[i][j];
if (vx < 0) vx = -vx;
if (vy < 0) vy = -vy;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
int x = i - 1, y = j;
q[++top] = x - (double)y / vy * vx;
x = i, y = j - 1;
q[++top] = x - (double)y / vy * vx;
}
sort(q + 1, q + top + 1);
m = 1;
for (int i = 2; i <= top; i++)
if (fabs(q[i] - q[m]) > 1e-9) q[++m] = q[i];
build(1, 1, m - 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
int l = bin(i - 1 - (double)j / vy * vx),
r = bin(i - (double)(j - 1) / vy * vx);
r--;
int t = query(1, 1, m - 1, l, r);
if (t < a[i][j]) ans += a[i][j] - t;
add(1, 1, m - 1, l, r, a[i][j]);
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 50;
int main() {
string a;
cin >> a;
for (int i = a.length(); i >= 2; i--) {
for (int j = 0; j <= a.length() - i; j++) {
string tmp = a.substr(j, i);
string ort = tmp;
reverse(tmp.begin(), tmp.end());
if (tmp != ort) return cout << i, 0;
}
}
puts("0");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve(vector<long long int> &a, int i, int j, long long int d,
long long int &ans) {
while (a[j] - a[i] <= d and j < a.size()) j++;
long long int g = j - i - 1;
if (g) ans += g * (g - 1) / 2;
if (i + 1 < a.size()) solve(a, i + 1, j, d, ans);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, d, seg = 0;
cin >> n >> d;
vector<long long int> a(n);
for (auto &i : a) cin >> i;
solve(a, 0, 0, d, seg);
cout << seg;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long C[64][64], m, k = 1;
long long f1(long long x) {
long long ret = 0, cnt = 0;
for (long long i = 63; i >= 0 && (k - cnt) >= 0; i--) {
if ((x >> i) & 1) {
ret += C[i][k - cnt];
cnt++;
}
}
cnt = 0;
for (long long i = 63; i >= 0 && (k - cnt) >= 0; i--) {
if ((x >> i) & 1) {
cnt++;
}
}
if (cnt == k) ret++;
return ret;
}
long long f(long long x) {
long long ret = f1(2 * x) - f1(x);
return ret;
}
int main() {
int i, j;
for (i = 0; i < 64; i++) C[i][0] = 1;
for (i = 1; i < 64; i++) {
for (j = 1; j <= i; j++) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
cin >> m >> k;
long long lo = 0, hi = (long long)1e18;
while (hi - lo > 1) {
long long mid = (hi + lo) / 2;
if (f(mid) <= m)
lo = mid;
else
hi = mid;
}
cout << lo << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int f[1 + 100];
int main() {
FILE *fi, *fo;
fi = stdin;
fo = stdout;
int n, r, x;
fscanf(fi, "%d", &n);
for (int i = 1; i <= n; i++) {
fscanf(fi, "%d", &r);
for (int j = 1; j <= r; j++) {
fscanf(fi, "%d", &x);
f[x]++;
}
}
for (int i = 1; i <= 100; i++)
if (f[i] == n) fprintf(fo, "%d ", i);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 51;
struct Segment {
int x, y, id;
inline bool operator<(const Segment &rhs) const { return x < rhs.x; }
inline bool operator>(const Segment &rhs) const { return y > rhs.y; }
};
struct BIT {
long long int x[MAXN];
inline void add(int pos, int val);
inline long long int query(int pos);
};
Segment seg[MAXN];
BIT bit;
int n, x, y;
long long int res, res2;
int l[MAXN], r[MAXN];
inline int read() {
register int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
inline void BIT::add(int pos, int val) {
for (; pos <= 2 * n; pos += pos & -pos) {
x[pos] += val;
}
}
inline long long int BIT::query(int pos) {
long long int res = 0;
for (; pos; pos -= pos & -pos) {
res += x[pos];
}
return res;
}
int main() {
n = read();
for (register int i = 1; i <= n; i++) {
x = read(), y = read(), x > y ? swap(x, y) : (void)1,
seg[i] = (Segment){x, y, i};
}
sort(seg + 1, seg + n + 1);
for (register int i = 1; i <= n; i++) {
l[seg[i].id] =
bit.query(seg[i].x - 1) + bit.query(2 * n) - bit.query(seg[i].y);
bit.add(seg[i].y, 1);
}
memset(bit.x, 0, sizeof(bit.x)),
res = (long long int)n * (n - 1) * (n - 2) / 6;
for (register int i = n; i; i--) {
r[seg[i].id] = bit.query(seg[i].y - 1), bit.add(seg[i].y, 1);
}
memset(bit.x, 0, sizeof(bit.x)),
sort(seg + 1, seg + n + 1, greater<Segment>());
for (register int i = 1; i <= n; i++) {
l[seg[i].id] += bit.query(2 * n) - bit.query(seg[i].y),
bit.add(seg[i].x, 1);
}
for (register int i = 1; i <= n; i++) {
res -= (long long int)l[i] * r[i],
res2 += (long long int)(l[i] + r[i]) * (n - l[i] - r[i] - 1);
}
printf("%lld\n", res - res2 / 2);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
int n, w, mx = -2e9, mn = 2e9, a[N];
int main() {
scanf("%d%d", &n, &w);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] += a[i - 1];
if (a[i] > mx) mx = a[i];
if (a[i] < mn) mn = a[i];
}
if (mn < 0) w += mn;
if (mx > 0) w -= mx;
printf("%d", max(w + 1, 0));
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int n, u, sz[N], a[N], b[N], cur = 0, cnt = 0;
vector<int> gr[N];
void dfs(int u) {
if (gr[u].size() == 0) sz[u]++;
for (int p : gr[u]) {
dfs(p);
sz[u] += sz[p];
}
}
bool option(int x, int y) { return sz[x] < sz[y]; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) a[i] = i;
for (int i = 2; i <= n; i++) {
cin >> u;
gr[u].push_back(i);
}
dfs(1);
sort(a + 1, a + n + 1, option);
for (int i = 1; i <= n; i++) b[i] = sz[a[i]];
for (int i = 1; i <= n; i++) {
while (cnt < i) {
cur++;
while (cnt < n && b[cnt] <= cur) cnt++;
if (b[cnt] > cur) cnt--;
}
cout << cur << " \n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long int>> multiply(vector<vector<long long int>> a,
vector<vector<long long int>> b) {
vector<vector<long long int>> v(4, vector<long long int>(4, 0));
for (long long int i = 0; i < 4; i++) {
for (long long int j = 0; j < 4; j++) {
for (long long int k = 0; k < 4; k++)
v[i][j] = (v[i][j] + a[i][k] * b[k][j]) % 1000000007;
}
}
return v;
}
vector<vector<long long int>> power(vector<vector<long long int>> v,
long long int k) {
if (k == 1) return v;
vector<vector<long long int>> res = power(v, k / 2);
if (1 & k)
res = multiply(multiply(res, res), v);
else
res = multiply(res, res);
return res;
}
long long int solve(vector<vector<long long int>> a, long long int k) {
vector<vector<long long int>> b(4, vector<long long int>(4));
b = power(a, k);
return b[0][0];
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
vector<vector<long long int>> a(4, vector<long long int>(4));
for (long long int i = 0; i < 4; i++) {
for (long long int j = 0; j < 4; j++) {
if (i == j)
a[i][j] = 0;
else
a[i][j] = 1;
}
}
cout << solve(a, n);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)(INT_MAX - 100);
const int N = (int)(0);
const long long mod = (int)(1e+9 + 7);
inline bool p(int n) {
if (n < 2) return 0;
for (int d = 2; d * d <= n; d++)
if (n % d == 0) return 0;
return 1;
}
int main() {
int n, p3;
cin >> n;
p3 = n;
while (1) {
while (!p(p3)) p3--;
if (p3 == n) return cout << "1\n" << p3, 0;
for (int p1 = (2); p1 <= (n - p3); p1++) {
if (!p(p1)) continue;
if (p3 + p1 == n) return cout << "2\n" << p1 << " " << p3, 0;
for (int p2 = (p1); p2 <= (n - (p3 + p1)); p2++) {
if (!p(p2)) continue;
if (p3 + p1 + p2 == n)
return cout << "3\n" << p1 << " " << p2 << " " << p3, 0;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 12;
int test, n, a[N], pw3[N];
int getbit(int m, int i) { return m / pw3[i] % 3; }
int main() {
cin >> test;
pw3[0] = 1;
for (int i = 1; i <= 10; ++i) pw3[i] = pw3[i - 1] * 3;
while (test--) {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
if (n == 1) {
if (a[0] == 0)
cout << "YES\n";
else
cout << "NO\n";
continue;
}
bool flag = false;
for (int i = 0; i < n; ++i) {
vector<int> v;
for (int j = 0; j < n; ++j)
if (j != i) v.push_back(a[j]);
for (int m = 0; m < pw3[n - 1]; ++m) {
int sum = 0;
for (int j = 0; j < n - 1; ++j)
if (getbit(m, j) == 1)
sum += v[j];
else if (getbit(m, j) == 2)
sum -= v[j];
if (sum == a[i]) {
flag = true;
break;
}
}
if (flag) {
break;
}
}
if (flag) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int r = 0, f = 1;
char ch = getchar();
while (ch < 48) {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch > 47) r = r * 10 + (ch ^ 48), ch = getchar();
return r * f;
}
inline int max(const int &a, const int &b) { return a > b ? a : b; }
inline int min(const int &a, const int &b) { return a > b ? b : a; }
const int maxn = 400086;
int a, b, c, d;
int arr[maxn], num;
int tim[5], pt;
void fuck() {
puts("NO");
exit(0);
}
void work() {
memset(arr, -1, sizeof(arr));
tim[0] = read(), tim[1] = read();
tim[2] = read(), tim[3] = read();
pt = tim[0] + tim[1] + tim[2] + tim[3];
int sum = tim[0] + tim[1] + tim[2] + tim[3];
if (tim[0] > tim[1] + 1) fuck();
if (tim[0] == tim[1] + 1) {
if (tim[2] || tim[3])
fuck();
else {
printf("YES\n");
for (int i = 1; i <= tim[1]; ++i) printf("%d %d ", 0, 1);
printf("0\n");
return;
}
}
for (int i = 1; i <= tim[0]; ++i) arr[++num] = 0, arr[++num] = 1, tim[1]--;
if (tim[3] > tim[2] + 1) fuck();
if (tim[3] == tim[2] + 1) {
if (tim[0] || tim[1]) fuck();
printf("YES\n");
for (int i = 1; i <= tim[2]; ++i) printf("3 2 ");
printf("3");
return;
}
for (int i = 1; i <= tim[3]; ++i) arr[pt--] = 3, arr[pt--] = 2, tim[2]--;
if (abs(tim[1] - tim[2]) <= 1) {
printf("YES\n");
if (tim[1] > tim[2]) printf("1 ");
for (int i = 1; i <= num; ++i) printf("%d ", arr[i]);
for (int i = 1; i <= min(tim[1], tim[2]); ++i) printf("2 1 ");
for (int i = pt + 1; i <= sum; ++i) printf("%d ", arr[i]);
if (tim[1] < tim[2]) printf("2 ");
return;
}
fuck();
}
signed main() { work(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m, a, b, i, j, p = 0;
cin >> n >> m;
vector<long long int> vec, vec1;
for (i = 0; i < n; i++) {
cin >> a;
vec.push_back(a);
}
for (i = 0; i < m; i++) {
cin >> b;
vec1.push_back(b);
}
sort(vec.begin(), vec.end());
sort(vec1.begin(), vec1.end());
for (i = 0; i < vec.size(); i++) {
for (j = 0; j < vec1.size(); j++) {
if (vec1[j] >= vec[i]) {
p++;
vec1[j] = 0;
break;
}
}
}
cout << abs(p - n);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF1 = (long long)2e18 + 9;
const long long INF = (long long)2e9;
const long long SIZE = (long long)3e5 + 5;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tt;
cin >> tt;
while (tt--) {
long long n;
cin >> n;
long long ar[n], cnt = n, flag = 0;
for (long long i = 0; i < n; i += 1) {
cin >> ar[i];
if (ar[i] % 2 == i % 2) {
flag = 1;
}
}
if (flag == 1) {
cout << -1 << "\n";
continue;
}
vector<long long> ans;
for (long long i = 0; i < cnt / 2; i++) {
long long ind;
for (long long j = 0; j < n; j++) {
if (ar[j] == n) {
ind = j + 1;
}
}
ans.push_back(ind);
reverse(ar, ar + ind);
for (long long j = 0; j < n; j++) {
if (ar[j] == n - 1) {
ind = j + 1;
}
}
ans.push_back(ind - 1);
reverse(ar, ar + ind - 1);
ans.push_back(ind + 1);
reverse(ar, ar + ind + 1);
ans.push_back(3);
reverse(ar, ar + 3);
ans.push_back(n);
reverse(ar, ar + n);
n -= 2;
}
for (long long i = 0; i < cnt; i += 1) {
}
cout << ans.size() << "\n";
for (auto x : ans) {
cout << x << " ";
}
cout << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T;
cin >> T;
while (T--) {
string s, t;
cin >> s >> t;
s = "$" + s;
int l = s.length();
vector<vector<int>> nex(l, vector<int>(26, -1));
for (int i = s.length() - 1; i > 0; --i) {
nex[i - 1] = nex[i];
nex[i - 1][s[i] - 'a'] = i;
}
nex.back() = nex[0];
for (int i = s.length() - 1; i > 0; --i) {
for (int j = 0; j < 26; ++j) {
if (nex[i - 1][j] < 0) nex[i - 1][j] = nex[i][j];
}
}
int ans = 1;
int idx = 0;
for (auto c : t) {
int idx_ = nex[idx][c - 'a'];
if (idx_ < 0) {
ans = -1;
break;
}
if (idx_ <= idx) ++ans;
idx = idx_;
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, q;
string input[36], output[36];
map<string, bool> M;
long long int res(string cur) {
if (cur.length() == n) {
if (!M[cur]) {
M[cur] = true;
return 1;
}
return 0;
}
long long int curResult = 0;
for (long long int T = 0; T < q; T += 1) {
if (output[T][0] == cur[0]) {
string cpy = cur;
cpy.erase(0, 1);
cpy.insert(0, input[T]);
curResult += res(cpy);
}
}
return (curResult);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> q;
for (long long int I = 0; I < q; I += 1) cin >> input[I] >> output[I];
long long int result = 0;
for (long long int I = 0; I < q; I += 1) {
if (output[I] == "a") {
result += res(input[I]);
}
}
cout << result;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 11;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-7;
const int BUFL = 1e6 + 11;
char Obuf[BUFL], Ibuf[BUFL];
char *optr = Obuf, *ist = 0, *ied = 0;
streambuf *sb, *ssb;
inline void print(char c) {
optr == Obuf + BUFL ? (sb->sputn(Obuf, BUFL), optr = Obuf),
*optr++ = c : *optr++ = c;
}
inline void flush() { sb->sputn(Obuf, optr - Obuf); }
inline char pick() {
return ist == ied ? ied = Ibuf + ssb->sgetn(ist = Ibuf, BUFL),
(ist == ied ? -1 : *ist++) : *ist++;
}
template <class T>
inline void print(T x) {
if (x == 0) {
print(char(48));
return;
}
if (x < 0) {
print(char('-'));
x = -x;
}
static char buf[233];
register int cnt;
for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 | 48;
while (cnt) print(buf[cnt--]);
}
template <class T>
inline int read(T &t) {
long long x;
register char c, f;
f = 1;
while (!((c = pick()) >= '0' && c <= '9') && (c ^ -1) && (c ^ 45))
;
if (c == -1) return EOF;
if (c == 45) c = pick(), f = 0;
for (x = c - 48; (c = pick()) >= '0' && c <= '9';
(x = ((x << 3) + (x << 1))) += c - 48)
;
t = f ? x : -x;
return 1;
}
int to[MAXN << 1], nxt[MAXN << 1], head[MAXN], tot;
long long cost[MAXN << 1];
void init(int n) {
memset(head, -1, sizeof(head));
tot = 0;
}
void add(int u, int v, long long w = 0) {
to[tot] = v;
cost[tot] = w;
nxt[tot] = head[u];
head[u] = tot++;
}
int n, k;
int size[MAXN], msize[MAXN][5];
inline int sub(int a, int b, int mod) {
return ((a % mod - b % mod) % mod + mod) % mod;
}
long long dfs(int u, int fa, int d) {
for (int i = 0; i <= 4; i++) msize[u][i] = 0;
size[u] = 1;
msize[u][d % k] = 1;
long long ans = 0;
for (int i = head[u]; ~i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
ans += dfs(v, u, d + 1);
ans += (long long)size[v] * (n - size[v]);
for (int i = 0; i <= k - 1; i++) {
for (int j = 0; j <= k - 1; j++) {
int r = sub(i + j, d << 1, k);
int t = sub(k, r, k);
ans += (long long)t * msize[u][i] * msize[v][j];
}
}
for (int i = 0; i <= k - 1; i++) msize[u][i] += msize[v][i];
size[u] += size[v];
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ssb = cin.rdbuf();
sb = cout.rdbuf();
;
while (~read(n)) {
read(k);
init(n);
for (int i = 1; i <= n - 1; i++) {
int u, v;
read(u);
read(v);
add(u, v);
add(v, u);
}
print(dfs(1, -1, 0) / k), print('\n');
;
}
flush();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 998244353;
double eps = 1e-12;
struct interval {
long long sp, b;
};
bool compareInterval(interval i1, interval i2) {
if (i1.sp == i2.sp) return (i1.b < i2.b);
return (i1.sp < i2.sp);
}
void solve() {
long long i, j, n;
cin >> n;
string s, mv = "";
cin >> s;
int a[100] = {0};
int ms = INT_MAX;
a[s[0]]++;
if (s[0] == '1' || s[0] == '4' || s[0] == '6' || s[0] == '8' || s[0] == '9') {
cout << 1 << endl;
cout << s[0] << endl;
return;
}
for (int i = 1; i < n; i++) {
if (s[i] == '1' || s[i] == '4' || s[i] == '6' || s[i] == '8' ||
s[i] == '9') {
cout << 1 << endl;
cout << s[i] << endl;
return;
} else if (ms > 2) {
if (s[i] == '2' || s[i] == '5') {
ms = 2;
mv = "";
mv = mv + s[i - 1] + s[i];
} else if (a[s[i]] > 0) {
ms = 2;
mv = "";
mv = mv + s[i] + s[i];
} else if (s[i] == '7') {
if (s[0] == '2') {
ms = 2;
mv = "27";
}
if (s[0] == '5') {
ms = 2;
mv = "57";
}
}
}
a[s[i]] += 1;
}
cout << ms << endl << mv << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 12;
int a[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int k, cnt = 0;
cin >> k;
if (k == 0) {
cout << 0 << '\n';
return 0;
}
for (int i = 0; i < N; i++) cin >> a[i];
sort(a, a + N);
for (int i = N - 1; i >= 0; i--) {
cnt += a[i];
if (cnt >= k) {
cout << N - i << '\n';
return 0;
}
}
cout << -1 << '\n';
return 0;
}
| 0 |
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn = 1005;
const int maxm = 3e5 + 10;
int a[maxn][maxn], val[maxn];
struct node{
int x, y, v;
node(int x = 0, int y = 0, int v = 0): x(x), y(y), v(v){}
}e[maxm];
bool cmp(node a, node b)
{
if(a.v == b.v)
return a.x < b.x;
return a.v < b.v;
}
vector<int> G[maxm];
int f[maxm];
int Find(int x)
{
if(f[x] == x)
return x;
return f[x] = Find(f[x]);
}
int main()
{
int cnt = 0;
int n;
scanf("%d", &n);
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
scanf("%d", &a[i][j]);
if(i == j)
val[i] = a[i][j];
if(i < j)
e[++cnt] = node(i, j, a[i][j]);
}
}
int now = n;
sort(e + 1, e + 1 + cnt, cmp);
for(int i = 0; i < maxm; i++)
f[i] = i;
int pre = 0;
for(int i = 1; i <= cnt; i++)
{
int u = e[i].x;
int v = e[i].y;
int num = e[i].v;
u = Find(u);
v = Find(v);
if(u == v)
continue;
if(u == pre && num == e[i - 1].v)
{
f[v] = now;
G[now].push_back(v);
}
else
{
++now;
pre = now;
f[u] = now;
f[v] = now;
G[now].push_back(u);
G[now].push_back(v);
val[now] = num;
}
}
printf("%d\n", now);
for(int i = 1; i <= now; ++i)
{
printf("%d ", val[i]);
}
printf("\n%d\n", Find(1));
for(int i = 1; i <= now; i++)
{
for(int j = 0; j < G[i].size(); j++)
{
printf("%d %d\n", G[i][j], i);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x;
int count1 = 0;
int count2 = 1;
vector<int> v;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) {
count1++;
}
}
cout << count1 << endl;
if (count1 == n) {
for (int i = 0; i < n; i++) {
cout << "1"
<< " ";
}
} else {
for (int i = 0; i < n; i++) {
if (a[i + 1] == 1 || i == n - 1) {
cout << count2 << " ";
count2 = 1;
} else {
count2++;
}
}
}
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
const long long N = 200100;
long long n;
long long a[N];
vector<pair<long long, long long> > factorize(long long X) {
vector<pair<long long, long long> > ans;
for (long long i = 2; i <= min((long long)1e6, X); i++) {
if (X % i == 0) {
long long k = 0;
while (X % i == 0) {
k++;
X /= i;
}
ans.push_back(pair<long long, long long>(i, k));
}
}
if (X > 1) {
long long sq = sqrtl(X);
for (long long i = sq - 1; i <= sq + 1; i++) {
if (i * i == X) {
ans.push_back(pair<long long, long long>(i, 2));
X = 1;
break;
}
}
for (long long i = 1; i <= n; i++) {
long long g = gcd(a[i], X);
if (g != 1 and g != X) {
ans.push_back(pair<long long, long long>(g, 1));
ans.push_back(pair<long long, long long>(X / g, 1));
X = 1;
break;
}
}
if (X > 1) ans.push_back(pair<long long, long long>(X, 1));
}
return ans;
}
const long long MX = (1 << 16);
long long mask[(1 << 16) + 100];
void SOS_dp() {
for (long long i = 0; i < 16; i++) {
for (long long msk = 0; msk < MX; msk++) {
if (msk & (1 << i)) mask[msk] += mask[msk ^ (1 << i)];
}
}
}
void redo(vector<pair<long long, long long> >& x,
vector<pair<long long, long long> >& y) {
vector<pair<long long, long long> > x1, abacaba;
for (long long i = 0; i < (long long)x.size(); i++) {
if (x[i].second < y[i].second) {
x1.push_back(x[i]);
abacaba.push_back(y[i]);
}
}
x = x1, y = abacaba;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long X, Y;
cin >> n >> X >> Y;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
;
}
if (Y % X != 0) {
cout << 0 << "\n";
return 0;
}
vector<pair<long long, long long> > x = factorize(X), y = factorize(Y);
sort(x.begin(), x.end());
sort(y.begin(), y.end());
for (auto it : y) {
long long has = 0;
for (auto it2 : x) {
if (it2.first == it.first) has = 1;
}
if (!has) x.push_back(pair<long long, long long>(it.first, 0));
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
assert((long long)x.size() == (long long)y.size());
redo(x, y);
for (long long i = 1; i <= n; i++) {
long long mini = 0;
long long val = a[i];
if (a[i] % X) continue;
long long id = 0;
for (auto it : x) {
long long k = 0;
while (val % it.first == 0) {
k++;
val /= it.first;
}
if (k > it.second) mini |= (1 << id);
id++;
}
mask[mini]++;
}
SOS_dp();
long long ans = 0;
for (long long i = 1; i <= n; i++) {
long long maxi = 0;
long long val = a[i];
if (Y % a[i]) continue;
long long id = 0;
for (auto it : y) {
long long k = 0;
while (val % it.first == 0) {
k++;
val /= it.first;
}
if (k < it.second) maxi |= (1 << id);
id++;
}
ans += mask[(MX - 1) ^ (maxi)];
}
cout << ans << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char name[100000 + 1][10 + 1];
vector<pair<int, int> > reg[10000 + 1];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
int g, s;
scanf("%s%d%d", name[i], &g, &s);
reg[g].push_back({-s, i});
}
for (int i = 1; i <= m; ++i) sort(reg[i].begin(), reg[i].end());
for (int i = 1; i <= m; ++i) {
if (reg[i].size() == 2)
printf("%s %s\n", name[reg[i][0].second], name[reg[i][1].second]);
else {
if (reg[i][1].first == reg[i][2].first)
printf("?\n");
else
printf("%s %s\n", name[reg[i][0].second], name[reg[i][1].second]);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n, i, k;
cin >> n >> k;
if (((n - 1) * n / 2) < k) {
cout << "Impossible";
return 0;
} else {
unsigned long long count = 0, level = 0, require = k;
if (k == 0) {
goto print;
}
while (count < k) {
if (count + level <= k) {
cout << "(";
count += level;
level++;
n--;
} else {
cout << ")";
level--;
}
if (count == k) {
break;
}
}
level--;
while (level >= 0) {
if (level == 0) {
cout << ")";
break;
}
cout << ")";
level--;
}
print:
for (i = 1; i <= n; i++) cout << "()";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
constexpr uint64_t MPF = 1000000000 + 7;
vector<vector<uint64_t>> state;
vector<char> instr;
int main() {
int N;
cin >> N;
instr.resize(N);
state.assign(N, vector<uint64_t>(N, 0));
for (char& c : instr) cin >> c;
state[0][0] = 1;
for (int i = 1; i < N; ++i) {
uint64_t sum = 0;
for (int j = N - 1; j >= 0; --j) {
sum = (sum + state[i - 1][j]) % MPF;
if (instr[i - 1] == 's') {
state[i][j] = sum;
} else {
state[i][j] = (j > 0) ? state[i - 1][j - 1] : 0;
}
}
}
uint64_t sum = 0;
for (int j = 0; j < N; ++j) {
sum = (sum + state[N - 1][j]) % MPF;
}
cout << sum << '\n';
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:20000000")
using namespace std;
long n, i;
double m, p1, p2, maxx, minn, r, l;
long ar[1000000];
int main() {
cin >> n;
cout.precision(6);
for (i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
l = 0;
r = 2000000000;
while (r - l > 0.01) {
m = (l + r) / 2;
p1 = ar[0] + 2 * m;
p2 = ar[n - 1] - 2 * m;
minn = 1100000000;
maxx = -1100000000;
for (i = 0; i < n; i++) {
if (ar[i] > p1 && ar[i] < p2) {
if (ar[i] < minn) minn = ar[i];
if (ar[i] > maxx) maxx = ar[i];
};
}
if (maxx - minn > 2100000000 || maxx - minn < 2 * m) {
r = m;
} else
l = m;
;
}
long lq = m * 2 + 0.1;
m = lq * 0.5;
cout << fixed << m << endl << ar[0] + m;
minn = 1100000000;
for (i = 0; i < n; i++)
if (ar[i] > ar[0] + 2 * m + 0.00000001 && ar[i] < minn) minn = ar[i];
if (minn > 1000000000) minn = ar[0];
cout << " " << minn + m << " " << ar[n - 1] - m << endl;
cin.get();
cin.get();
cin.get();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100;
int n;
long long int tab[MAXN + 3];
long long int p, q;
int main() {
cin >> p >> q;
cin >> n;
for (int i = 0; i < n; i++) cin >> tab[i];
if (tab[n - 1] == 1 && n > 1) {
tab[n - 2]++;
n--;
}
int actual = 0;
while (q > 0) {
if (actual >= n) {
cout << "NO\n";
return 0;
}
long long int k = p / q;
if (k != tab[actual++]) {
cout << "NO\n";
return 0;
}
p = p % q;
swap(p, q);
}
if (actual < n) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[10000001];
priority_queue<int, vector<int>, greater<int> > c;
void pop() {
int m = c.top();
while (!c.empty() && m == c.top()) c.pop(), k--;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
c.push(a[i]);
}
if (k == 0 && c.top() > 1) {
cout << 1;
exit(0);
}
while (1) {
int kq = c.top();
pop();
if (k == 0) {
cout << kq;
break;
}
if (k < 0) {
cout << -1;
break;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, i = 1, p;
int arr[101];
cin >> a;
p = a;
while (a--) {
cin >> arr[i];
i++;
}
if ((arr[1]) % 2 == 0 && (arr[2]) % 2 == 0) {
for (int j = 3; j <= p; j++) {
if ((arr[j]) % 2 == 1) {
cout << j;
}
}
} else if ((arr[1] % 2) == 1 && (arr[2] % 2) == 1) {
for (int j = 3; j <= p; j++) {
if (arr[j] % 2 == 0) {
cout << j;
}
}
} else {
if (arr[1] % 2 == 1 && arr[2] % 2 == 0 && arr[3] % 2 == 1) {
cout << 2;
} else if (arr[1] % 2 == 1 && arr[2] % 2 == 0 && arr[3] % 2 == 0) {
cout << 1;
} else if (arr[1] % 2 == 0 && arr[2] % 2 == 1 && arr[3] % 2 == 0) {
cout << 2;
} else {
cout << 1;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string last = "1689";
for (int i = 0; i < last.size(); ++i) {
s.erase(find(s.begin(), s.end(), last[i]));
}
sort(s.begin(), s.end());
reverse(s.begin(), s.end());
int count = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '0') count++;
}
if (count == s.size()) {
cout << "1869" << s << endl;
return 0;
}
do {
string t = s + last;
int rem = 0;
for (int i = 0; i < t.length(); ++i) {
int x = rem * 10 + t[i] - '0';
rem = x % 7;
}
if (rem == 0) {
cout << t << endl;
return 0;
}
} while (next_permutation(last.begin(), last.end()));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0, num;
cin >> n;
vector<int> v;
vector<int> v1;
vector<int>::iterator it;
for (int i = 0; i < n; i++) {
cin >> num;
v.push_back(num);
}
sort(v.begin(), v.end());
it = v.begin();
for (int i = *it; i <= n; i++) {
int k = (find(v.begin(), v.end(), i)) - v.begin();
if (k == v.size()) {
v1.push_back(i);
}
}
int j = 0;
vector<int>::iterator ptr;
vector<int>::iterator ptr1;
for (ptr = v.begin() + 1; ptr < v.end(); ptr++) {
if (*ptr == *(ptr - 1)) {
int flag = 0;
for (ptr1 = v1.begin(); ptr1 < v1.end(); ptr1++) {
if (*ptr1 > *ptr) {
flag = 1;
sum = sum + (*ptr1 - *ptr);
*ptr1 = 0;
break;
}
}
if (flag == 0) {
n++;
sum += (n - *ptr);
}
}
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 79, maxlog = 19;
int n, m;
vector<pair<pair<int, int>, pair<int, int> > > e(maxn);
vector<int> mst(maxn, 0), d(maxn, 0), pv(maxn), s(maxn, 1), ans(maxn, -1);
int highest(int v) {
while (v != pv[v]) v = pv[v];
return v;
}
bool mergedsu(int a, int b) {
a = highest(a);
b = highest(b);
if (a == b) return false;
if (s[a] < s[b]) swap(a, b);
pv[b] = a;
s[a] += s[b];
return true;
}
vector<vector<pair<int, int> > > t(maxn);
vector<vector<int> > p(maxlog, vector<int>(maxn, 0)),
maxi(maxlog, vector<int>(maxn, 0));
void dfs_prepare_lca(int v = 0) {
for (int i = 1; i < maxlog; i++) p[i][v] = p[i - 1][p[i - 1][v]];
for (int i = 1; i < maxlog; i++)
maxi[i][v] = max(maxi[i - 1][v], maxi[i - 1][p[i - 1][v]]);
for (pair<int, int> i : t[v]) {
if (i.first == p[0][v]) continue;
p[0][i.first] = v;
maxi[0][i.first] = e[i.second].first.first;
d[i.first] = d[v] + 1;
dfs_prepare_lca(i.first);
}
}
int max_edge(int u, int v) {
if (d[u] < d[v]) swap(u, v);
int ans = 0;
for (int i = maxlog - 1; i >= 0; i--)
if (d[p[i][u]] >= d[v]) {
ans = max(ans, maxi[i][u]);
u = p[i][u];
}
if (u == v) return ans;
for (int i = maxlog - 1; i >= 0; i--)
if (p[i][u] != p[i][v]) {
ans = max({ans, maxi[i][u], maxi[i][v]});
u = p[i][u], v = p[i][v];
}
return max({ans, maxi[0][u], maxi[0][v]});
}
vector<set<pair<int, int> > > ss(maxn);
vector<int> my(maxn);
int mergesets(int &m1, int &m2) {
if (ss[m1].size() > ss[m2].size()) swap(m1, m2);
for (pair<int, int> i : ss[m1])
if (ss[m2].count(i))
ss[m2].erase(i);
else
ss[m2].insert(i);
return m2;
}
void dfs(int vr = 0, int p = -1) {
for (pair<int, int> i : t[vr]) {
if (i.second == p) continue;
dfs(i.first, i.second);
my[vr] = mergesets(my[vr], my[i.first]);
}
if (p >= 0)
ans[e[p].first.second] =
(ss[my[vr]].empty() ? -1 : ss[my[vr]].begin()->first - 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> e[i].second.first >> e[i].second.second >> e[i].first.first;
e[i].first.second = i;
e[i].second.first--;
e[i].second.second--;
}
sort(e.begin(), e.begin() + m);
for (int i = 0; i < n; i++) pv[i] = my[i] = i;
for (int i = 0; i < m; i++)
if (mergedsu(e[i].second.first, e[i].second.second)) {
t[e[i].second.first].push_back({e[i].second.second, i});
t[e[i].second.second].push_back({e[i].second.first, i});
mst[i] = true;
}
dfs_prepare_lca();
for (int i = 0; i < m; i++)
if (!mst[i]) {
ans[e[i].first.second] =
max_edge(e[i].second.first, e[i].second.second) - 1;
ss[e[i].second.first].insert({e[i].first.first, i});
ss[e[i].second.second].insert({e[i].first.first, i});
}
dfs();
for (int i = 0; i < m; i++) cout << ans[i] << " ";
cout << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool checkbitt(long long int num, int pos);
long long int setbitt(long long int num, long long int pos);
long long int resetbitt(long long int num, int pos);
const long long int mod = 1e9 + 7;
const long long int N = 2e5 + 100;
int idx[N];
int n, q;
int st[N * 4];
vector<int> graph[N];
void seive() {
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
graph[min(idx[i], idx[j])].push_back(max(idx[i], idx[j]));
}
}
}
void update(int n, int s, int e, int pos) {
if (s == e) {
st[n]++;
return;
}
int mid = (s + e) / 2;
if (mid >= pos)
update(n * 2, s, mid, pos);
else
update(n * 2 + 1, mid + 1, e, pos);
st[n] = st[n * 2] + st[n * 2 + 1];
}
int query(int n, int s, int e, int qs, int qe) {
if (s > qe || e < qs) return 0;
if (s >= qs && e <= qe) return st[n];
int mid = (s + e) / 2;
return query(n * 2, s, mid, qs, qe) + query(n * 2 + 1, mid + 1, e, qs, qe);
}
void U(int id, int v) {
for (; id <= n; st[id] += v, id += (id & -id))
;
}
int Q(int id) {
int ret = 0;
for (; id > 0; ret += st[id], id -= (id & -id))
;
return ret;
}
int solve() {
cin >> n >> q;
int x;
for (int i = 1; i <= n; i++) {
cin >> x;
idx[x] = i;
}
seive();
vector<pair<int, int> > ask[n + 1];
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
ask[l].push_back({r, i});
}
int ans[q];
for (int i = n; i >= 1; i--) {
for (auto x : graph[i]) {
U(x, 1);
}
for (auto x : ask[i]) {
ans[x.second] = Q(x.first);
}
}
for (int i = 0; i < q; i++) cout << ans[i] << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int cs = 1;
int cn = 1;
while (cs--) {
solve();
}
}
bool checkbitt(long long int num, int pos) { return (num >> pos) & 1; }
long long int setbitt(long long int num, long long int pos) {
return (1 << pos) | num;
}
long long int resetbitt(long long int num, int pos) {
if (!checkbitt(num, pos))
return num;
else
return (1 << pos) ^ num;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.