text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
vector<int> G[(3 * 100000 + 42)];
struct LCA {
vector<int> height, euler, first, segtree;
vector<bool> visited;
int n;
LCA(vector<vector<int>> &adj, int root = 0) {
n = adj.size();
height.resize(n);
first.resize(n);
euler.reserve(n * 2);
visited.assign(n, false);
dfs(adj, root);
int m = euler.size();
segtree.resize(m * 4);
build(1, 0, m - 1);
}
void dfs(vector<vector<int>> &adj, int node, int h = 0) {
visited[node] = true;
height[node] = h;
first[node] = euler.size();
euler.push_back(node);
for (auto to : adj[node]) {
if (!visited[to]) {
dfs(adj, to, h + 1);
euler.push_back(node);
}
}
}
void build(int node, int b, int e) {
if (b == e) {
segtree[node] = euler[b];
} else {
int mid = (b + e) / 2;
build(node << 1, b, mid);
build(node << 1 | 1, mid + 1, e);
int l = segtree[node << 1], r = segtree[node << 1 | 1];
segtree[node] = (height[l] < height[r]) ? l : r;
}
}
int query(int node, int b, int e, int L, int R) {
if (b > R || e < L) return -1;
if (b >= L && e <= R) return segtree[node];
int mid = (b + e) >> 1;
int left = query(node << 1, b, mid, L, R);
int right = query(node << 1 | 1, mid + 1, e, L, R);
if (left == -1) return right;
if (right == -1) return left;
return height[left] < height[right] ? left : right;
}
int lca(int u, int v) {
int left = first[u], right = first[v];
if (left > right) swap(left, right);
return query(1, 0, euler.size() - 1, left, right);
}
int dist(int u, int v) {
int parent = lca(u, v);
return height[u] + height[v] - 2 * height[parent];
}
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<vector<int>> V(n + 1, vector<int>());
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
V[a].push_back(b);
V[b].push_back(a);
}
LCA LASEK(V, 1);
int Q;
cin >> Q;
while (Q--) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int dab = LASEK.dist(a, b);
int dxy = LASEK.dist(x, y);
int cycle = dxy + 1;
int dax = LASEK.dist(a, x);
int day = LASEK.dist(a, y);
int dbx = LASEK.dist(b, x);
int dby = LASEK.dist(b, y);
bool good = false;
int zwykla_droga = dab;
int droga_AXYB = dax + 1 + dby;
int droga_BXYA = dbx + 1 + day;
if (zwykla_droga % 2 == k % 2 and zwykla_droga <= k) good = true;
if (droga_AXYB % 2 == k % 2 and droga_AXYB <= k) good = true;
if (droga_BXYA % 2 == k % 2 and droga_BXYA <= k) good = true;
if ((droga_AXYB + cycle) % 2 == k % 2 and droga_AXYB + cycle <= k)
good = true;
if ((droga_BXYA + cycle) % 2 == k % 2 and droga_BXYA + cycle <= k)
good = true;
cout << (good ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
const int poww = 23;
int head[maxn];
int cnt;
int d[maxn];
int p[maxn][poww];
vector<int> v;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
struct node {
int to;
int next;
} e[maxn * 2];
void init() {
memset(head, -1, sizeof(head));
cnt = 0;
}
void add(int u, int v) {
e[cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt++;
e[cnt].to = u;
e[cnt].next = head[v];
head[v] = cnt++;
}
void dfs(int u, int fa) {
d[u] = d[fa] + 1;
p[u][0] = fa;
for (int i = 1; i < poww; i++) {
p[u][i] = p[p[u][i - 1]][i - 1];
}
for (int i = head[u]; i + 1; i = e[i].next) {
if (e[i].to == fa) continue;
dfs(e[i].to, u);
}
}
int lca(int a, int b) {
if (d[a] > d[b]) swap(a, b);
int dis = d[b] - d[a];
for (int i = 0; i < poww; i++)
if (dis & (1 << i)) b = p[b][i];
if (a == b) return a;
for (int i = poww - 1; i >= 0; i--) {
if (p[a][i] != p[b][i]) a = p[a][i], b = p[b][i];
}
return p[b][0];
}
int qiu(int x, int y) {
int tmp = lca(x, y);
return d[x] + d[y] - 2 * d[tmp];
}
int main() {
int n;
while (cin >> n) {
int x, y, a, b, k;
init();
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
}
int q;
cin >> q;
dfs(1, 0);
for (int j = 1; j <= 18; ++j)
for (int i = 1; i <= n; ++i) p[i][j] = p[p[i][j - 1]][j - 1];
for (int i = 0; i < q; i++) {
x = read();
y = read();
a = read();
b = read();
k = read();
v.clear();
int tmp1 = qiu(x, a);
int tmp2 = qiu(y, b);
int dis1 = tmp1 + tmp2 + 1;
tmp1 = qiu(y, a);
tmp2 = qiu(x, b);
int dis2 = tmp1 + tmp2 + 1;
int dis3 = qiu(a, b);
if (dis1 <= k) v.push_back(dis1);
if (dis2 <= k) v.push_back(dis2);
if (dis3 <= k) v.push_back(dis3);
int flag = 0;
if (v.size() > 0) {
for (int i = 0; i < v.size(); i++) {
if (v[i] % 2 == k % 2) {
flag = 1;
}
}
}
if (flag)
cout << "YES" << endl;
else {
cout << "NO" << endl;
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct LCA {
vector<int> height, euler, first, segtree;
vector<bool> visited;
int n;
LCA(vector<vector<int>> &adj, int root = 0) {
n = adj.size();
height.resize(n);
first.resize(n);
euler.reserve(n * 2);
visited.assign(n, false);
dfs(adj, root);
int m = euler.size();
segtree.resize(m * 4);
build(1, 0, m - 1);
}
void dfs(vector<vector<int>> &adj, int node, int h = 0) {
visited[node] = true;
height[node] = h;
first[node] = euler.size();
euler.push_back(node);
for (auto to : adj[node]) {
if (!visited[to]) {
dfs(adj, to, h + 1);
euler.push_back(node);
}
}
}
void build(int node, int b, int e) {
if (b == e) {
segtree[node] = euler[b];
} else {
int mid = (b + e) / 2;
build(node << 1, b, mid);
build(node << 1 | 1, mid + 1, e);
int l = segtree[node << 1], r = segtree[node << 1 | 1];
segtree[node] = (height[l] < height[r]) ? l : r;
}
}
int query(int node, int b, int e, int L, int R) {
if (b > R || e < L) return -1;
if (b >= L && e <= R) return segtree[node];
int mid = (b + e) >> 1;
int left = query(node << 1, b, mid, L, R);
int right = query(node << 1 | 1, mid + 1, e, L, R);
if (left == -1) return right;
if (right == -1) return left;
return height[left] < height[right] ? left : right;
}
int lca(int u, int v) {
int left = first[u], right = first[v];
if (left > right) swap(left, right);
return query(1, 0, euler.size() - 1, left, right);
}
int dist(int u, int v) {
int a = lca(u, v);
return height[u] - height[a] + height[v] - height[a];
}
};
vector<vector<int>> g(100001);
void pre() {}
void solve() {
long long int n, u, v, a, b, k;
cin >> n;
for (long long int i = 0; i < n - 1; i++) {
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
long long int q;
cin >> q;
struct LCA lc(g);
for (long long int i = 0; i < q; i++) {
cin >> u >> v >> a >> b >> k;
v--;
u--;
a--;
b--;
long long int dist1 = lc.dist(a, b), dist2, dist3, dist4;
dist2 = lc.dist(u, v) + 1;
dist3 = lc.dist(u, a);
dist4 = lc.dist(v, b);
if (k - dist1 >= 0 && (dist1 - k) % 2 == 0) {
cout << "YES"
<< "\n";
continue;
}
if (k - dist3 - dist4 - 1 >= 0 && (k - dist3 - dist4 - 1) % 2 == 0) {
cout << "YES"
<< "\n";
continue;
}
if (k - dist3 - dist4 - dist2 - 1 >= 0 &&
(k - dist3 - dist4 - 1 - dist2) % 2 == 0) {
cout << "YES"
<< "\n";
continue;
}
dist4 = lc.dist(u, b);
dist3 = lc.dist(v, a);
if (k - dist3 - dist4 - 1 >= 0 && (k - dist3 - dist4 - 1) % 2 == 0) {
cout << "YES"
<< "\n";
continue;
}
if (k - dist3 - dist4 - dist2 - 1 >= 0 &&
(k - dist3 - dist4 - 1 - dist2) % 2 == 0) {
cout << "YES"
<< "\n";
continue;
}
cout << "NO"
<< "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
pre();
long long int num = 1;
for (long long int i = 0; i < num; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
long long R = 7 + 1e9, NUMTESTCASE;
const int NN = 10 + 2e6;
const double pi = acos(-1.0);
int di[4] = {1, 0, -1, 0}, dj[4] = {0, 1, 0, -1},
DI[8] = {1, 1, 0, -1, -1, -1, 0, 1}, DJ[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
int n, ti = 1, timein[NN], timeout[NN], lev[NN], parn[NN], Hash[NN], m,
segtree[NN];
vector<int> G[NN];
void DFS(int ver, int par, int cnt) {
int in = ti++;
for (int u : G[ver])
if (u != par) DFS(u, ver, cnt + 1);
Hash[ver] = ++m;
lev[Hash[ver]] = cnt;
parn[Hash[ver]] = par;
timein[Hash[ver]] = in;
timeout[Hash[ver]] = ti++;
}
bool isgra(int ver, int par) {
return (timein[par] <= timein[ver] && timeout[par] >= timeout[ver]);
}
unordered_map<int, unordered_map<int, int> > memo;
int com_par(int u, int v) {
if (isgra(v, u)) return u;
if (isgra(u, v)) return v;
auto it1 = memo.find(u);
if (it1 != memo.end()) {
auto it2 = it1->second.find(v);
if (it2 != it1->second.end()) return it2->second;
}
return memo[u][v] = memo[v][u] = com_par(u, parn[v]);
}
void build(int pos, int st, int en) {
if (st == en) {
segtree[pos] = st;
return;
}
build(2 * pos, st, (st + en) / 2);
build(2 * pos + 1, (st + en) / 2 + 1, en);
segtree[pos] = com_par(segtree[2 * pos], segtree[2 * pos + 1]);
}
int seg_com_par(int pos, int st, int en, int u, int v) {
if (en < u || st > v) return -1;
if (st >= u && en <= v) return segtree[pos];
int flag1 = seg_com_par(2 * pos, st, (st + en) / 2, u, v);
int flag2 = seg_com_par(2 * pos + 1, (st + en) / 2 + 1, en, u, v);
int res;
if (flag1 != -1 && flag2 != -1)
res = com_par(flag1, flag2);
else if (flag1 != -1)
res = flag1;
else
res = flag2;
return res;
}
int dis(int v, int u) {
if (u > v) swap(u, v);
return lev[v] + lev[u] - 2 * lev[seg_com_par(1, 1, m, u, v)];
}
int main() {
cin >> n;
int u, v;
for (int i = (1); i <= (n - 1); ++i) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
DFS(1, -1, 0);
parn[Hash[1]] = 1;
for (int i = (1); i <= (n); ++i) parn[i] = Hash[parn[i]];
build(1, 1, m);
int x, y, a, b, k, q;
cin >> q;
while (q--) {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
x = Hash[x];
y = Hash[y];
a = Hash[a];
b = Hash[b];
int flag = 0, ab = dis(a, b), axyb = 1 + dis(a, x) + dis(y, b),
ayxb = 1 + dis(a, y) + dis(x, b);
if (ab % 2 == k % 2 && ab <= k) flag = 1;
if (axyb % 2 == k % 2 && axyb <= k) flag = 1;
if (ayxb % 2 == k % 2 && ayxb <= k) flag = 1;
printf(flag ? "YES\n" : "NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nax = 2e5 + 111;
int n, a, b;
vector<int> v[nax];
int h[nax];
int skok[nax][18];
void dfs(int u, int p) {
h[u] = h[p] + 1;
skok[u][0] = p;
for (int j = 1; j <= 17; ++j) skok[u][j] = skok[skok[u][j - 1]][j - 1];
for (auto it : v[u])
if (it != p) dfs(it, u);
}
int lca(int x, int y) {
if (h[x] < h[y]) swap(x, y);
for (int i = 17; 0 <= i; --i)
if (h[x] - (1 << i) >= h[y]) x = skok[x][i];
if (x == y) return x;
for (int i = 17; 0 <= i; --i)
if (skok[x][i] != skok[y][i]) {
x = skok[x][i];
y = skok[y][i];
}
return skok[x][0];
}
int dis(int a, int b) { return h[a] + h[b] - 2 * h[lca(a, b)]; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
dfs(1, 0);
int q;
scanf("%d", &q);
while (q--) {
int x, y, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
if (dis(a, b) <= k && dis(a, b) % 2 == k % 2) {
printf("YES\n");
continue;
}
int z = dis(a, x) + 1 + dis(y, b);
if (z <= k && z % 2 == k % 2) {
printf("YES\n");
continue;
}
z = dis(a, y) + 1 + dis(x, b);
if (z <= k && z % 2 == k % 2) {
printf("YES\n");
continue;
}
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 600300, M = 400200;
int lg[N];
void _lg() {
for (int i = 2; i < N; i <<= 1) lg[i] = 1;
for (int i = 3; i < N; ++i) lg[i] += lg[i - 1];
}
int st[N][25];
void build(int* a, int n) {
for (int i = 0; i < n; ++i) st[i][0] = i;
for (int j = 1; (1 << j) <= n; ++j)
for (int i = 0; i + (1 << j) < n; ++i) {
int x = st[i][j - 1];
int y = st[i + (1 << (j - 1))][j - 1];
st[i][j] = a[y] < a[x] ? y : x;
}
}
int get(int l, int r, int* a) {
int s = r - l;
int ls = lg[s];
int x = st[l][ls], y = st[r - (1 << ls)][ls];
return a[y] < a[x] ? y : x;
}
int head[N], e;
int to[M], nxt[M];
void init(int n) {
e = 0;
memset(head + 1, -1, n * sizeof(head[0]));
}
void addEdge(int u, int v) {
nxt[e] = head[u];
to[e] = v;
head[u] = e++;
}
void addBiEdge(int u, int v) {
addEdge(u, v);
addEdge(v, u);
}
int id[N], t[N], s[N], c;
int dist[N];
void dfs(int u, int p, int d) {
s[u] = c, t[c] = d, id[c++] = u;
dist[u] = d;
for (int e = head[u]; ~e; e = nxt[e]) {
int v = to[e];
if (v == p) continue;
dfs(v, u, d + 1);
t[c] = d;
id[c++] = u;
}
}
int LCA(int u, int v) {
int l = s[u];
int r = s[v];
if (r < l) swap(l, r);
int x = get(l, r + 1, t);
return id[x];
}
int k;
int clc(int u, int v) {
int lca = LCA(u, v);
return dist[u] + dist[v] - 2 * dist[lca];
}
bool isb(int d) {
if (d > k) return false;
if ((k - d) % 2 == 0) return true;
return false;
}
bool tr(int u, int v) {
if (isb(clc(u, v))) return true;
return false;
}
bool gog(int u, int v, int x, int y) {
int d1 = clc(u, x);
int d2 = clc(v, y);
return isb(d1 + d2 + 1);
}
int main() {
_lg();
int n, m, u, v, x, y, a, b;
cin >> n;
init(n);
for (int i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
addBiEdge(u, v);
}
dfs(1, 0, 0);
build(t, c);
cin >> m;
while (m--) {
scanf("%d %d %d %d %d", &x, &y, &a, &b, &k);
if (tr(a, b))
cout << "YES\n";
else if (gog(a, b, x, y))
cout << "YES\n";
else if (gog(a, b, y, x))
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000;
const long long LINF = INF * (long long)INF;
const int MAX = 100007;
const int MOD = 1000000007;
vector<int> G[MAX];
int up[MAX][20];
int tin[MAX];
int tout[MAX];
int d[MAX];
int timer = 0;
void dfs(int v, int p) {
tin[v] = timer++;
up[v][0] = p;
for (int i = (1); i < (20); i++) up[v][i] = up[up[v][i - 1]][i - 1];
for (int to : G[v]) {
if (to == p) continue;
d[to] = d[v] + 1;
dfs(to, v);
}
tout[v] = timer++;
}
bool upper(int a, int b) { return (tin[a] <= tin[b] && tout[a] >= tout[b]); }
int lca(int a, int b) {
if (upper(a, b)) return a;
if (upper(b, a)) return b;
for (int i = (20) - 1; i >= (0); i--) {
if (!upper(up[a][i], b)) a = up[a][i];
}
return up[a][0];
}
int dist(int a, int b) {
int c = lca(a, b);
return d[a] + d[b] - 2 * d[c];
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n;
for (int i = (0); i < (n - 1); i++) {
int a, b;
cin >> a >> b;
--a;
--b;
G[a].push_back(b);
G[b].push_back(a);
}
dfs(0, 0);
int q;
cin >> q;
for (int i = (0); i < (q); i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
--x;
--y;
--a;
--b;
bool res = false;
int l = dist(a, b);
if (l <= k && l % 2 == k % 2) res = true;
l = dist(a, x) + 1 + dist(b, y);
if (l <= k && l % 2 == k % 2) res = true;
l = dist(a, y) + 1 + dist(b, x);
if (l <= k && l % 2 == k % 2) res = true;
if (res)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int a, b, k, t, x, y, n, q, i, j, up[N][20], ln, dist[N], tin[N], tout[N];
vector<int> v[N];
void dfs(int u, int pr) {
tin[u] = ++t;
up[u][0] = pr;
for (i = 1; i <= ln; ++i) up[u][i] = up[up[u][i - 1]][i - 1];
for (auto j : v[u])
if (pr != j) {
dist[j] = dist[u] + 1;
dfs(j, u);
}
tout[u] = ++t;
}
int check(int x, int y) { return tin[x] <= tin[y] && tout[x] >= tout[y]; }
int lca(int x, int y) {
if (check(x, y)) return x;
if (check(y, x)) return y;
for (j = ln; j >= 0; --j) {
if (!check(up[x][j], y)) x = up[x][j];
}
return up[x][0];
}
int get(int x, int y) {
int h = lca(x, y);
return dist[x] + dist[y] - 2 * dist[h];
}
int main() {
cin >> n;
for (i = 1; i < n; ++i) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
while ((1 << ln) <= n) ++ln;
++ln;
dfs(1, 1);
cin >> q;
for (i = 1; i <= q; ++i) {
cin >> x >> y >> a >> b >> k;
vector<int> ans;
ans.push_back(get(a, b));
ans.push_back(get(a, x) + get(b, y) + 1);
ans.push_back(get(a, y) + get(b, x) + 1);
int f = 0;
for (auto j : ans) {
if (j <= k && (k - j) % 2 == 0) f = 1;
}
if (f)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline void normal(int64_t &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline int64_t modMul(int64_t a, int64_t b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline int64_t modAdd(int64_t a, int64_t b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline int64_t modSub(int64_t a, int64_t b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline int64_t modPow(int64_t b, int64_t p) {
int64_t r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline int64_t modInverse(int64_t a) { return modPow(a, 1000000007 - 2); }
inline int64_t modDiv(int64_t a, int64_t b) { return modMul(a, modInverse(b)); }
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
typename vector<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
typename set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
typename map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
const int64_t siz = 2e5 + 1;
vector<int64_t> adj[siz];
int64_t timer, n, l;
vector<int64_t> in, out, level;
vector<vector<int64_t> > up;
void dfs(int64_t node, int64_t parent, int64_t h = 0) {
in[node] = ++timer;
up[node][0] = parent;
level[node] = h;
for (int64_t i = 1; i <= l; i++) {
up[node][i] = up[up[node][i - 1]][i - 1];
}
for (auto to : adj[node]) {
if (to != parent) {
dfs(to, node, h + 1);
}
}
out[node] = ++timer;
}
bool is_ancestor(int64_t u, int64_t v) {
return (in[u] <= in[v] and out[u] >= out[v]);
}
int64_t lca(int64_t u, int64_t v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (int64_t i = l; i >= 0; i--) {
if (!is_ancestor(up[u][i], v)) u = up[u][i];
}
return up[u][0];
}
void preprocess(int64_t root) {
in.resize(n + 1);
out.resize(n + 1);
level.resize(n + 1);
timer = 0;
l = ceil(log2(n + 1));
up.assign(n + 1, vector<int64_t>(l + 1));
dfs(root, root);
}
int64_t path_length(int64_t u, int64_t v) {
int64_t l = lca(u, v);
return level[u] + level[v] - 2 * level[l];
}
bool check(int64_t x, int64_t k) {
if (x <= k && x % 2 == k % 2) return true;
return false;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int64_t T = 1;
for (int64_t trr = 1; trr < T + 1; trr++) {
int64_t q;
cin >> n;
for (int64_t i = 0; i < n - 1; i++) {
int64_t u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
preprocess(1);
bool wrong;
cin >> q;
while (q--) {
int64_t x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int64_t ab = path_length(a, b), ax = path_length(a, x),
yb = path_length(b, y), ay = path_length(a, y),
bx = path_length(b, x);
if (check(ab, k) || check(ax + yb + 1, k) || check(ay + bx + 1, k))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int t = 20;
int N, M, deep[int(3e5 + 5)], f[int(3e5 + 5)][t + 5];
int tot, nt[int(3e5 + 5)], hd[int(3e5 + 5)], ver[int(3e5 + 5)];
inline void read(int &x) {
x = 0;
bool f = 0;
char ch = getchar();
for (; !(ch >= '0' && ch <= '9'); ch = getchar()) f |= ch == '-';
for (; (ch >= '0' && ch <= '9'); ch = getchar())
x = (x << 3) + (x << 1) + (ch ^ 48);
x = f ? -x : x;
}
inline void addedge(int x, int y) {
++tot;
nt[tot] = hd[x];
ver[tot] = y;
hd[x] = tot;
}
void Dfs(int x) {
for (int i = hd[x]; i; i = nt[i]) {
int y = ver[i];
if (f[x][0] == y) continue;
f[y][0] = x;
deep[y] = deep[x] + 1;
for (int i = 1; i <= t; ++i) f[y][i] = f[f[y][i - 1]][i - 1];
Dfs(y);
}
}
inline int lca(int x, int y) {
if (deep[x] > deep[y]) swap(x, y);
for (int i = t; i >= 0; --i)
if (deep[f[y][i]] >= deep[x]) y = f[y][i];
if (x == y) return x;
for (int i = t; i >= 0; --i)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
inline int cnt(int x, int y) { return deep[x] + deep[y] - 2 * deep[lca(x, y)]; }
int main() {
read(N);
for (int i = 1; i < N; ++i) {
int x, y;
read(x);
read(y);
addedge(x, y);
addedge(y, x);
}
Dfs(1);
read(M);
for (int i = 1; i <= M; ++i) {
int f = 0, x, y, a, b, k;
read(x);
read(y);
read(a);
read(b);
read(k);
int u = cnt(a, b), v = cnt(a, x) + cnt(b, y) + 1,
t = cnt(a, y) + cnt(b, x) + 1;
if (u <= k && (u % 2 == k % 2)) f = 1;
if (v <= k && (v % 2 == k % 2)) f = 1;
if (t <= k && (t % 2 == k % 2)) f = 1;
if (!f) {
printf("NO\n");
continue;
}
printf("YES\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010, logN = 20;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
struct node {
int v, nxt;
} e[N];
int lca[N][logN + 1];
int head[N], ejs;
void add(int u, int v) {
e[++ejs].v = v;
e[ejs].nxt = head[u];
head[u] = ejs;
}
int dis[N];
void dfs(int u, int fa) {
for (int i = 1; i <= logN; ++i) lca[u][i] = lca[lca[u][i - 1]][i - 1];
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
lca[v][0] = u;
dis[v] = dis[u] + 1;
dfs(v, u);
}
}
int LCA(int x, int y) {
if (dis[x] < dis[y]) swap(x, y);
for (int i = logN; i >= 0; --i)
if (dis[lca[x][i]] >= dis[y]) x = lca[x][i];
for (int i = logN; i >= 0; --i)
if (lca[x][i] != lca[y][i]) x = lca[x][i], y = lca[y][i];
if (x != y) x = lca[x][0];
return x;
}
int dist(int x, int y) { return dis[x] + dis[y] - 2 * dis[LCA(x, y)]; }
int main() {
int n = read();
for (int i = 1; i < n; ++i) {
int u = read(), v = read();
add(u, v);
add(v, u);
}
dfs(1, 0);
int Q = read();
while (Q--) {
int x = read(), y = read(), a = read(), b = read(), k = read();
int t = dist(a, b);
if (t <= k && (t & 1) == (k & 1)) {
puts("YES");
continue;
}
int t1 = dist(x, a), t2 = dist(y, b);
t = t1 + t2 + 1;
if (t <= k && (t & 1) == (k & 1)) {
puts("YES");
continue;
}
t1 = dist(x, b);
t2 = dist(y, a);
t = t1 + t2 + 1;
if (t <= k && (t & 1) == (k & 1)) {
puts("YES");
continue;
}
puts("NO");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
int n, N, q;
int f[maxn + 5][25];
int dis[maxn + 5];
vector<int> E[maxn + 5];
int get_log(int x) {
int t = 0;
while ((1 << (t + 1)) <= x) t++;
return t;
}
void dfs(int x, int fa) {
f[x][0] = fa;
dis[x] = dis[fa] + 1;
for (int i = 0; i < E[x].size(); i++) {
int v = E[x][i];
if (v != fa) {
dfs(v, x);
}
}
}
int get_lca(int u, int v) {
if (dis[u] < dis[v]) swap(u, v);
int d = dis[u] - dis[v];
for (int i = 0; i <= N; i++) {
if ((1 << i) & d) {
u = f[u][i];
}
}
if (u == v) return u;
for (int i = N; i >= 0; i--) {
if (f[u][i] != f[v][i]) {
u = f[u][i];
v = f[v][i];
}
}
return f[u][0];
}
int main() {
scanf("%d", &n);
N = get_log(n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
E[u].push_back(v);
E[v].push_back(u);
}
dis[0] = 0;
dfs(1, 0);
for (int j = 1; j <= N; j++)
for (int i = 1; i <= n; i++) f[i][j] = f[f[i][j - 1]][j - 1];
scanf("%d", &q);
while (q--) {
bool flag = false;
int x, y, a, b, k, u, v;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
u = get_lca(a, b);
int len = dis[a] + dis[b] - 2 * dis[u];
if ((len & 1) == (k & 1) && (len <= k)) flag = true;
if (!flag) {
u = get_lca(a, x);
v = get_lca(b, y);
int len1 =
dis[a] + dis[x] - 2 * dis[u] + dis[b] + dis[y] - 2 * dis[v] + 1;
u = get_lca(a, y);
v = get_lca(b, x);
int len2 =
dis[a] + dis[y] - 2 * dis[u] + dis[b] + dis[x] - 2 * dis[v] + 1;
if (((len1 & 1) == (k & 1) && len1 <= k) ||
((len2 & 1) == (k & 1) && len2 <= k))
flag = true;
}
if (flag)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> g[100009];
long long depth[100009];
long long dad[100009][30];
void dfs(long long v, long long prt) {
dad[v][0] = prt;
for (long long i = 1; i < 30; ++i) dad[v][i] = dad[dad[v][i - 1]][i - 1];
for (auto u : g[v]) {
if (u == prt) continue;
depth[u] = depth[v] + 1;
dfs(u, v);
}
}
long long lca(long long x, long long y) {
if (depth[y] > depth[x]) swap(x, y);
for (long long i = 29; i >= 0; --i)
if (depth[dad[x][i]] >= depth[y]) x = dad[x][i];
if (x == y) return x;
for (long long i = 29; i >= 0; --i)
if (dad[x][i] != dad[y][i]) {
x = dad[x][i];
y = dad[y][i];
}
return dad[y][0];
}
long long dist(long long x, long long y) {
long long lc = lca(x, y);
return depth[x] - depth[lc] + depth[y] - depth[lc];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (long long i = 0; i < n - 1; ++i) {
long long x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
long long q;
cin >> q;
while (q--) {
long long x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
if (dist(a, b) <= k && (k - dist(a, b)) % 2 == 0)
cout << "YES\n";
else if (dist(a, x) + dist(b, y) + 1 <= k &&
(k - (dist(a, x) + dist(b, y) + 1)) % 2 == 0)
cout << "YES\n";
else if (dist(a, y) + dist(b, x) + 1 <= k &&
(k - (dist(a, y) + dist(b, x) + 1)) % 2 == 0)
cout << "YES\n";
else
cout << "NO\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int M = 1e9 + 7;
long long int inf = 9 * 1e18;
long long int begtime = clock();
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) int idx,
__attribute__((unused)) int LINE_NUM) {
cout << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if (idx > 0)
cout << " | ";
else
cout << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cout << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
long long int n, m;
long long int binpow(long long int val, long long int deg) {
if (deg < 0) return 0;
if (!deg) return 1 % M;
if (deg & 1) return binpow(val, deg - 1) * val % M;
long long int res = binpow(val, deg >> 1);
return (res * res) % M;
}
long long int modinv(long long int n) { return binpow(n, M - 2); }
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int l;
vector<vector<long long int>> adj;
long long int timer;
vector<long long int> tin, tout, d;
vector<vector<long long int>> up;
void dfs(long long int vector, long long int p) {
tin[vector] = ++timer;
up[vector][0] = p;
d[vector] = d[p] + 1;
for (long long int i = 1; i <= l; ++i)
up[vector][i] = up[up[vector][i - 1]][i - 1];
for (long long int u : adj[vector]) {
if (u != p) dfs(u, vector);
}
tout[vector] = ++timer;
}
bool is_ancestor(long long int u, long long int vector) {
return tin[u] <= tin[vector] && tout[u] >= tout[vector];
}
long long int lca(long long int u, long long int vector) {
if (is_ancestor(u, vector)) return u;
if (is_ancestor(vector, u)) return vector;
for (long long int i = l; i >= 0; --i) {
if (!is_ancestor(up[u][i], vector)) u = up[u][i];
}
return up[u][0];
}
void preprocess(long long int root) {
tin.resize(n);
tout.resize(n);
d.assign(n, 0);
timer = 0;
l = ceil(log2(n));
up.assign(n, vector<long long int>(l + 1));
dfs(root, root);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int i, j, t, k, x, y, z, N;
cin >> n;
adj.resize(n);
for (i = 0; i < n - 1; i++) {
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
preprocess(0);
long long int m;
cin >> m;
for (i = 0; i < m; i++) {
long long int a, b;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
long long int d1 = d[a] + d[b] - 2 * d[lca(a, b)];
long long int flg = 0;
if (d1 <= k) {
if ((k - d1) % 2 == 0) flg = 1;
}
long long int d2 = d[x] + d[a] - 2 * d[lca(a, x)];
long long int d3 = d[y] + d[b] - 2 * d[lca(b, y)];
long long int dum = d2 + d3 + 1;
if (dum <= k) {
if ((k - dum) % 2 == 0) flg = 1;
}
d2 = d[x] + d[b] - 2 * d[lca(b, x)];
d3 = d[y] + d[a] - 2 * d[lca(a, y)];
dum = d2 + d3 + 1;
if (dum <= k) {
if ((k - dum) % 2 == 0) flg = 1;
}
if (flg)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int lg = 30;
int n, m;
int h[maxn];
bool mark[maxn];
int f[lg][maxn];
string ans[maxn];
vector<int> adj[maxn];
void in();
void dfs(int u);
void solve();
int dis(int u, int v);
void out();
int main() {
in();
solve();
out();
}
void in() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
cin >> m;
}
void dfs(int u) {
for (int i = 1; i < lg; i++)
if (f[i - 1][u] != -1) f[i][u] = f[i - 1][f[i - 1][u]];
mark[u] = 1;
for (auto v : adj[u]) {
if (!mark[v]) {
h[v] = h[u] + 1;
f[0][v] = u;
dfs(v);
}
}
}
void solve() {
for (int i = 0; i < lg; i++) fill(f[i], f[i] + n, -1);
dfs(0);
for (int t = 0; t < m; t++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
x--;
y--;
a--;
b--;
ans[t] = "NO\n";
int ab = dis(a, b);
int xy = dis(x, y);
int ax = dis(a, x);
int ay = dis(a, y);
int bx = dis(b, x);
int by = dis(b, y);
if (ab <= k && (k - ab) % 2 == 0) ans[t] = "YES\n";
ab = ax + 1 + by;
if (ab <= k && (k - ab) % 2 == 0) ans[t] = "YES\n";
ab = ay + 1 + bx;
if (ab <= k && (k - ab) % 2 == 0) ans[t] = "YES\n";
}
}
int dis(int u, int v) {
int tmp = h[u] + h[v];
if (h[u] > h[v]) swap(u, v);
for (int i = lg - 1; i >= 0; i--)
if (f[i][v] != -1 && h[f[i][v]] >= h[u]) v = f[i][v];
if (u == v) return tmp - 2 * h[u];
for (int i = lg - 1; i >= 0; i--) {
if (f[i][v] != f[i][u]) {
v = f[i][v];
u = f[i][u];
}
}
u = f[0][u];
return tmp - 2 * h[u];
}
void out() {
for (int i = 0; i < m; i++) cout << ans[i];
}
|
#include <bits/stdc++.h>
std::vector<int> euler, height, first, seg_tree;
std::vector<std::vector<int> > adj;
std::vector<bool> seen;
int nodes, m;
void dfs(int v, int h) {
seen[v] = true, height[v] = h;
first[v] = euler.size(), euler.push_back(v);
for (auto u : adj[v])
if (!seen[u]) dfs(u, h + 1), euler.push_back(v);
}
void setup_seg(int v, int l, int r) {
if (l == r)
seg_tree[v] = euler[l];
else {
int mid = (l + r) / 2, a, b;
setup_seg(v * 2, l, mid);
setup_seg(v * 2 + 1, mid + 1, r);
a = seg_tree[v * 2], b = seg_tree[v * 2 + 1];
seg_tree[v] = (height[a] < height[b] ? a : b);
}
}
int query(int n, int t_l, int t_r, int l, int r) {
if (l > r) return -1;
if (l == t_l && r == t_r) return height[seg_tree[n]];
int mid = (t_l + t_r) / 2;
int left = query(n * 2, t_l, mid, l, std::min(r, mid));
int right = query(n * 2 + 1, mid + 1, t_r, std::max(l, mid + 1), r);
if (left == -1) return right;
if (right == -1) return left;
return std::min(left, right);
}
void setup() {
height.resize(nodes), first.resize(nodes), seen.resize(nodes);
dfs(0, 0), m = euler.size(), seg_tree.resize(4 * m);
setup_seg(1, 0, m - 1);
}
int dist(int u, int v) {
int h_u, h_v, h_lca;
if (first[u] > first[v]) std::swap(u, v);
h_u = height[u], h_v = height[v];
h_lca = query(1, 0, m - 1, first[u], first[v]);
return h_u - h_lca + h_v - h_lca;
}
bool possible(int dist, int k) { return (dist <= k && dist % 2 == k % 2); }
int main() {
std::cin >> nodes;
adj.resize(nodes);
for (int i = 0, u, v; i < nodes - 1; i++) {
std::cin >> u >> v;
adj[u - 1].push_back(v - 1);
adj[v - 1].push_back(u - 1);
}
setup();
int con_a, con_b, u, v, k, q;
int d, d_with_a, d_with_b;
std::cin >> q;
while (q--) {
std::cin >> con_a >> con_b >> u >> v >> k;
con_a--, con_b--, u--, v--;
d = dist(u, v);
d_with_a = dist(u, con_a) + dist(con_b, v) + 1;
d_with_b = dist(u, con_b) + dist(con_a, v) + 1;
if (possible(d, k) || possible(d_with_a, k) || possible(d_with_b, k))
std::cout << "YES"
<< "\n";
else
std::cout << "NO"
<< "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000, LOG = 20;
vector<vector<int>> g(N), p(N, vector<int>(LOG));
vector<int> d(N), tin(N), tout(N), c(N);
int f = 1;
void dfs(int u, int pr, int depth) {
p[u][0] = pr;
tin[u] = f++;
for (int i = 1; i < LOG; i++) {
p[u][i] = p[p[u][i - 1]][i - 1];
}
d[u] = depth;
c[u] = d[u] % 2;
for (auto v : g[u]) {
if (v != pr) {
dfs(v, u, depth + 1);
}
}
tout[u] = f++;
}
bool is_ancestor(int u, int v) {
return tin[u] <= tin[v] && tout[u] >= tout[v];
}
int lca(int u, int v) {
if (is_ancestor(u, v)) {
return u;
}
if (is_ancestor(v, u)) {
return v;
}
for (int i = LOG - 1; i >= 0; i--) {
if (!is_ancestor(p[u][i], v)) {
u = p[u][i];
}
}
return p[u][0];
}
int dist(int u, int v) {
int a = lca(u, v);
return d[u] + d[v] - 2 * d[a];
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[--u].push_back(--v);
g[v].push_back(u);
}
dfs(0, 0, 0);
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int a, b, x, y, k;
scanf("%d %d %d %d %d", &x, &y, &a, &b, &k);
--a, --b, --x, --y;
int distance = dist(a, b);
if (distance <= k && distance % 2 == k % 2) {
puts("yes");
continue;
}
distance = dist(a, x);
distance += dist(b, y) + 1;
if (distance <= k && distance % 2 == k % 2) {
puts("yes");
continue;
}
distance = dist(a, y);
distance += dist(b, x) + 1;
if (distance <= k && distance % 2 == k % 2) {
puts("yes");
continue;
}
puts("no");
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, u, v, q, x, y, a, b, k, p[100007][22], d[100007];
vector<long long int> adj[100007];
void dfs(long long int x, long long int par) {
d[x] = d[par] + 1;
p[x][0] = par;
for (long long int i = 1; i <= 20; ++i) {
p[x][i] = p[p[x][i - 1]][i - 1];
}
for (long long int i : adj[x]) {
if (i != par) dfs(i, x);
}
}
long long int dist(long long int a, long long int b) {
if (d[a] > d[b]) swap(a, b);
long long int res = 0;
for (long long int i = 20; i >= 0; --i) {
if (d[p[b][i]] >= d[a]) {
b = p[b][i];
res += (1 << i);
}
}
if (a == b) return res;
for (long long int i = 20; i >= 0; --i) {
if (p[b][i] != p[a][i]) {
b = p[b][i];
a = p[a][i];
res += (1 << (i + 1));
}
}
return res + 2;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long int i = 0; i < n - 1; ++i) {
long long int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1, 0);
cin >> q;
while (q--) {
cin >> x >> y >> a >> b >> k;
long long int ans = dist(a, b), ans2 = (dist(a, x) + dist(y, b)) + 1,
ans3 = (dist(a, y) + dist(x, b)) + 1;
long long int f = 0x3f3f3f3f3f3f3f3f;
if (ans % 2 == k % 2) f = min(f, ans);
if (ans2 % 2 == k % 2) f = min(f, ans2);
if (ans3 % 2 == k % 2) f = min(f, ans3);
if (f <= k)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Pll = pair<ll, ll>;
using Pii = pair<int, int>;
constexpr int INF = 1 << 30;
constexpr ll LINF = 1LL << 60;
constexpr ll MOD = 1000000007;
constexpr long double EPS = 1e-10;
constexpr int dyx[4][2] = {{0, 1}, {-1, 0}, {0, -1}, {1, 0}};
constexpr int N_MAX = 100000;
vector<int> graph[N_MAX];
class LowestCommonAncestor {
public:
int root, n, LOG_V_MAX = 30;
vector<int> depth;
vector<vector<int>> parent;
LowestCommonAncestor(int root = 0, int n = N_MAX) : root(root), n(n) {
depth.assign(n, -1);
parent.assign(n, vector<int>(LOG_V_MAX, -1));
dfs(root, -1, 0);
for (int j = 1; j < LOG_V_MAX; ++j) {
for (int i = 0; i < n; ++i) {
if (parent[i][j - 1] == -1) continue;
parent[i][j] = parent[parent[i][j - 1]][j - 1];
}
}
}
void dfs(int node, int par, int d) {
depth[node] = d;
parent[node][0] = par;
for (auto child : graph[node]) {
int c = child;
if (c == par) continue;
dfs(c, node, d + 1);
}
}
int get_lca(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
int depth_diff = depth[v] - depth[u];
for (int j = 0; j < LOG_V_MAX; ++j) {
if (depth_diff & (1 << j)) {
v = parent[v][j];
}
}
if (u == v) return u;
for (int j = LOG_V_MAX - 1; j >= 0; --j) {
if (parent[u][j] != parent[v][j]) {
u = parent[u][j];
v = parent[v][j];
}
}
return parent[u][0];
}
int get_dist(int u, int v) {
return depth[u] + depth[v] - 2 * depth[get_lca(u, v)];
}
};
bool in_loop(LowestCommonAncestor &lca, int a, int x, int y, int l) {
if (lca.depth[a] < lca.depth[l] ||
max(lca.depth[x], lca.depth[y]) < lca.depth[a])
return false;
if (lca.get_lca(a, l) == l) {
if (lca.get_lca(a, x) == a || lca.get_lca(a, y) == a) return true;
}
return false;
}
void solve(LowestCommonAncestor &lca) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
--x;
--y;
--a;
--b;
int xy = lca.get_dist(x, y), ab = lca.get_dist(a, b);
if (ab <= k && k % 2 == ab % 2) {
cout << "YES\n";
return;
}
int l = lca.get_lca(x, y);
int cycle_length = xy + 1;
int d = lca.get_dist(a, x) + 1 + lca.get_dist(y, b);
if (d <= k && d % 2 == k % 2) {
cout << "YES\n";
return;
}
d = d - 1 + cycle_length - xy;
if (d <= k && d % 2 == k % 2) {
cout << "YES\n";
return;
}
d = lca.get_dist(a, y) + 1 + lca.get_dist(x, b);
if (d <= k && d % 2 == k % 2) {
cout << "YES\n";
return;
}
d = d - 1 + cycle_length - xy;
if (d <= k && d % 2 == k % 2) {
cout << "YES\n";
return;
}
cout << "NO\n";
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
graph[u].push_back(v);
graph[v].push_back(u);
}
LowestCommonAncestor lca = LowestCommonAncestor();
int t;
cin >> t;
while (t--) {
solve(lca);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, u, v;
vector<int> e[100005];
int p[100005][21], d[100005], q, x, y, a, b, k;
void dfs(int x, int fa) {
d[x] = d[fa] + 1;
p[x][0] = fa;
for (int i = 1; i <= 20; ++i) {
p[x][i] = p[p[x][i - 1]][i - 1];
}
for (int i = 0; i < e[x].size(); ++i) {
int u = e[x][i];
if (u == fa) continue;
dfs(u, x);
}
}
int LCA(int u, int v) {
if (d[u] < d[v]) swap(u, v);
for (int i = 20; i >= 0; --i) {
if (d[u] - d[v] >= (1 << i)) u = p[u][i];
}
if (u == v) return u;
for (int i = 20; i >= 0; --i) {
if (p[u][i] != p[v][i]) {
u = p[u][i];
v = p[v][i];
}
}
return p[u][0];
}
int dis(int u, int v) {
int top = LCA(u, v);
return d[u] + d[v] - 2 * d[top];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, 1);
scanf("%d", &q);
while (q--) {
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
int d1 = dis(a, b);
int flag = 0, circle = dis(x, y) + 1;
if (k >= d1 && ((k - d1) & 1) == 0) flag = 1;
int d2 = dis(a, x) + dis(b, y) + 1;
if (k >= d2 && ((k - d2) & 1) == 0) flag = 1;
int d3 = dis(a, y) + dis(b, x) + 1;
if (k >= d3 && ((k - d3) & 1) == 0) flag = 1;
if (k >= d2 + circle) {
int tmp = k - d2 - circle;
if ((tmp & 1) == 0) flag = 1;
}
if (k >= d3 + circle) {
int tmp = k - d3 - circle;
if ((tmp & 1) == 0) flag = 1;
}
puts(flag ? "YES" : "NO");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
vector<int> G[N];
int pos[N], dep[N], rmq[22][2 * N], cur, n;
void dfs(int u, int fa = 0) {
dep[u] = dep[fa] + 1;
pos[u] = ++cur;
rmq[0][cur] = u;
for (int v : G[u])
if (v != fa) {
dfs(v, u);
rmq[0][++cur] = u;
}
}
int Min(int x, int y) { return dep[x] < dep[y] ? x : y; }
void rmq_init() {
for (int l = 1, j = 1; l <= cur; l <<= 1, j++)
for (int i = 1; i + (l << 1) - 1 <= cur; i++)
rmq[j][i] = Min(rmq[j - 1][i], rmq[j - 1][i + l]);
}
void init() {
dfs(1);
rmq_init();
}
int lca(int x, int y) {
x = pos[x], y = pos[y];
if (x > y) swap(x, y);
int logl = log2(y - x + 1);
int l = 1 << logl;
return Min(rmq[logl][x], rmq[logl][y - l + 1]);
}
int query(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; };
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
init();
int q;
scanf("%d", &q);
while (q--) {
int c, d, a, b, k;
scanf("%d%d%d%d%d", &c, &d, &a, &b, &k);
int t = query(a, b);
if (t <= k && (k % 2 == t % 2)) {
printf("YES\n");
continue;
}
int s = query(a, c) + 1 + query(d, b);
if (s <= k && (s % 2 == k % 2)) {
printf("YES\n");
continue;
}
int r = query(a, d) + 1 + query(c, b);
if (r <= k && (r % 2 == k % 2)) {
printf("YES\n");
continue;
}
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100, M = 20010010;
int head[N], ver[M], Next[M], tot;
int n, q;
int f[N][20], d[N], t, dist[N];
void add(int x, int y) {
ver[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
}
void bfs() {
queue<int> q;
q.push(1);
d[1] = 1;
while (q.size()) {
int x = q.front();
q.pop();
for (int i = head[x]; i; i = Next[i]) {
int y = ver[i];
if (d[y]) continue;
d[y] = d[x] + 1;
f[y][0] = x;
for (int j = 1; j <= t; j++) f[y][j] = f[f[y][j - 1]][j - 1];
q.push(y);
}
}
}
int lca(int x, int y) {
if (d[x] > d[y]) swap(x, y);
for (int i = t; i >= 0; i--)
if (d[f[y][i]] >= d[x]) y = f[y][i];
if (x == y) return x;
for (int i = t; i >= 0; i--)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
int dis(int u, int v) {
int dx = lca(u, v);
return d[u] + d[v] - 2 * d[dx];
}
int main() {
scanf("%d", &n);
tot = 0;
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
t = (int)(log(n) / log(2) + 1);
bfs();
scanf("%d", &q);
while (q--) {
int x, y, a, b, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
int s1 = dis(a, b), s2 = dis(a, x) + dis(b, y) + 1,
s3 = dis(a, y) + dis(b, x) + 1;
if ((k >= s1 && (k - s1) % 2 == 0) || (k >= s2 && (k - s2) % 2 == 0) ||
(k >= s3 && (k - s3) % 2 == 0))
printf("YES\n");
else
printf("NO\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MAX_N = 100000;
const long long int LIM = 17;
const long long int INF = (long long int)1e9 + 7;
vector<long long int> adj[MAX_N + 5];
long long int depth[MAX_N + 5];
long long int par[MAX_N + 5][LIM + 1];
void build(long long int cur, long long int p) {
long long int i;
depth[cur] = depth[p] + 1;
par[cur][0] = p;
for (i = 1; i <= LIM; i++) par[cur][i] = par[par[cur][i - 1]][i - 1];
for (long long int x : adj[cur])
if (x != p) build(x, cur);
}
long long int lca_len(long long int a, long long int b) {
long long int i, len = 0;
if (depth[a] > depth[b]) swap(a, b);
for (i = LIM; i >= 0; i--) {
if (depth[par[b][i]] >= depth[a]) {
b = par[b][i];
len += (1 << i);
}
}
if (a == b) return len;
for (i = LIM; i >= 0; i--) {
if (par[a][i] != par[b][i]) {
a = par[a][i];
b = par[b][i];
len += (1 << (i + 1));
}
}
return len + 2;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n, q, i;
cin >> n;
for (i = 0; i < n - 1; i++) {
long long int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
build(1, 0);
cin >> q;
while (q--) {
long long int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
long long int without = lca_len(a, b);
long long int with =
min(lca_len(a, x) + lca_len(y, b), lca_len(a, y) + lca_len(x, b)) + 1;
long long int ans = INF;
if (without % 2 == k % 2) ans = without;
if (with % 2 == k % 2) ans = min(ans, with);
cout << (ans <= k ? "YES" : "NO") << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, Q;
vector<long long> G[100005];
int Prev[100005][17];
int depth[100005];
void predfs(int v, int p, int d) {
depth[v] = d;
Prev[v][0] = p;
for (int i = 0; i < G[v].size(); i++) {
if (G[v][i] == p) continue;
predfs(G[v][i], v, d + 1);
}
}
int getLCA(int u, int v) {
int x = u, y = v;
if (depth[y] > depth[x]) swap(x, y);
for (int i = 16; i >= 0; i--) {
if (depth[x] - (1 << i) >= depth[y]) x = Prev[x][i];
}
if (x == y) return x;
for (int i = 16; i >= 0; i--) {
if (Prev[x][i] != Prev[y][i]) {
x = Prev[x][i];
y = Prev[y][i];
}
}
x = Prev[x][0];
return x;
}
long long getDist(long long u, long long v) {
long long lca = getLCA(u, v);
return depth[u] + depth[v] - 2 * depth[lca];
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
long long u, v;
for (int i = 1; i <= n - 1; i++) {
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
predfs(1, 0, 0);
for (int i = 1; i < 17; i++) {
for (int j = 1; j <= n; j++) {
Prev[j][i] = Prev[Prev[j][i - 1]][i - 1];
}
}
cin >> Q;
long long x, y, a, b, k;
for (int q = 0; q < Q; q++) {
cin >> x >> y >> a >> b >> k;
long long d = getDist(a, b);
if (d <= k && d % 2 == k % 2) {
cout << "YES"
<< "\n";
continue;
}
d = getDist(x, a) + getDist(y, b) + 1;
if (d <= k && d % 2 == k % 2) {
cout << "YES"
<< "\n";
continue;
}
d = getDist(x, b) + getDist(y, a) + 1;
if (d <= k && d % 2 == k % 2) {
cout << "YES"
<< "\n";
continue;
}
cout << "NO"
<< "\n";
}
flush(cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
int n, q, head[100005], nxt[100005 << 1], to[100005 << 1], cnt = 0, dep[100005],
fa[100005][35];
int log2(int x) { return log(x) / log(2); }
void add(int x, int y) {
cnt++;
to[cnt] = y;
nxt[cnt] = head[x];
head[x] = cnt;
}
void dfs(int x) {
for (int i = 1; (1 << i) <= dep[x]; i++) {
fa[x][i] = fa[fa[x][i - 1]][i - 1];
}
for (int p = head[x]; p; p = nxt[p]) {
int v = to[p];
if (v == fa[x][0]) continue;
dep[v] = dep[x] + 1;
fa[v][0] = x;
dfs(v);
}
}
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
while (dep[x] != dep[y]) x = fa[x][log2(dep[x] - dep[y])];
if (x == y) return x;
for (int i = log2(dep[x]); i >= 0; i--) {
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
}
return fa[x][0];
}
int dis(int x, int y) { return dep[x] + dep[y] - 2 * dep[lca(x, y)]; }
int main() {
n = read();
for (int i = 1; i <= n - 1; i++) {
int x = read(), y = read();
add(x, y), add(y, x);
}
dfs(1);
q = read();
while (q--) {
int x = read(), y = read(), a = read(), b = read(), k = read();
int t1 = dis(a, b);
if (t1 <= k && (t1 & 1) == (k & 1)) {
printf("YES\n");
continue;
}
t1 = dis(a, x) + 1 + dis(y, b);
if (t1 <= k && (t1 & 1) == (k & 1)) {
printf("YES\n");
continue;
}
t1 = dis(a, y) + 1 + dis(x, b);
if (t1 <= k && (t1 & 1) == (k & 1)) {
printf("YES\n");
continue;
}
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:512000000")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
mt19937_64 gen(time(NULL));
ll const mod = 1e9 + 7;
namespace {
ll mul(ll a, ll b) {
ll val = a * b - (ll)((ld)a * b / mod) * mod;
if (val < 0) val += mod;
if (val >= mod) val -= mod;
return val;
}
ll poww(ll a, ll b) {
ll val = 1;
a %= mod;
while (b > 0) {
if (b % 2) val = mul(a, val);
a = mul(a, a);
b >>= 1;
}
return val % mod;
}
ll inv(ll a) { return poww(a, mod - 2); }
} // namespace
ll timer = 0;
ll const maxn = 3e5 + 5;
ll const maxk = 27;
vector<ll> g[maxn];
bool used[maxn];
ll d[maxn];
ll tin[maxn], tout[maxn];
ll up[maxn][maxk];
void dfs(ll u, ll p, ll dd) {
tin[u] = timer++;
up[u][0] = p;
for (ll i = 1; i < maxk; i++) {
up[u][i] = up[up[u][i - 1]][i - 1];
}
used[u] = 1, d[u] = dd;
for (ll v : g[u]) {
if (used[v]) continue;
dfs(v, u, dd + 1);
}
tout[u] = timer++;
}
bool is_ancestor(ll u, ll v) { return (tin[u] <= tin[v] && tin[v] <= tout[u]); }
ll lca(ll u, ll v) {
if (is_ancestor(u, v)) return u;
if (is_ancestor(v, u)) return v;
for (ll i = maxk - 1; i >= 0; i--) {
if (!is_ancestor(up[u][i], v)) {
u = up[u][i];
}
}
return up[u][0];
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
for (ll i = 0; i < n - 1; i++) {
ll u, v;
cin >> u >> v;
g[u].push_back(v), g[v].push_back(u);
}
ll root = 1;
dfs(root, root, 0);
ll q;
cin >> q;
while (q--) {
ll x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
ll lc = lca(a, b);
ll kek = d[a] - d[lc] + d[b] - d[lc];
bool f = false;
if (kek <= k && kek % 2 == k % 2) {
f = true;
}
ll lcax = lca(a, x), lcay = lca(a, y);
ll lcbx = lca(b, x), lcby = lca(b, y);
ll kek1 = d[a] + d[x] - 2 * d[lcax] + 1 + (d[b] + d[y] - 2 * d[lcby]);
if (kek1 <= k && kek1 % 2 == k % 2) {
f = true;
}
ll kek2 = d[a] + d[y] - 2 * d[lcay] + 1 + (d[b] + d[x] - 2 * d[lcbx]);
if (kek2 <= k && kek2 % 2 == k % 2) {
f = true;
}
if (f) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const unsigned long long nmax = 200002;
unsigned long long n, k, a[nmax], s[nmax], t[nmax], c[nmax], r = UINT64_MAX, A,
B;
int main() {
scanf("%llu%llu", &n, &k);
for (unsigned long long i = 1; i <= n; ++i) scanf("%llu", a + i);
sort(a + 1, a + n + 1);
for (unsigned long long i = 1; i <= n; ++i) s[i] = s[i - 1] + a[i];
for (unsigned long long i = n; i >= 1; --i) t[i] = t[i + 1] + a[i];
for (unsigned long long i = 1; i <= n; ++i) {
if (a[i] == a[i - 1])
c[i] = c[i - 1] + 1;
else
c[i] = 1;
if (c[i] >= k) {
puts("0");
return 0;
}
}
for (unsigned long long i = 1; i <= n; ++i) {
if (i >= k) {
A = i * a[i] - s[i] - (i - k);
r = min(r, A);
}
if (n - i + 1 >= k) {
B = t[i] - (n - i + 1) * a[i] - (n - i + 1 - k);
r = min(r, B);
}
r = min(r, i * a[i] - s[i] + t[i] - (n - i + 1) * a[i] - (n - k));
}
printf("%llu\n", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return !b ? a : gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T>
T sqr(T a) {
return a * a;
}
template <typename T>
T cube(T a) {
return a * a * a;
}
template <typename T>
inline void smin(T &a, T b) {
a = a < b ? a : b;
}
template <typename T>
inline void smax(T &a, T b) {
a = a > b ? a : b;
}
template <typename T>
inline void Int(T &n) {
n = 0;
int f = 1;
register int ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) n = (n << 3) + (n << 1) + ch - '0';
n = n * f;
}
vector<string> split(const string &s, char c) {
vector<string> v;
stringstream second(s);
string x;
while (getline(second, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << ", ";
err(++it, args...);
}
inline int in() {
int n;
scanf("%d", &n);
return n;
}
inline long long Lin() {
long long n;
scanf("%lld", &n);
return n;
}
inline double Din() {
double n;
scanf("%lf", &n);
return n;
}
inline int add(int a, int b, int mod) {
a += b;
return a >= mod ? a - mod : a;
}
inline int sub(int a, int b, int mod) {
a -= b;
return a < 0 ? a + mod : a;
}
inline int mul(int a, int b, int mod) { return (long long)a * b % mod; }
const int N = 2e5 + 5;
const int inf = (int)2e9 + 5;
const long long Inf = (long long)1e18 + 5;
const int mod = (int)1e9 + 7;
const long long Mod = (long long)1e9 + 7;
vector<int> b[N];
int solve() {
int n = in(), k = in();
vector<int> a(n);
for (int i = 0; i < n; i++) {
a[i] = in();
}
for (int i = 0; i < n; i++) {
int x = a[i], cur = 0;
while (x >= 1) {
b[x].push_back(cur);
x /= 2;
cur++;
}
}
long long ans = Inf;
for (int i = 0; i <= 2e5; i++) {
sort(b[i].begin(), b[i].end());
if ((int)b[i].size() >= k) {
long long cur = 0;
for (int j = 0; j < k; j++) {
cur += b[i][j];
}
smin(ans, cur);
}
}
printf("%lld\n", ans);
return 0;
}
int main() {
int test = 1, tc = 0;
while (test--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k;
cin >> n >> k;
vector<long long int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
map<long long int, long long int> bag;
for (long long int i = 0; i < n; i++) bag[v[i]]++;
vector<pair<long long int, long long int> > vpll;
vpll.push_back(pair<long long int, long long int>(0, 0));
for (auto it = bag.begin(); it != bag.end(); ++it) {
vpll.push_back(pair<long long int, long long int>(it->first, it->second));
}
vpll.push_back(pair<long long int, long long int>(1e18, 0));
sort(vpll.begin(), vpll.end());
vector<long long int> costL(vpll.size() + 2, 0), costR(vpll.size() + 2, 0);
vector<long long int> countL(vpll.size() + 2, 0), countR(vpll.size() + 2, 0);
for (int i = 1; i < vpll.size() - 1; i++) {
int index = i;
countL[index + 1] = countL[index] + vpll[index].second;
costL[index] =
costL[index - 1] +
countL[index] * abs(vpll[index].first - vpll[index - 1].first);
}
for (int i = 1; i < vpll.size() - 1; i++) {
int index = vpll.size() - i;
countR[index - 1] = countR[index] + vpll[index].second;
costR[index] =
costR[index + 1] +
countR[index] * abs(vpll[index].first - vpll[index + 1].first);
}
long long int ans = 1e18;
for (int i = 1; i < vpll.size() - 1; i++) {
long long int qtyA = countL[i];
long long int qtyB = countR[i];
long long int cA = costL[i - 1];
long long int cB = costR[i + 1];
long long int diffA = abs(vpll[i].first - vpll[i - 1].first);
long long int diffB = abs(vpll[i].first - vpll[i + 1].first);
for (int j = 0; j < 2; j++) {
long long int tmp = 0;
long long int req = max(0ll, k - vpll[i].second);
long long int rmA = min(qtyA, req);
long long int rmB = req - rmA;
if (rmA) tmp += cA + rmA + (diffA - 1ll) * qtyA;
if (rmB) tmp += cB + rmB + (diffB - 1ll) * qtyB;
swap(qtyA, qtyB);
swap(cA, cB);
swap(diffA, diffB);
ans = min(ans, tmp);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class n, class second>
ostream &operator<<(ostream &p, pair<n, second> x) {
return p << "<" << x.first << ", " << x.second << ">";
}
template <class n>
auto operator<<(ostream &p, n y) ->
typename enable_if<!is_same<n, string>::value,
decltype(y.begin(), p)>::type {
long long o = 0;
p << "{";
for (auto c : y) {
if (o++) p << ", ";
p << c;
}
return p << "}";
}
void dor() { cerr << '\n'; }
template <class n, class... second>
void dor(n p, second... y) {
cerr << p << " ";
dor(y...);
}
template <class n, class second>
void mini(n &p, second y) {
if (p > y) p = y;
}
template <class n, class second>
void maxi(n &p, second y) {
if (p < y) p = y;
}
const long long MXN = 2e5 + 5;
long long t[MXN];
long long sum[MXN];
long long sum_seg(long long a, long long b) { return sum[b] - sum[a - 1]; }
void solve() {
long long n, k;
cin >> n >> k;
map<long long, long long> cnt;
vector<long long> V;
for (long long i = (1); i <= (long long)(n); ++i) {
long long a;
cin >> a;
cnt[a]++;
t[i] = a;
if (cnt[a] >= k) {
cout << 0 << '\n';
return;
}
}
long long res = 1e18;
long long mi = cnt.begin()->first;
long long mx = (--cnt.end())->first;
long long ile = 0;
long long cost = 0;
long long prev = mi;
for (auto i : cnt) {
cost += (long long)ile * (i.first - prev);
ile += i.second;
if (ile >= k) {
mini(res, cost);
}
prev = i.first;
}
ile = 0;
cost = 0;
prev = mx;
for (auto iter = cnt.rbegin(); iter != cnt.rend(); ++iter) {
auto i = *iter;
cost += (long long)ile * (prev - i.first);
ile += i.second;
if (ile >= k) {
mini(res, cost);
}
prev = i.first;
}
sort(t + 1, t + n + 1);
for (long long i = (1); i <= (long long)(n); ++i) {
sum[i] = sum[i - 1] + t[i];
}
for (long long i = (1); i <= (long long)(n); ++i) {
long long cnt_left = i;
long long cnt_right = n - i;
if (t[i] == t[i + 1]) continue;
long long cost = (long long)t[i] * (cnt_left)-sum_seg(1, i) +
sum_seg(i + 1, n) - ((long long)t[i] + 1) * cnt_right;
mini(res, cost + max(0LL, k - max(cnt_right, cnt_left)));
}
for (long long i = (2); i <= (long long)(n); ++i) {
long long cnt_left = i - 1;
long long cnt_right = n - i + 1;
if (t[i - 1] == t[i]) continue;
long long cost = (long long)(t[i] - 1) * (cnt_left)-sum_seg(1, i - 1) +
sum_seg(i, n) - ((long long)t[i]) * cnt_right;
mini(res, cost + max(0LL, k - max(cnt_right, cnt_left)));
}
for (long long i = (1); i <= (long long)(n); ++i) {
long long cnt_left = i;
long long cnt_right = n - i;
long long cost = (long long)t[i] * (cnt_left)-sum_seg(1, i) +
sum_seg(i + 1, n) - (long long)t[i] * cnt_right;
mini(res, cost);
}
long long rowne_lewo = 1;
for (long long i = (1); i <= (long long)(n); ++i) {
long long cnt_right = n - i;
if (t[i] == t[i + 1]) {
rowne_lewo++;
continue;
}
long long cost = sum_seg(i + 1, n) - (t[i] + 1) * cnt_right;
if (rowne_lewo + cnt_right >= k) mini(res, cost + max(0LL, k - rowne_lewo));
rowne_lewo = 1;
}
long long rowne_prawo = 1;
for (long long i = (n); i >= (long long)(1); --i) {
long long cnt_left = i - 1;
if (t[i] == t[i - 1]) {
rowne_prawo++;
continue;
}
long long cost = (t[i] - 1) * cnt_left - sum_seg(1, i - 1);
if (rowne_prawo + cnt_left >= k)
mini(res, cost + max(0LL, k - rowne_prawo));
rowne_prawo = 1;
}
cout << res << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[400000];
int initialD[400000];
vector<vector<int> > vecc;
vector<int> toint[400000];
int main() {
int n, k;
cin >> n >> k;
vecc.resize(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
initialD[arr[i]]++;
int tem = arr[i];
while (tem) {
vecc[i].push_back(tem);
tem /= 2;
}
}
for (int i = 0; i < n; i++) {
int sez = vecc[i].size();
for (int j = 0; j < sez; j++) {
toint[vecc[i][j]].push_back(j);
}
}
long long ans = 1000000000;
for (int i = 0; i < 200001; i++) {
sort(toint[i].begin(), toint[i].end());
int sez = toint[i].size();
if (sez >= k) {
long long temp = 0;
for (int j = 0; j < k; j++) {
temp += toint[i][j];
}
ans = min(ans, temp);
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF64 = 1e18;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (auto &it : a) cin >> it;
sort(a.begin(), a.end());
vector<pair<int, int>> cnt;
for (auto it : a) {
if (cnt.empty() || cnt.back().first != it) {
cnt.push_back({it, 1});
} else {
++cnt.back().second;
}
}
vector<long long> prefsum, sufsum;
vector<int> prefcnt, sufcnt;
for (int i = 0; i < int(cnt.size()); ++i) {
long long cursum = cnt[i].first * 1ll * cnt[i].second;
int curcnt = cnt[i].second;
if (prefsum.empty()) {
prefsum.push_back(cursum);
prefcnt.push_back(curcnt);
} else {
prefsum.push_back(prefsum.back() + cursum);
prefcnt.push_back(prefcnt.back() + curcnt);
}
}
for (int i = int(cnt.size()) - 1; i >= 0; --i) {
long long cursum = cnt[i].first * 1ll * cnt[i].second;
int curcnt = cnt[i].second;
if (sufsum.empty()) {
sufsum.push_back(cursum);
sufcnt.push_back(curcnt);
} else {
sufsum.push_back(sufsum.back() + cursum);
sufcnt.push_back(sufcnt.back() + curcnt);
}
}
reverse(sufsum.begin(), sufsum.end());
reverse(sufcnt.begin(), sufcnt.end());
long long ans = INF64;
for (int i = 0; i < int(cnt.size()); ++i) {
int cur = max(0, k - cnt[i].second);
int needl = 0;
if (i > 0) needl = min(cur, prefcnt[i - 1]);
int needr = max(0, cur - needl);
long long res = 0;
if (i > 0 && needl > 0) {
res += prefcnt[i - 1] * 1ll * (cnt[i].first - 1) - prefsum[i - 1];
res += needl;
}
if (i + 1 < int(cnt.size()) && needr > 0) {
res += sufsum[i + 1] - sufcnt[i + 1] * 1ll * (cnt[i].first + 1);
res += needr;
}
ans = min(ans, res);
needr = 0;
if (i + 1 < int(cnt.size())) needr = min(cur, sufcnt[i + 1]);
needl = max(0, cur - needr);
res = 0;
if (i > 0 && needl > 0) {
res += prefcnt[i - 1] * 1ll * (cnt[i].first - 1) - prefsum[i - 1];
res += needl;
}
if (i + 1 < int(cnt.size()) && needr > 0) {
res += sufsum[i + 1] - sufcnt[i + 1] * 1ll * (cnt[i].first + 1);
res += needr;
}
ans = min(ans, res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[200010];
long long pre[200010];
long long suf[200010];
signed main() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i];
for (long long i = n; i >= 1; i--) suf[i] = suf[i + 1] + a[i];
long long ans = a[k] * k - pre[k];
ans = min(ans, suf[n - k + 1] - a[n - k + 1] * k);
for (long long i = 1; i <= n; i++)
if (a[i + 1] != a[i]) {
long long x = i;
while (a[x] == a[i]) x--;
long long l = (a[i] - 1) * x - pre[x];
long long r = suf[i + 1] - (n - i) * (a[i] + 1);
long long need = k - (i - x);
ans = min(ans, l + r + need);
if (k <= i) ans = min(ans, l + need);
if (need <= n - i) ans = min(ans, r + need);
if (need <= 0) {
printf("0");
return 0;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20000005;
int n, k, x, t, a, b, m;
string s;
vector<int> v;
void solve() {
cin >> n >> k;
map<int, pair<int, int>> cnt;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
cnt[x] = {cnt[x].first + 1, 0};
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
int num = v[i];
int cur = 0;
while (num > 0) {
cur++;
num /= 2;
int count = cnt[num].first;
int moves = cnt[num].second;
if (count < k) cnt[num] = {count + 1, moves + cur};
}
}
int mn = 1e9;
for (auto m : cnt) {
if (m.second.first >= k) mn = min(m.second.second, mn);
}
cout << mn;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
const long long M = 1e9 + 7;
const long long Mod = 998244353;
long long _, i, j, k, n, m, t, T, p, q, len, u, v, w, st, en, x, y, ma, mi, num,
flag, res, cnt, ans, tmp1, tmp2, nex;
long long a[N], s1[N], s2[N];
map<long long, long long> l, r;
signed main() {
ios::sync_with_stdio(false);
long long t = 1;
while (t--) {
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++)
if (!l[a[i]]) l[a[i]] = i;
for (i = n; i >= 1; i--)
if (!r[a[i]]) r[a[i]] = i;
for (i = 1; i <= n; i++) s1[i] = s1[i - 1] + a[i];
for (i = n; i >= 1; i--) s2[i] = s2[i + 1] + a[i];
ans = 1e18;
for (i = 1; i <= n; i++) {
if (r[a[i]] - l[a[i]] + 1 >= k) {
ans = 0;
break;
}
tmp1 = (a[i] - 1) * (l[a[i]] - 1) - s1[l[a[i]] - 1];
tmp2 = s2[r[a[i]] + 1] - (a[i] + 1) * (n - r[a[i]]);
if (i >= k) ans = min(ans, tmp1 + k - r[a[i]] + l[a[i]] - 1);
if (n - i + 1 >= k) ans = min(ans, tmp2 + k - (r[a[i]] - l[a[i]] + 1));
ans = min(ans, tmp1 + tmp2 + k - (r[a[i]] - l[a[i]] + 1));
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[200010], f[200010], l, r, mid, x, y;
int main() {
scanf("%I64d%I64d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + n + 1);
a[0] = a[1];
a[n + 1] = a[n];
f[1] = a[1];
long long ans = (long long)1e17;
for (int i = 2; i <= n; i++) f[i] = f[i - 1] + a[i];
for (int i = 1; i <= n; i++) {
x = y = 0;
if (i + m - 1 <= n) {
x += f[i + m - 1] - f[i - 1] - a[i] * m;
if (a[i + m - 1] > a[i])
x += f[n] - f[i + m - 1] - (a[i] + 1) * (n - i - m + 1);
} else {
x += (f[n] - f[i - 1]) - a[i] * (n - i + 1);
x += a[i] * (i - n + m) - (f[i] - f[n - m]);
if (a[n - m + 1] < a[i]) x += (a[i] - 1) * (n - m) - f[n - m];
}
if (i - m + 1 >= 1) {
y += a[i] * m - (f[i] - f[i - m]);
if (a[i - m + 1] < a[i]) y += (a[i] - 1) * (i - m) - (f[i - m]);
} else {
y += a[i] * (i) - (f[i]);
y += (f[m] - f[i - 1]) - a[i] * (m - i + 1);
if (a[m] > a[i]) y += f[n] - f[m] - (a[i] + 1) * (n - m);
}
ans = min(ans, min(x, y));
}
if (m == 1) ans = 0;
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int a[maxn];
vector<int> v[maxn];
int main() {
int n, k, i, j;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
int cnt = 0;
while (a[i] != 0) {
v[a[i]].push_back(cnt);
cnt++;
a[i] /= 2;
}
}
int ans = 1000000;
for (i = 0; i < maxn; i++) {
if (v[i].size() < k) continue;
sort(v[i].begin(), v[i].end());
int tmp = 0;
for (j = 0; j < k; j++) tmp += v[i][j];
ans = min(ans, tmp);
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long LINF = 1LL * INF * INF;
const int MAX = 100010;
const long double PI = acos(-1.);
const double EPS = 1e-6;
long long mod = 1000LL * 1000 * 1000 + 7;
int arr[200 * 1000 + 7];
vector<int> tmp[200 * 1000 + 7];
int main() {
ios_base::sync_with_stdio(0);
double startClock = clock();
int n, k;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
int cnt = 0;
while (arr[i]) {
tmp[arr[i]].push_back(cnt);
arr[i] /= 2;
cnt++;
}
tmp[arr[i]].push_back(cnt);
}
int ans = INF;
for (int i = 0; i < 200 * 1000 + 7; ++i) {
if ((int)tmp[i].size() >= k) {
sort(tmp[i].begin(), tmp[i].end());
int sum = 0;
for (int j = 0; j < k; ++j) sum += tmp[i][j];
ans = min(ans, sum);
}
}
cout << ans;
cerr << endl << (clock() - startClock) / CLOCKS_PER_SEC << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxx = 2e5 + 10;
long long ans = 1e18;
int a[maxx];
int num[maxx], cnt[maxx];
long long ad[maxx], re[maxx], le[maxx], mo[maxx];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int e = 0, k = 0;
for (int i = 0; i < n; i++) {
e++;
if (a[i] != a[i + 1]) {
num[k] = a[i];
cnt[k++] = e;
e = 0;
}
}
for (int i = 1; i < k; i++) {
int M = num[i] - num[i - 1];
ad[i] = ad[i - 1] + le[i - 1] * M + cnt[i - 1] * (M - 1);
le[i] = le[i - 1] + cnt[i - 1];
}
for (int i = k - 2; i >= 0; i--) {
int M = num[i + 1] - num[i];
re[i] = re[i + 1] + mo[i + 1] * M + cnt[i + 1] * (M - 1);
mo[i] = mo[i + 1] + cnt[i + 1];
}
for (int i = 0; i < k; i++) {
if (cnt[i] >= m) {
cout << 0 << endl;
return 0;
}
int cha = m - cnt[i];
if (i > 0 && i < k - 1) ans = min(ans, ad[i] + re[i] + cha);
if (i > 0 && le[i] >= cha) ans = min(ans, ad[i] + cha);
if (i < k - 1 && mo[i] >= cha) ans = min(ans, re[i] + cha);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
map<int, vector<int>> vals;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int temp, counter = 0;
cin >> temp;
vals[temp].push_back(0);
while (temp > 0) {
temp /= 2;
counter++;
vals[temp].push_back(counter);
}
}
int answer = 1000000000;
for (map<int, vector<int>>::iterator it = vals.begin(); it != vals.end();
it++) {
int posan = 0;
if (it->second.size() >= k) {
sort(it->second.begin(), it->second.end());
for (int i = 0; i < k; i++) {
posan += it->second[i];
}
if (posan < answer) answer = posan;
}
}
cout << answer;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i1, i2, i3, i4, t1, t2, t3, l1, ans;
long long n, k, ac[200050][25], s[200050], c[200050], total[200050];
vector<long long> v;
int main() {
cin >> n >> k;
for (i1 = 0; i1 < n; i1++) {
for (i2 = 0; i2 < 25; i2++) ac[i1][i2] = -1;
}
for (i1 = 1; i1 <= n; i1++) {
cin >> t1;
v.push_back(t1);
}
sort(v.begin(), v.end());
for (i1 = 0; i1 < n; i1++) {
t1 = v[i1];
s[i1] = round(log(t1) / log(2) + 0.5);
for (i2 = s[i1]; i2 >= 0; i2--) {
ac[i1][i2] = t1;
t1 /= 2;
}
}
for (i1 = 0; i1 < n; i1++) {
for (i2 = 0; i2 < 25; i2++) {
if (ac[i1][i2] == -1) continue;
c[ac[i1][i2]]++;
if (c[ac[i1][i2]] <= k) total[ac[i1][i2]] += s[i1] - i2;
}
}
ans = 100000000;
for (i1 = 1; i1 < 200050; i1++) {
if (c[i1] >= k) ans = min(ans, total[i1]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 10;
struct Node {
long long val, num;
} node[MAXN];
long long precnt[MAXN], sufcnt[MAXN];
long long presum[MAXN], sufsum[MAXN];
long long val[MAXN];
int main() {
long long n, k;
scanf("%lld %lld", &n, &k);
for (long long i = 1; i <= n; i++) scanf("%lld", &val[i]);
long long num = 1;
sort(val + 1, val + n + 1);
node[1].val = val[1];
node[1].num = 1;
for (long long i = 2; i <= n; i++) {
if (val[i] != val[i - 1]) {
node[++num].val = val[i];
node[num].num = 1;
} else {
node[num].num++;
}
}
for (long long i = 1; i <= num; i++) {
precnt[i] = precnt[i - 1] + node[i].num;
presum[i] = presum[i - 1] + node[i].num * node[i].val;
}
for (long long i = num; i >= 1; i--) {
sufcnt[i] = sufcnt[i + 1] + node[i].num;
sufsum[i] = sufsum[i + 1] + node[i].num * node[i].val;
}
long long res = 1e18;
for (long long i = 1; i <= num; i++) {
long long need = max((long long)0, k - node[i].num);
long long needl = min(need, precnt[i - 1]);
long long needr = max((long long)0, need - needl);
long long mvl =
needl ? (needl + (node[i].val - 1) * precnt[i - 1] - presum[i - 1]) : 0;
long long mvr =
needr ? (needr + sufsum[i + 1] - (node[i].val + 1) * sufcnt[i + 1]) : 0;
res = min(res, mvl + mvr);
}
for (long long i = num; i >= 1; i--) {
long long need = max((long long)0, k - node[i].num);
long long needr = min(need, sufcnt[i + 1]);
long long needl = max((long long)0, need - needr);
long long mvr =
needr ? (needr + sufsum[i + 1] - (node[i].val + 1) * sufcnt[i + 1]) : 0;
long long mvl =
needl ? (needl + (node[i].val - 1) * precnt[i - 1] - presum[i - 1]) : 0;
res = min(res, mvl + mvr);
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
#pragma optimize GCC("O3")
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> a(n);
map<long long, long long> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a.begin(), a.end());
long long i = 0;
map<long long, long long> pfc;
pfc[a[i]] = 0;
map<long long, long long> pfs;
pfs[a[i]] = 0;
vector<pair<long long, long long> > v;
for (pair<long long, long long> p : m) {
v.push_back(p);
while (p.first != a[i]) i++;
if (i == 0) continue;
pfc[a[i]] = pfc[a[i - 1]] + m[a[i - 1]];
pfs[a[i]] = pfs[a[i - 1]] + a[i - 1] * m[a[i - 1]];
}
reverse(v.begin(), v.end());
i = n - 1;
map<long long, long long> sfc;
sfc[a[i]] = 0;
map<long long, long long> sfs;
sfs[a[i]] = 0;
for (pair<long long, long long> p : v) {
while (p.first != a[i]) i--;
if (i == n - 1) continue;
sfc[a[i]] = sfc[a[i + 1]] + m[a[i + 1]];
sfs[a[i]] = sfs[a[i + 1]] + a[i + 1] * m[a[i + 1]];
}
long long ans = 1e18;
for (int i = 0; i < v.size(); i++) {
long long ne = max(0ll, k - v[i].second);
if (ne == 0) {
ans = 0ll;
break;
}
long long nel = min(ne, pfc[v[i].first]);
long long ner = ne - nel;
long long lsum = (v[i].first - 1) * pfc[v[i].first] - pfs[v[i].first] + nel;
long long rsum = 0;
if (ner > 0)
rsum = sfs[v[i].first] - (v[i].first + 1) * sfc[v[i].first] + ner;
ans = min(ans, lsum + rsum);
ner = min(ne, sfc[v[i].first]);
nel = ne - ner;
rsum = sfs[v[i].first] - (v[i].first + 1) * sfc[v[i].first] + ner;
if (nel > 0)
lsum = (v[i].first - 1) * pfc[v[i].first] - pfs[v[i].first] + nel;
else
lsum = 0;
ans = min(ans, lsum + rsum);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long num = 0;
bool f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
f = (ch == '-');
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
num = (num << 1) + (num << 3) + ch - '0';
ch = getchar();
}
return f ? -num : num;
}
long long n, k, t, ans;
long long a[222222], sum[222222], c[222222];
const long long INF = (1ll << 62) - 1ll;
int main() {
n = read(), k = read();
ans = INF;
t = 1ll;
for (int i = 1; i <= n; i++) a[i] = read();
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
c[i] = (a[i] == a[i - 1]) ? c[i - 1] + 1 : 1;
if (c[i] == k) {
puts("0");
return 0;
}
}
while (t <= n) {
long long tmp1 = INF, tmp2 = INF, tmp3 = INF;
if (t >= k) tmp1 = a[t] * t - sum[t] - (t - k);
if (n - t + 1 >= k)
tmp2 = sum[n] - sum[t - 1] - a[t] * (n - t + 1) - (n - t + 1 - k);
tmp3 =
a[t] * t - sum[t] + sum[n] - sum[t - 1] - a[t] * (n - t + 1) - (n - k);
ans = min(ans, min(tmp1, min(tmp2, tmp3)));
t++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n;
cin >> n >> k;
vector<pair<long long int, long long int> > a;
vector<long long int> tmp(n);
for (int i = 0; i < n; i++) {
cin >> tmp[i];
}
sort(tmp.begin(), tmp.end());
long long int ln = 0;
for (int i = 0; i < n; i++) {
if (ln != tmp[i]) {
pair<int, long long int> tt(tmp[i], 1);
a.push_back(tt);
ln = tmp[i];
} else {
(a[a.size() - 1].second)++;
}
}
vector<long long int> prefcnt(a.size()), prefsum(a.size()), sufsum(a.size()),
sufcnt(a.size());
prefcnt[0] = 0;
prefsum[0] = 0;
sufsum[a.size() - 1] = 0;
sufsum[a.size() - 1] = 0;
long long int as = a[0].first * a[0].second, ac = a[0].second;
for (int i = 1; i < a.size(); i++) {
prefcnt[i] = ac;
prefsum[i] = as;
as += a[i].first * a[i].second;
ac += a[i].second;
}
as = a[a.size() - 1].first * a[a.size() - 1].second;
ac = a[a.size() - 1].second;
for (int i = a.size() - 2; i >= 0; i--) {
sufcnt[i] = ac;
sufsum[i] = as;
as += a[i].first * a[i].second;
ac += a[i].second;
}
long long int cost = 100000000000000;
for (int i = 0; i < a.size(); i++) {
if (a[i].second >= k) {
cost = min((long long int)0, cost);
break;
} else {
long long int c1, c2;
if (prefcnt[i] + a[i].second < k) {
c1 = a[i].first * prefcnt[i] - prefsum[i];
c1 += sufsum[i] - (a[i].first + 1) * sufcnt[i] +
(k - prefcnt[i] - a[i].second);
} else {
c1 = (a[i].first - 1) * prefcnt[i] - prefsum[i] + (k - a[i].second);
}
if (sufcnt[i] + a[i].second < k) {
c2 = sufsum[i] - a[i].first * sufcnt[i];
c2 += (a[i].first - 1) * prefcnt[i] - prefsum[i] +
(k - a[i].second - sufcnt[i]);
} else {
c2 = sufsum[i] - (a[i].first + 1) * sufcnt[i] + (k - a[i].second);
}
c1 = min(c1, c2);
cost = min(c1, cost);
}
}
cout << cost;
}
|
#include <bits/stdc++.h>
int dx[] = {0, -1, 0, 1, -1, 1, -1, 1};
int dy[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int MOD = 1e9 + 7, N = 2e5 + 5, oo = 1e9;
const double pi = acos(-1);
using namespace std;
long long freq[N], f[N][100];
void solve(long long n) {
long long cnt = 0;
while (n >= 1) {
f[n][cnt]++;
n /= 2;
cnt++;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int k, n;
cin >> n >> k;
long long arr[n + 5];
for (int i = 0; i < n; i++) {
cin >> arr[i];
freq[arr[i]]++;
solve(arr[i]);
}
sort(arr, arr + n);
long long final = 1e18;
for (int i = 1; i < N; i++) {
long long add = 0;
long long ans = 0;
for (int j = 0; j < 50; j++) {
ans += j * min(f[i][j], k - add);
add += f[i][j];
if (add >= k) {
final = min(final, ans);
break;
}
}
}
cout << final;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
void setmax(T& a, T b) {
a = max(a, b);
};
template <typename T>
void setmin(T& a, T b) {
a = min(a, b);
};
template <typename T>
bool in(T v, T lo, T hi) {
return lo <= v && v <= hi;
};
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 10;
int n, k;
int a[N];
map<int, long long> lcost;
map<int, long long> rcost;
map<int, int> lnum;
map<int, int> rnum;
map<int, int> cnt;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
int num = 0;
long long cost = 0;
int at = 0;
vector<pair<int, int>> rev;
for (auto& [x, mult] : cnt) {
rev.push_back({x, mult});
cost += ((x - 1) - at) * 1ll * num;
at = x - 1;
lcost[x] = cost;
lnum[x] = num;
cost += num;
at = x;
num += mult;
}
reverse(rev.begin(), rev.end());
{
int num = 0;
long long cost = 0;
int at = 1e9 + 5;
for (auto& [x, mult] : rev) {
cost += (at - (x + 1)) * 1ll * num;
at = x + 1;
rcost[x] = cost;
rnum[x] = num;
cost += num;
at = x;
num += mult;
}
}
long long ans = 1e18;
for (auto& [x, mult] : cnt) {
if (mult >= k) {
setmin(ans, 0ll);
}
if (mult + rnum[x] >= k) {
setmin(ans, rcost[x] + max(0, k - mult));
}
if (mult + lnum[x] >= k) {
setmin(ans, lcost[x] + max(0, k - mult));
}
setmin(ans, lcost[x] + rcost[x] + max(0, k - mult));
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace myrand {
mt19937 mt(chrono::system_clock::now().time_since_epoch() /
chrono::microseconds(1));
long long Int(long long l, long long r) {
return uniform_int_distribution<long long>(l, r)(mt);
}
} // namespace myrand
using namespace myrand;
auto ss = chrono::system_clock::now();
double remain_time() {
auto en = chrono::system_clock::now();
return (chrono::duration_cast<chrono::nanoseconds>(en - ss).count() * 1e-9);
}
long long a[200005];
long long pre_sum[200005];
long long sum[200005];
long long n, k, Left, Right;
long long f(int x) {
long long total = a[n] * n;
long long kbe = lower_bound(a + 1, a + 1 + n, x) - a;
if (a[kbe] >= x) kbe--;
long long klon = upper_bound(a + 1, a + 1 + n, x) - a;
long long kkk = (klon - 1) - kbe + (a[kbe] == x);
long long tt = x * (kbe)-pre_sum[kbe];
long long t1 = sum[klon] - x * (n - klon + 1);
kkk = k - kkk;
klon = n - klon + 1;
if (kkk <= 0) return 0;
if (klon >= kkk)
total = min(total, t1 - (klon - kkk));
else
total = min(total, t1 + tt - (kbe - (kkk - klon)));
if (kbe >= kkk)
total = min(total, tt - (kbe - kkk));
else
total = min(total, (tt + t1 - (klon - (kkk - kbe))));
return total;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pre_sum[i] = 0;
sum[i] = 0;
}
pre_sum[0] = pre_sum[n + 1] = 0;
sum[0] = sum[n + 1] = 0;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) pre_sum[i] = pre_sum[i - 1] + a[i];
for (int i = n; i > 0; i--) sum[i] = sum[i + 1] + a[i];
long long kq = a[n] * n;
for (int i = 1; i <= n; i++) {
long long ttt = f(a[i]);
kq = min(kq, ttt);
}
cout << kq;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct rge {
T b, e;
};
template <class T>
rge<T> range(T i, T j) {
return rge<T>{i, j};
}
template <class T>
auto dud(T *x) -> decltype(cout << *x, 0);
template <class T>
char dud(...);
struct debug {
template <class T>
debug &operator<<(const T &) {
return *this;
}
};
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
const int dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
const ld eps = (ld)1e-9;
const ll MOD = (ll)1e9 + 7;
const ld PI = acos(-1);
const int N = (int)5e5 + 5;
template <class T>
T gcd(T x, T y) {
return (y == 0) ? x : gcd(y, x % y);
}
template <class T>
void mini(T &a, T b) {
a = min(a, b);
}
template <class T>
void maxi(T &a, T b) {
a = max(a, b);
}
template <class T>
T mul(T x, T y) {
return (x * y) % MOD;
}
template <class T>
inline T power(T a, T b) {
T res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res % MOD;
}
template <class T>
inline T modInverse(T n) {
return power(n, MOD - 2, MOD) % MOD;
}
template <class T>
inline void add(T &x, T y) {
x += y;
if (x >= MOD) x -= MOD;
}
template <class T>
inline void sub(T &x, T y) {
x -= y;
if (x < 0) x += MOD;
}
template <class T>
inline T power(T a, T b, T mod) {
T res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res % mod;
}
template <class T>
inline T modInverse(T n, T p) {
return power(n, p - 2, p) % p;
}
template <class T, class U>
string to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
bool is_digit(char x) { return x >= '0' && x <= '9'; }
bool is_upper(char x) { return x >= 'A' && x <= 'Z'; }
bool is_lower(char x) { return x >= 'a' && x <= 'z'; }
bool is_char(char x) {
return x == '!' || x == '@' || x == '#' || x == '$' || x == '%' || x == '&';
}
template <class T>
inline bool isPrime(T n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (ll i = 5; i * i <= n; i += 6) {
if ((n % i == 0) || (n % (i + 2) == 0)) {
return false;
}
}
return true;
}
inline void to_upper(string &s) {
transform((s).begin(), (s).end(), s.begin(), ::toupper);
}
inline void to_lower(string &s) {
transform((s).begin(), (s).end(), s.begin(), ::tolower);
}
class D2EqualizingByDivisionHardVersion {
public:
void solve(std::istream &cin, std::ostream &cout) {
int n, k, x;
cin >> n >> k;
map<int, vi> g;
for (int i = 0; i < n; ++i) {
cin >> x;
for (int j = 0; x; j++, x /= 2) {
g[x].push_back(j);
}
}
int ans = INT_MAX;
for (auto &[xx, mp] : g) {
if ((int)(mp).size() >= k) {
sort((mp).begin(), (mp).end());
int sum = 0;
for (int j = 0; j < k; ++j) {
sum += mp[j];
}
mini(ans, sum);
}
}
cout << ans << endl;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(12);
D2EqualizingByDivisionHardVersion solver;
std::istream &in(std::cin);
std::ostream &out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using vi = vector<long long>;
using mi = map<long long, long long>;
using pi = pair<long long, long long>;
const long long N = 100005;
const long long MOD = 1e9 + 7;
const long long inf = 1e18 + 1;
void solve() {
long long n, k, ans = inf;
cin >> n >> k;
long long a[n], pref[n + 1];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
pref[0] = 0;
for (long long i = 0; i < n; i++) pref[i + 1] = pref[i] + a[i];
for (long long i = 0; i < n; i++) {
long long x = a[i];
long long lc = lower_bound(a, a + n, x) - a;
long long mc = n - (upper_bound(a, a + n, x) - a);
long long ls = pref[lc];
long long ms = pref[n] - pref[n - mc];
long long req = k - (n - lc - mc);
if (req <= 0) {
ans = 0;
break;
}
if (mc >= req) {
ans = min(ans, req + ms - mc * (x + 1));
}
if (lc >= req) {
ans = min(ans, req + lc * (x - 1) - ls);
}
ans = min(ans, req + ms - mc * (x + 1) + lc * (x - 1) - ls);
}
cout << ans << '\n';
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[200005], sh[200005], sp[200005];
int main() {
long long i, j, k, n, m, p, q, t, cnt = 0, mn;
scanf("%lld", &n);
scanf("%lld", &k);
for (i = 0; i < n; i++) {
scanf("%lld", &arr[i]);
;
}
sort(arr, arr + n);
for (i = 0; i < n; i++) {
cnt = 0;
while (1) {
sh[arr[i]]++;
if (sh[arr[i]] <= k) sp[arr[i]] += cnt;
if (!arr[i]) break;
arr[i] /= 2;
cnt++;
}
}
mn = sp[0];
for (i = 0; i <= 200005; i++) {
if (sh[i] >= k && sp[i] < mn) mn = sp[i];
}
cout << mn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long a[maxn];
long long sum[maxn];
inline long long getsum(int l, int r) {
if (l > r)
return 0ll;
else
return sum[r] - sum[l - 1];
}
int main(void) {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
long long res = 1e18;
for (int i = 1; i <= n; i++) {
int j = i;
while (j + 1 <= n && a[j + 1] == a[i]) j++;
int d1 = i - 1;
int d2 = j - i + 1;
int d3 = n - j;
long long s1, s2, t;
if (d2 >= k) {
res = 0;
break;
}
if (d1 + d2 >= k) {
s1 = getsum(1, i - 1);
t = 1ll * d1 * (a[i] - 1) - s1;
res = min(res, t + (k - d2));
}
if (d3 + d2 >= k) {
s2 = getsum(j + 1, n);
t = s2 - 1ll * d3 * (a[i] + 1);
res = min(res, t + (k - d2));
}
s1 = getsum(1, i - 1);
long long t1 = 1ll * d1 * (a[i] - 1) - s1;
s2 = getsum(j + 1, n);
long long t2 = s2 - 1ll * d3 * (a[i] + 1);
res = min(res, t1 + t2 + (k - d2));
i = j;
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
long long n, k, a[N], pre[N], suf[N], ans = 1e18;
map<long long, long long> mp;
signed main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
}
for (long long i = n; i >= 1; --i) {
suf[i] = suf[i + 1] + a[i];
}
for (long long i = 1; i <= n; i++) mp[a[i]]++;
for (auto i : mp)
if (i.second >= k) {
cout << 0 << endl;
return 0;
}
for (long long i = 1; i <= n; i++) {
long long x = a[i];
long long e =
upper_bound(a + 1, a + n + 1, x) - lower_bound(a + 1, a + n + 1, x);
long long g = n - (upper_bound(a + 1, a + n + 1, x) - a) + 1;
long long l = lower_bound(a + 1, a + n + 1, x) - a - 1;
long long sg = suf[n - g + 1];
long long sl = pre[l];
long long tmp = sg - g * x + l * x - sl - (n - k);
ans = min(ans, tmp);
if (n - l >= k) {
long long tx = sg - g * x - (n - l - k);
ans = min(ans, tx);
}
if (n - g >= k) {
long long tx = l * x - sl - (n - g - k);
ans = min(ans, tx);
}
}
cout << max(0ll, ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[202202];
pair<int, int> p[202202];
int lp;
long long int calc1(int fr, int step) {
long long int res = 0LL;
int cnt = p[fr].second;
for (int i = fr; i < lp && i >= 0; i += step) {
int cur = i, nxt = i + step;
res += 1LL * cnt * (labs(p[cur].first - p[nxt].first) - 1);
if (cnt + p[nxt].second < k) {
res += cnt;
cnt += p[nxt].second;
} else {
res += k - p[nxt].second;
break;
}
}
return res;
}
long long int calc2(int l, int r) {
long long int res = 0LL;
int lef = 0, rig = 0;
for (int i = 0; i < lp; i++) {
if (p[i].first <= l) {
res += 1LL * (l - p[i].first) * p[i].second;
lef += p[i].second;
} else {
res += 1LL * (p[i].first - r) * p[i].second;
rig += p[i].second;
}
}
return res + k - max(lef, rig);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
lp = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (i > 0 && a[i] != a[i - 1]) {
p[lp++] = make_pair(a[i - 1], cnt);
cnt = 1;
} else
cnt++;
}
p[lp++] = make_pair(a[n - 1], cnt);
bool chk = false;
for (int i = 0; i < lp && !chk; i++) {
if (p[i].second >= k) chk = true;
}
if (chk) {
puts("0");
return 0;
}
long long int ans = calc1(0, 1);
ans = min(ans, calc1(lp - 1, -1));
if (n % 2 == 0)
ans = min(ans, calc2(a[n / 2] - 1, a[n / 2]));
else {
ans = min(ans, calc2(a[n / 2] - 1, a[n / 2]));
ans = min(ans, calc2(a[n / 2], a[n / 2] + 1));
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
inline int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
inline int sub(int a, int b) {
if ((a -= b) < 0) a += P;
return a;
}
inline int mul(int a, int b) { return 1ll * a * b % P; }
inline int kpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a)) {
if (b & 1) r = mul(r, a);
}
return r;
}
const int N = 404040;
int n, m;
int sum[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (n); i++) {
int t;
scanf("%d", &t);
sum[t]++;
}
for (int i = (1); i < (N); i++) sum[i] = sum[i - 1] + sum[i];
int ans = 1e9;
for (int i = (1); i < (N / 2); i++) {
int s = 0, op = 0, res = 0;
for (int l = i, r = i; s < m && r < N; l = l * 2, r = r * 2 + 1, op++) {
int t = min(m - s, sum[r] - sum[l - 1]);
s += t;
res += t * op;
}
if (s == m) ans = min(ans, res);
}
if (ans == 1e9) {
ans = 0;
for (int i = (1); i < (N / 2); i++) {
int t = 0, sb = i;
while (sb) {
sb >>= 1;
t++;
}
ans += t * (sum[i] - sum[i - 1]);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e16;
const double EPS = 1e-9;
const long long MOD = (long long)(1e9 + 7);
const long long MAXV = (long long)(2e5 + 10);
const long long MAXE = (long long)(1e6 + 10);
int n, k;
int A[MAXV];
vector<int> ans[MAXV];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> A[i];
int curr = 0;
int aux = A[i];
while (1) {
ans[aux].push_back(curr);
if (aux == 0) break;
aux /= 2;
curr++;
}
}
long long sol = INF;
for (int i = 0; i < MAXV; i++) {
if (ans[i].size() < k) continue;
sort(ans[i].begin(), ans[i].end());
long long h = 0;
for (int j = 0; j < k; j++) h += ans[i][j];
sol = min(sol, h);
}
cout << sol << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
vector<int> s[maxn];
int a[maxn];
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
int x = a[i];
int c = 0;
while (x > 0) {
s[x].push_back(c);
x /= 2;
c++;
}
}
int ans = 1e9;
for (int i = 0; i <= 200000; i++) {
sort(s[i].begin(), s[i].end());
int num = s[i].size();
if (num < k) {
continue;
}
ans = min(accumulate(s[i].begin(), s[i].begin() + k, 0), ans);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200010;
long long a[N];
long long sum[N];
long long c[N];
long long t;
signed main() {
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
long long res = 1e18;
for (long long i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
for (long long i = 1; i <= n; i++) {
long long j = i;
while (j <= n && a[j] == a[i]) j++;
long long len = j - i;
if (len >= k) res = 0;
long long l = -sum[i - 1] + (i - 1) * a[i];
long long r = sum[n] - sum[j - 1] - (n - j + 1) * a[i];
if (j - 1 >= k)
res = min(res, l - (j - 1 - k));
else
res = min(res, l + r - (n - k));
if (n - i + 1 >= k) res = min(res, r - (n - i + 1 - k));
i = j - 1;
}
res = max(res, 0ll);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
int ops[200001] = {0};
int count[200001] = {0};
for (int i = 0; i < n; i++) {
int x = arr[i];
int op_count = 0;
while (x >= 1) {
if (count[x] < k) {
ops[x] += op_count;
count[x]++;
}
x = (x / 2);
op_count++;
}
}
int ans = ops[1];
for (int i = 1; i <= 200000; i++) {
if (count[i] >= k) ans = min(ans, ops[i]);
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << std::fixed;
cout << std::setprecision(10);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
map<int, vector<int>> kit;
for (int i = 0; i < n; i++) {
kit[a[i]].push_back(0);
for (int j = 1; a[i] > 0; j++) {
a[i] /= 2;
kit[a[i]].push_back(j);
}
}
int ans = (int)1e8;
for (auto [_, it] : kit) {
if (it.size() >= k) {
int sum = accumulate(it.begin(), it.begin() + k, 0);
ans = min(ans, sum);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<vector<int> > vals(200 * 1000 + 11);
for (int i = 0; i < n; ++i) {
int x = a[i];
int cur = 0;
while (x > 0) {
vals[x].push_back(cur);
x /= 2;
++cur;
}
}
int ans = 1e9;
for (int i = 0; i <= 200 * 1000; ++i) {
sort(vals[i].begin(), vals[i].end());
if (int(vals[i].size()) < k) continue;
ans = min(ans, accumulate(vals[i].begin(), vals[i].begin() + k, 0));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
long long n, k, a[MX];
map<int, int> ini, fin;
long long acu[MX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < (n); i++) cin >> a[i + 1];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) {
acu[i] = a[i] + acu[i - 1];
if (!ini[a[i]]) ini[a[i]] = i;
fin[a[i]] = i;
}
long long res = acu[n];
for (int i = 1; i <= n; i++) {
long long l = ini[a[i]], r = fin[a[i]];
long long x = (l - 1) * (a[i] - 1) - acu[l - 1];
long long y = (acu[n] - acu[r]) - (n - r) * (a[i] + 1);
int act = r - l + 1;
if (act >= k) res = 0;
if (l - 1 >= k - act) res = min(res, x + max(0ll, k - act));
if (n - r >= k - act) res = min(res, y + max(0ll, k - act));
res = min(res, x + y + max(0ll, k - act));
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
;
vector<long long> arr(n + 1, 0);
for (int i = 1; i <= n; i++) cin >> arr[i];
;
sort(arr.begin(), arr.end());
vector<long long> prefix(2e5 + 5, 0), suffix(2e5 + 5, 0);
for (int i = 1; i <= n; i++) {
prefix[i] = prefix[i - 1] + arr[i];
}
for (int i = n; i >= 1; i--) {
suffix[i] = suffix[i + 1] + arr[i];
}
long long ans = 1e15;
for (int i = 1; i <= n; i++) {
int right = i + 1;
while (right < n && arr[i] == arr[right]) right++;
int have = right - i;
if (have >= k) {
cout << 0 << endl;
return 0;
}
int need = k - have;
long long tmp = (arr[i] - 1) * (i - 1) - prefix[i - 1] + suffix[right] -
(arr[i] + 1) * (n - right + 1) + need;
ans = min(ans, tmp);
if (need < i) {
ans = min(ans, (arr[i] - 1) * (i - 1) - prefix[i - 1] + need);
}
if (n - right + 1 >= need) {
ans = min(ans, suffix[right] - (arr[i] + 1) * (n - right + 1) + need);
}
i = right - 1;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, k;
while (cin >> n >> k) {
map<long long, long long> mp, mp1;
long long ans = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mp[a[i]]++;
if (mp[a[i]] >= k) {
ans = 1;
}
}
if (ans) {
cout << "0" << endl;
continue;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= k; i++) {
ans += (a[i] / 2) + 1;
}
for (int i = 1; i <= n; i++) {
long long num = a[i], x = 0;
while (num > 0) {
num = num / 2;
x++;
mp[num]++;
mp1[num] += x;
if (mp[num] >= k) {
ans = min(ans, mp1[num]);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> am[2 * (int)1e5 + 1];
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int in;
for (int i = 0; i < n; i++) {
cin >> in;
int moves = 0;
while (in != 0) {
am[in].push_back(moves);
in /= 2;
moves += 1;
}
am[in].push_back(moves);
}
int ans = INT_MAX;
for (int i = 0; i <= 2 * (int)1e5; i++) {
if (am[i].size() >= k) {
sort(am[i].begin(), am[i].end());
int fin = 0;
for (int j = 0; j < k; j++) fin += am[i][j];
ans = min(ans, fin);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, i, j, a[500], ans = 99999, x;
map<long long, long long> cost, num;
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
for (i = 1; i <= n; i++) {
long long x = 0;
while (a[i] != 0 && num[a[i]] < k) {
cost[a[i]] += x;
num[a[i]]++;
a[i] /= 2;
x++;
}
}
for (auto p : num) {
if (p.second == k) {
ans = min(ans, cost[p.first]);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int n, k, cnt;
long long ans, l[maxn], r[maxn], v[maxn], sum[maxn], a[maxn], b[maxn];
int main() {
scanf("%d%d", &cnt, &k);
ans = 1e18;
for (int i = 1; i <= cnt; i++) scanf("%lld", &b[i]);
sort(b + 1, b + cnt + 1);
for (int i = 1; i <= cnt; i++) {
a[++n] = b[i];
int j = i;
while (j + 1 <= cnt && b[j + 1] == b[i]) j++;
v[n] = j - i + 1;
i = j;
}
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + v[i];
l[1] = 0;
for (int i = 2; i <= n; i++) l[i] = l[i - 1] + sum[i - 1] * (a[i] - a[i - 1]);
r[n] = 0;
for (int i = n - 1; i >= 1; i--)
r[i] = r[i + 1] + (sum[n] - sum[i]) * (a[i + 1] - a[i]);
for (int i = 1; i <= n; i++)
if (v[i] >= k)
ans = min(ans, 0ll);
else {
int now = k - v[i];
if (sum[i - 1] >= now) ans = min(ans, l[i] - (sum[i - 1] - now));
if (sum[n] - sum[i] >= now)
ans = min(ans, r[i] - (sum[n] - sum[i] - now));
ans = min(ans, l[i] + r[i] - (sum[n] - v[i] - now));
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll n, k;
ll v[200002];
ll s[200001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> v[i];
sort(v + 1, v + 1 + n);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + v[i];
ll ans = 1e14;
for (ll i = 1; i <= n; i++) {
ll j = i;
while (v[j] == v[j + 1]) j++;
ll fr = j - i + 1;
if (fr >= k) {
cout << "0";
return 0;
}
if (i - 1 >= k - fr) {
ll cost = (i - 1) * (v[i] - 1) - s[i - 1];
cost += k - fr;
ans = min(ans, cost);
}
if (n - j >= k - fr) {
ll cost = s[n] - s[j] - (n - j) * (v[i] + 1);
cost += k - fr;
ans = min(ans, cost);
}
ll cost = (s[n] - s[j] - (n - j) * (v[i] + 1)) +
((i - 1) * (v[i] - 1) - s[i - 1]);
cost += k - fr;
ans = min(ans, cost);
i = j;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k;
int arr[N];
long long pre[N];
long long get(int a, int b) {
if (a > b) return 0;
return pre[b] - (a > 0 ? pre[a - 1] : 0);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", arr + i);
}
sort(arr, arr + n);
for (int i = 0; i < n; i++) pre[i] = arr[i] + (i > 0 ? pre[i - 1] : 0);
long long best = 1e18;
for (int i = 0; i < n; i++) {
int j = i;
while (j < n && arr[i] == arr[j]) ++j;
j--;
int len = j - i + 1;
if (len >= k)
best = 0;
else {
int rem = k - len;
int left = i;
int right = n - j - 1;
long long shift_left = 1LL * left * (arr[i] - 1) - get(0, i - 1);
long long shift_right = get(j + 1, n - 1) - 1LL * right * (arr[i] + 1);
if (rem > left) {
long long cost = shift_left + shift_right + rem;
best = min(best, cost);
} else {
long long cost = shift_left + rem;
best = min(best, cost);
}
if (rem > right) {
long long cost = shift_right + shift_left + rem;
best = min(best, cost);
} else {
long long cost = shift_right + rem;
best = min(best, cost);
}
}
i = j;
}
cout << best << '\n';
return 0;
}
|
#include <bits/stdc++.h>
const double EPS = 0.00000001;
const long long mod = 1000000000 + 7;
using namespace std;
map<int, int> a[200020];
int main() {
ios::sync_with_stdio(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[x][0]++;
}
long long N = 200000, ans = 10000000000LL;
for (int i = N; i >= 1; i--) {
if (i == 5) {
}
long long cnt = 0, cost = 0;
for (auto p : a[i]) {
int price = p.first, num = p.second;
a[i / 2][price + 1] += num;
if (num + cnt >= k) {
cost += (k - cnt) * price;
cnt = k;
break;
} else {
cost += price * num;
cnt += num;
}
}
if (cnt >= k) ans = min(ans, cost);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<vector<int> > possval(200005);
for (int i = 0; i < n; i++) {
int temp = a[i], iterator = 0;
while (temp > 0) {
possval[temp].push_back(iterator);
temp /= 2;
iterator++;
}
}
int answer = 1e9;
for (int i = 0; i < 200005; i++) {
sort(possval[i].begin(), possval[i].end());
if (possval[i].size() < k) continue;
answer =
min(answer, accumulate(possval[i].begin(), possval[i].begin() + k, 0));
}
cout << answer << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
const int mod = 1e9 + 7;
template <typename T>
int O(const T &s) {
cout << s << endl;
return 0;
}
template <typename T>
void db(T *bg, T *ed) {
while (bg != ed) cout << *bg++ << ' ';
printf("\n");
}
template <typename T>
void db(vector<T> &it) {
for (auto i : it) cout << i << ' ';
printf("\n");
}
inline long long mul_64(long long x, long long y, long long c) {
return (x * y - (long long)((long double)x / c * y) * c + c) % c;
}
inline long long ksm(long long a, long long b, long long c) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % c)
if (b & 1) ans = ans * a % c;
return ans;
}
inline void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b)
x = 1, y = 0;
else
exgcd(b, a % b, y, x), y -= (a / b) * x;
}
int n, k;
int a[N], x = 0, cnt = 0;
long long pre[N], suf[N];
int main() {
cin >> n >> k;
for (int i = 0; i++ < n; scanf("%d", &a[i]))
;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i];
for (int i = n; i >= 1; i--) suf[i] = suf[i + 1] + a[i];
for (int i = 2; i <= n; i++)
if (a[i] == a[i - 1])
x++;
else
cnt = max(cnt, x), x = 1;
cnt = max(cnt, x);
if (cnt >= k) return O(0);
long long ans = 1e18 + 11;
for (int i = 1; i <= n; i++) {
long long res = 1LL * (i - 1) * a[i] - pre[i - 1] - 1LL * a[i] * (n - i) +
suf[i + 1] - (n - k);
if (i >= k) res = min(res, 1LL * (i - 1) * a[i] - pre[i - 1] - (i - k));
if (n - i + 1 >= k)
res = min(res, suf[i + 1] - 1LL * (n - i) * a[i] - (n - i + 1 - k));
ans = min(ans, res);
}
O(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, n, a[200005], b[200005], c[200005], d[200005], s, q[200005], ans,
k;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> q[i];
sort(q + 1, q + n + 1);
for (i = 1; i <= n; i++)
if (q[i] > q[i - 1]) {
s++;
a[s] = q[i];
b[s] = 1;
} else
b[s]++;
n = s;
for (i = 1; i <= n; i++) {
c[i] = c[i - 1] + a[i] * b[i];
d[i] = d[i - 1] + b[i];
}
ans = 1e16;
for (i = 1; i <= n; i++) {
if (b[i] >= k) {
cout << 0;
return 0;
}
if (d[i - 1] + b[i] >= k)
ans = min(ans, d[i - 1] * (a[i] - 1) - c[i - 1] + k - b[i]);
if (d[n] - d[i] + b[i] >= k)
ans = min(ans, c[n] - c[i] - (d[n] - d[i]) * (a[i] + 1) + k - b[i]);
if (d[i - 1] + b[i] + d[n] - d[i] >= k)
ans = min(ans, d[i - 1] * (a[i] - 1) - c[i - 1] + c[n] - c[i] -
(d[n] - d[i]) * (a[i] + 1) + k - b[i]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long MAX = 2e6 + 7;
const long long INF = 1e15;
const long long dx[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const long long dy[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
long long i, j, k, t, n, q, l, r, mid;
vector<pair<long long, long long> > v;
long long precnt[MAX], presum[MAX], sufcnt[MAX], sufsum[MAX];
long long x, res, need, needr, needl, mini;
map<long long, long long> mp;
void solve() {
mini = INF;
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> x;
mp[x]++;
}
for (auto x : mp) {
v.push_back({x.first, x.second});
}
n = v.size();
for (long long i = 0; i < n; i++) {
if (i) {
precnt[i] += precnt[i - 1];
presum[i] += presum[i - 1];
}
precnt[i] += v[i].second;
presum[i] += v[i].second * v[i].first;
}
for (long long i = n - 1; i >= 0; i--) {
if (i != n - 1) {
sufcnt[i] += sufcnt[i + 1];
sufsum[i] += sufsum[i + 1];
}
sufcnt[i] += v[i].second;
sufsum[i] += v[i].first * v[i].second;
}
for (long long i = 0; i < n; i++) {
need = max(0ll, k - v[i].second);
res = 0;
needl = needr = 0;
if (i) needl = min(need, precnt[i - 1]);
needr = max(0ll, need - needl);
if (i && needl) {
res += (v[i].first - 1) * precnt[i - 1] - presum[i - 1];
res += needl;
}
if (i + 1 < v.size() && needr) {
res += sufsum[i + 1] - (v[i].first + 1) * sufcnt[i + 1];
res += needr;
}
mini = min(mini, res);
res = needl = needr = 0;
if (i + 1 < v.size()) needr = min(need, sufcnt[i + 1]);
needl = max(0ll, need - needr);
if (i && needl) {
res += (v[i].first - 1) * precnt[i - 1] - presum[i - 1];
res += needl;
}
if (i + 1 < v.size() && needr) {
res += sufsum[i + 1] - (v[i].first + 1) * sufcnt[i + 1];
res += needr;
}
mini = min(mini, res);
}
cout << mini << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 10;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
long long n, k, ans = INF;
long long a[MAXN], sum[MAXN];
long long cnt[MAXN], l[MAXN], r[MAXN];
bool flag = false;
vector<long long> v;
inline long long Getid(long long x) {
return lower_bound(v.begin(), v.end(), x) - v.begin() + 1;
}
signed main() {
cin >> n >> k;
for (register long long i = 1; i <= n; ++i) {
cin >> a[i];
v.push_back(a[i]);
}
sort(v.begin(), v.end());
sort(a + 1, a + n + 1);
v.erase(unique(v.begin(), v.end()), v.end());
for (register long long i = 1; i <= n; ++i) {
long long id = Getid(a[i]);
if (a[i - 1] != a[i]) l[id] = i;
r[id] = i;
sum[i] = sum[i - 1] + a[i];
cnt[id]++;
if (cnt[id] >= k) {
flag = true;
break;
}
}
if (flag) {
puts("0");
return 0;
}
for (register long long i = 1; i <= n; ++i) {
long long lv, rv, id = Getid(a[i]);
lv = a[i] * (l[id] - 1) - sum[l[id] - 1];
rv = (sum[n] - sum[r[id]]) - a[i] * (n - r[id]);
k -= cnt[id];
if (l[id] - 1 >= k) ans = min(ans, lv - (l[id] - 1 - k));
if (n - r[id] >= k) ans = min(ans, rv - (n - r[id] - k));
ans = min(ans, lv + rv - (n - cnt[id] - k));
k += cnt[id];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
const int maxn = 2e5 + 10;
using namespace std;
int n, k, a[maxn];
vector<int> v[maxn];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (k == 1) {
printf("0\n");
return 0;
}
for (int i = 1; i <= n; i++) {
int p = a[i], cnt = 0;
while (p >= 0) {
v[p].push_back(cnt);
if (p == 0) break;
p /= 2;
cnt++;
}
}
int ans = inf, anss;
for (int i = 0; i < maxn; i++) {
if (v[i].size() >= k) {
sort(v[i].begin(), v[i].end());
anss = 0;
for (int j = 0; j < k; j++) anss += v[i][j];
ans = min(ans, anss);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = signed long long int;
const int N = 2e5 + 10;
using mp = map<ll, ll>;
mp m;
ll n, k;
struct num {
ll key, frq, lcost, rcost, lcount, rcount;
inline ll calc() const {
if (frq >= k) {
return 0LL;
}
return min(calc(lcost, lcount, rcost, rcount),
calc(rcost, rcount, lcost, lcount));
}
inline ll calc(ll ls, ll lsn, ll gr, ll grn) const {
ll res = 0LL, rq = k - frq;
res += ls;
rq -= min(rq, lsn);
if (rq > 0) {
res += gr;
}
res += k - frq;
return res;
}
};
vector<num> v;
ll res = numeric_limits<ll>::max();
int main() {
ios_base::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
cout << fixed;
cout.precision(12);
v.reserve(N);
cin >> n >> k;
for (int i = 0, t; i < n; i++) {
cin >> t;
m[t]++;
}
for (auto p : m) {
v.push_back({p.first, p.second});
}
v.front().lcost = v.front().lcount = v.back().rcost = v.back().rcount = 0LL;
for (int i = 1; i < v.size(); i++) {
v[i].lcost = v[i - 1].lcost + (v[i].key - v[i - 1].key) * v[i - 1].lcount +
(v[i].key - v[i - 1].key - 1LL) * v[i - 1].frq;
v[i].lcount = v[i - 1].lcount + v[i - 1].frq;
}
for (int i = v.size() - 2; i >= 0; i--) {
v[i].rcost = v[i + 1].rcost + (v[i + 1].key - v[i].key) * v[i + 1].rcount +
(v[i + 1].key - v[i].key - 1LL) * v[i + 1].frq;
v[i].rcount = v[i + 1].rcount + v[i + 1].frq;
}
for (auto& x : v) {
res = min(res, x.calc());
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e5;
int n, k;
long long a[mxN], b[mxN + 1], ans = 1e18;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i < n; ++i) b[i + 1] = b[i] + a[i];
for (int i = 0, j = 0; i < n; i = j) {
for (; j < n && a[j] == a[i]; ++j)
;
long long c = j - i, x = a[i], cl = (long long)i * (x - 1) - b[i],
cr = b[n] - b[j] - (long long)(n - j) * (x + 1);
if (c >= k) ans = 0;
if (c + i >= k) ans = min(cl + k - c, ans);
if (c + n - j >= k) ans = min(cr + k - c, ans);
ans = min(cl + cr + k - c, ans);
}
cout << max(ans, 0ll);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, t;
cin >> n >> k;
vector<int> a(n);
set<int> s;
for (i = 0; i < n; i++) {
cin >> t;
a[i] = t;
while (t) {
s.insert(t);
t /= 2;
}
}
int ans = INT_MAX;
for (auto x : s) {
vector<int> cur;
for (i = 0; i < n; i++) {
int cnt = 0;
t = a[i];
while (t > x) {
t /= 2;
cnt++;
}
if (t == x) cur.push_back(cnt);
}
if ((int)(cur).size() < k) continue;
sort(cur.begin(), cur.end());
ans = min(ans, accumulate(cur.begin(), cur.begin() + k, 0));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200007;
vector<long long> v[N + 5];
long long cnt[N + 9];
long long a[N + 9];
set<long long> st;
int32_t main() {
ios::sync_with_stdio(0);
long long n, k, x;
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> x;
++cnt[x];
if (cnt[x] >= k) {
st.insert(x);
}
long long r = 0;
v[x].push_back(r);
while (x != 0) {
x /= 2;
r++;
++cnt[x];
if (cnt[x] >= k) {
st.insert(x);
}
v[x].push_back(r);
}
}
long long ans = 999999999999999999;
for (auto it : st) {
sort(v[it].begin(), v[it].end());
long long r = 0;
for (long long i = 0; i < k; i++) {
r += v[it][i];
}
ans = min(ans, r);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
constexpr int INF = INT_MAX / 10;
constexpr long long LINF = LLONG_MAX / 10;
constexpr double eps = 1e-9;
template <class T, class U>
inline bool chmax(T& lhs, const U& rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U>
inline bool chmin(T& lhs, const U& rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
using namespace std;
inline long long gcd(long long a, long long b) {
while (b) {
long long c = a;
a = b;
b = c % b;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool isprime(long long n) {
if (n == 1) return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
long long mypow(long long a, long long b) {
if (!b) return 1;
if (b & 1) return mypow(a, b - 1) * a;
long long memo = mypow(a, b >> 1);
return memo * memo;
}
long long modpow(long long a, long long b, long long m) {
if (!b) return 1;
if (b & 1) return modpow(a, b - 1, m) * a % m;
long long memo = modpow(a, b >> 1, m);
return memo * memo % m;
}
void printArray(vector<int>& vec) {
for (int i = 0; i < (vec.size() - 1); i++) cout << vec[i] << " ";
cout << vec.back() << endl;
}
int n, k;
long long a[200010], dp[2][200010];
map<int, int> c;
signed main() {
cin >> n >> k;
for (int i = 0; i < (n); i++) {
cin >> a[i];
c[a[i]]++;
}
sort(a, a + n);
dp[0][0] = 0;
for (int i = 1; i <= (n - 1); i++) {
if (a[i - 1] == a[i])
dp[0][i] = dp[0][i - 1];
else {
dp[0][i] = dp[0][i - 1] + (long long)i * (a[i] - a[i - 1]);
}
}
dp[1][n - 1] = 0;
for (int i = n - 2; i >= 0; i--) {
if (a[i + 1] == a[i])
dp[1][i] = dp[1][i + 1];
else {
dp[1][i] = dp[1][i + 1] + (long long)(n - i - 1) * (a[i + 1] - a[i]);
}
}
if (c.size() == 1) {
cout << 0 << endl;
return 0;
}
long long ans = LINF, memo = 0, left = 0;
for (int i = 0; i < (n - 1); i++) {
if (k <= c[a[i]]) {
cout << 0 << endl;
return 0;
}
if (a[i] == a[i + 1]) continue;
if (k <= i + 1) {
chmin(ans, memo + (a[i] - a[left - 1] - 1) * left + k - c[a[i]]);
}
if (k <= n - left) {
chmin(ans,
dp[1][i + 1] + (a[i + 1] - a[i] - 1) * (n - i - 1) + k - c[a[i]]);
}
if (left)
chmin(ans, memo + dp[1][i + 1] + (a[i] - a[left - 1] - 1) * left +
(a[i + 1] - a[i] - 1) * (n - i - 1) + k - c[a[i]]);
memo = dp[0][i];
left = i + 1;
}
chmin(ans, memo + (a[n - 1] - a[left - 1] - 1) * left + k - c[a[n - 1]]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int k;
cin >> n >> k;
int ans[200009];
int a[n];
memset(ans, -1, sizeof(ans));
int max1 = INT_MIN;
for (int i = 0; i < n; i++) {
cin >> a[i];
max1 = max(max1, a[i]);
}
long long int count = 0;
long long int count1 = 0;
int q = 0;
sort(a, a + n);
int flag = 0;
for (int i = 1; i <= max1; i++) {
count1 = 0;
q = 0;
for (int j = 0; j < n; j++) {
int x = a[j];
count = 0;
flag = 0;
while (x > i) {
x = x / 2;
count++;
}
if (x == i) {
count1 += count;
q++;
if (q == k) {
flag = 1;
break;
}
}
}
if (flag == 1) ans[i] = count1;
}
int r = INT_MAX;
for (int i = 1; i <= max1; i++) {
if (ans[i] != -1) r = min(r, ans[i]);
}
cout << r << " ";
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 100;
const int md = 1000000007;
priority_queue<int, vector<int>, greater<int> > pq;
bool compare(int &a, int &b) { return a < b; }
vector<priority_queue<int, vector<int> > > arr(mx * 2);
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i += 1) {
int x, z = 0;
scanf("%d", &x);
while (true) {
arr[x].push(z);
if (arr[x].size() > m) arr[x].pop();
if (x == 0) break;
z++;
x /= 2;
}
}
long long ans = -1, temp = 0;
for (int i = 0; i < mx * 2; i += 1) {
temp = 0;
if (arr[i].size() >= m) {
for (int j = 0; j < m; j += 1) {
temp += arr[i].top();
arr[i].pop();
}
if (ans == -1) ans = temp;
ans = min(ans, temp);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pair_hash {
template <class T1, class T2>
std::size_t operator()(const std::pair<T1, T2>& pair) const {
return std::hash<T1>()(pair.first) ^ std::hash<T2>()(pair.second);
}
};
const long double EPS = 1e-7;
const long long MOD = 1000000007;
const long long INF = 1e18;
const double pi = 2 * acos(0.0);
long long n, m, k, p, q, t, sum = 0, cnt = 0;
long long mx = INT64_MIN;
long long mn = INT64_MAX;
bool flag = 0;
vector<long long> v;
string s = "", s1, s2;
void bad_solve() {}
void solve() {
vector<vector<long long> > nms(2e5 + 1, vector<long long>());
cin >> n >> k;
for (long long(i) = 0; (i) < (n); ++(i)) {
cin >> p;
cnt = 0;
while (p) {
nms[p].push_back(cnt);
p >>= 1ll;
++cnt;
}
nms[p].push_back(cnt);
}
for (long long(i) = 0; (i) < (2e5 + 1); ++(i)) {
sort(nms[i].begin(), nms[i].end());
if ((long long)nms[i].size() >= k) {
sum = 0;
for (long long(j) = 0; (j) < (k); ++(j)) {
sum += nms[i][j];
}
mn = min(sum, mn);
}
}
cout << mn;
}
int main() {
cout.precision(20);
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[200001];
void solve() {
long long x, y, t, ans = (int)1e9 + 7;
cin >> x >> y;
for (long long i = 0; i < x; ++i) {
cin >> t;
long long ct = 0;
while (t) {
v[t].push_back(ct);
ct++;
t /= 2;
}
}
for (long long i = 0; i < 200001; ++i) {
if (v[i].size() < y) continue;
sort(v[i].begin(), v[i].end());
long long sum = 0;
for (long long k = 0; k < y; ++k) sum += v[i][k];
ans = min(ans, sum);
}
cout << ans;
}
signed main() {
long long t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200005] = {};
int b[200005][2] = {};
int main() {
int n, k, i, j, l, ans = 9999999, num = 0;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = 0; i < n; i++) {
l = 0;
do {
b[a[i]][0]++;
b[a[i]][1] += l;
if (b[a[i]][0] >= k && b[a[i]][1] < ans) {
ans = b[a[i]][1];
num = a[i];
}
a[i] /= 2;
l++;
} while (a[i]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, k, ans = N;
vector<int> a[N];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
int x, j = 0;
scanf("%d", &x);
while (x) {
a[x].push_back(j);
j++;
x >>= 1;
}
}
for (int i = 0; i <= 200000; ++i)
if (a[i].size() >= k) {
int mx = 0;
sort(a[i].begin(), a[i].end());
for (int j = 0; j < k; ++j) mx += a[i][j];
ans = min(ans, mx);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1>
void dbg_pr(vector<T1> V, int add = 0, int start = -1, int end = -1) {
cout << "{";
if (start < 0) start = 0;
if (end < 0) end = V.size() - 1;
for (int i = start; i <= end; i++) {
cout << V[i] + add << ((i == end) ? "}" : " ");
}
}
void dbg_pr(string V) { cout << "\"" << V << "\""; }
template <typename T1>
void dbg_pr(T1 V) {
cout << V;
}
template <typename T1, typename T2>
void dbg_pr(map<T1, T2> M) {
cout << "{";
for (const auto m : M) {
dbg_pr(m.first);
cout << ":";
dbg_pr(m.second);
cout << ",";
}
cout << "}";
}
void debug_out() { cout << "\033[0m\n"; }
template <typename T1, typename... T2>
void debug_out(T1 A, T2... B) {
cout << " ";
dbg_pr(A);
debug_out(B...);
}
int test = 1;
void setupFastCin() {
ios::sync_with_stdio(false);
cin.tie(0);
}
template <typename T1>
T1 chmin(T1 &x, const T1 v) {
return x = min(x, v);
}
template <typename T1>
T1 chmax(T1 &x, const T1 v) {
return x = max(x, v);
}
template <typename T1>
void pr(vector<T1> V, int add = 0, int start = -1, int end = -1) {
if (start < 0) start = 0;
if (end < 0) end = V.size() - 1;
for (int i = start; i <= end; i++) {
cout << V[i] + add << ((i == end) ? "\n" : " ");
}
}
template <typename T1>
T1 gcd(const T1 &a, const T1 &b) {
if (a == 0 || b == 0) return a + b;
return gcd(b, a % b);
}
const int MAX = 200005;
const long long MOD = 998244353ll;
long long calc(vector<pair<long long, long long> > N, const int k) {
if (N[0].second >= k) return 0;
long long c = 0;
for (int i = 1; i < N.size(); i++) {
N[i].second += N[i - 1].second;
c += N[i - 1].second * abs(N[i].first - N[i - 1].first);
if (N[i].second >= k) {
long long rm = min(N[i].second - k, N[i - 1].second);
return c - rm;
}
}
assert(0);
return -1;
}
void solve() {
int n, k;
cin >> n >> k;
vector<long long> N(n), S(n);
for (int i = 0; i < n; i++) cin >> N[i];
sort(N.begin(), N.end());
vector<pair<long long, long long> > P;
for (int i = 0; i < n; i++) {
if (P.size() == 0 || N[i] != P.back().first) P.push_back({N[i], 0});
P.back().second++;
if (P.back().second >= k) {
cout << 0 << "\n";
return;
};
}
long long b = 0;
int m = (n - 1) / 2;
for (int i = 0; i < n; i++) {
b += abs(N[i] - N[m]);
}
1337;
b += (k - n);
chmin(b, calc(P, k));
reverse(P.begin(), P.end());
chmin(b, calc(P, k));
{
cout << b << "\n";
return;
};
}
int main() {
setupFastCin();
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int min(int a, int b) { return a < b ? a : b; }
int max(int a, int b) { return a > b ? a : b; }
bool isprime(int k) {
bool is = 1;
for (int i = 2; i <= sqrt(k); i++)
if (k % i == 0) is = 0;
return is;
}
vector<int> vc[200000 + 5];
int32_t main() {
;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int t = 0, x = a[i];
while (x > 0) {
vc[x].emplace_back(t);
x /= 2;
t++;
}
}
int ans = 2147483647;
for (int i = 0; i < 200005; i++) {
if (vc[i].size() < k) continue;
sort(vc[i].begin(), vc[i].end());
ans = min(ans, accumulate(vc[i].begin(), vc[i].begin() + k, 0));
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int negative_infinite = 0xcfcfcfcf;
const double pi = acos(-1);
const int mod = 1e9 + 7;
const double eps = 1e-8;
const int MAXN = 1e6 + 117;
const int MAXM = 2e5 + 117;
int n, k;
long long a[MAXN];
long long pre[MAXN], suf[MAXN];
map<int, int> l, r;
void build() {
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
if (l[a[i]] == 0) l[a[i]] = i;
}
for (int i = n; i > 0; i--) {
suf[i] = suf[i + 1] + a[i];
if (r[a[i]] == 0) r[a[i]] = i;
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
build();
long long ans = 1e15;
for (int i = 1; i <= n; i++) {
int dx = k - (r[a[i]] - l[a[i]] + 1);
if (dx <= 0) {
ans = 0;
break;
}
long long lcost = (l[a[i]] - 1) * (a[i] - 1) - pre[l[a[i]] - 1];
long long rcost = suf[r[a[i]] + 1] - (n - r[a[i]]) * (a[i] + 1);
if (i >= k) ans = min(ans, lcost + dx);
if (n - i + 1 >= k) ans = min(ans, rcost + dx);
ans = min(ans, lcost + rcost + dx);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, l, ans = INT_MAX;
map<int, pair<int, int> > m;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
l = 0;
while (a[i]) {
if (m[a[i]].first < k) m[a[i]].first++, m[a[i]].second += l;
a[i] /= 2, l++;
}
}
for (auto i : m) {
if ((i.second).first == k) ans = min((i.second).second, ans);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
template <typename T>
T add(T &a, T b) {
return (a += b) %= 1000000007;
}
template <typename T>
T sub(T &a, T b) {
(a -= b);
if (a < 0) a += 1000000007;
}
const int N = 2e5 + 5;
long long n, k;
long long a[N], b[N], ans;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (long long i = 0; i < n; i++) b[i + 1] = b[i] + a[i];
ans = 9e18;
for (long long i = 0, j = 0; i < n; i = j) {
for (; j < n and a[i] == a[j]; j++)
;
long long c = j - i, first = a[i], cl = i * (first - 1) - b[i],
cr = b[n] - b[j] - (n - j) * (first + 1);
if (c >= k) ans = 0;
if (c + i >= k) ans = min(ans, cl + k - c);
if (c + n - j >= k) ans = min(ans, cr + k - c);
ans = min(ans, (cl + cr + k - c));
}
cout << max(ans, 0ll);
return 0;
}
|
#include <bits/stdc++.h>
int main() {
std::size_t n, k;
std::cin >> n >> k;
unsigned constexpr MAX = 2e5 + 5;
std::vector<std::vector<unsigned>> times(MAX);
while (n--) {
unsigned x;
std::cin >> x;
unsigned cur = 0;
while (true) {
times[x].push_back(cur);
if (!x) {
break;
}
x /= 2;
++cur;
}
}
unsigned result = std::numeric_limits<unsigned>::max();
for (auto& v : times) {
if (v.size() < k) {
continue;
}
std::nth_element(v.begin(), v.begin() + k, v.end());
result = std::min(result, std::accumulate(v.begin(), v.begin() + k, 0u));
}
std::cout << result << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
long long n, i, m, x;
cin >> n >> m;
long long a[n];
for (auto &ghe : a) cin >> ghe;
;
priority_queue<long long> pq[200001];
for (auto &i : a) {
x = 0;
while (i) pq[i].push(-x), i >>= 1, ++x;
pq[0].push(-x);
}
x = LLONG_MAX;
for (auto &q : pq)
if (q.size() >= m) {
i = m;
n = 0;
while (i--) n -= q.top(), q.pop();
x = min(x, n);
}
cout << x << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m, ans = INT_MAX;
int steps[200005] = {0}, freq[200005] = {0};
void cal(int x, int step) {
freq[x]++;
if (freq[x] == k) ans = min(ans, steps[x]);
if (x == 0) return;
step++;
steps[x / 2] += step;
cal(x / 2, step);
}
int main() {
cin >> n >> k;
vector<int> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr.begin(), arr.end());
for (int i = 0; i < n; i++) cal(arr[i], 0);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
map<long long, long long>::iterator it;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a = 0, b = 0, c, d, e, f = 0, l, g, m, n, k, i, j, t, p, q, sum = 0,
ssum, pp;
cin >> n >> k;
f = 1234567891253456;
for (i = 0; i < n; i++) {
cin >> a;
sum += a;
mp[a]++;
if (mp[a] >= k) f = 0;
}
a = 0;
ssum = 0;
it = mp.begin();
while (it != mp.end()) {
d = k - it->second;
if (d <= 0) break;
if (a >= d) {
p = it->first - 1;
p *= a;
p -= ssum;
p += d;
f = min(f, p);
}
if (n - a >= k) {
p = it->first + 1;
q = n - a - it->second;
p *= q;
p = sum - ssum - it->second * it->first - p;
p += d;
f = min(f, p);
}
p = it->first - 1;
p *= a;
p -= ssum;
pp = it->first + 1;
q = n - a - it->second;
pp *= q;
pp = sum - ssum - it->second * it->first - pp;
p += pp + d;
f = min(f, p);
a += it->second;
ssum += it->first * it->second;
it++;
}
cout << f << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n % 2 == 1) res = res * x;
x = x * x;
n = n / 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, i, j;
cin >> n >> k;
int a[n];
int f[2 * 100002] = {0};
int ans[2 * 100002] = {0};
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n; i++) {
int x = a[i], cnt = 0;
while (x > 0) {
if (f[x] < k) {
f[x]++;
ans[x] += cnt;
}
x = x / 2;
cnt++;
}
if (f[0] < k) {
f[0]++;
ans[0] += cnt;
}
}
int y = INT_MAX;
for (i = 0; i <= 2 * 100001; i++) {
if (f[i] == k) {
y = min(ans[i], y);
}
}
cout << y;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
long long dx[] = {1, 0, -1, 0};
long long dy[] = {0, 1, 0, -1};
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void solve() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
vector<multiset<long long>> mp(200001);
for (long long i = 0; i < n; i++) {
long long cur = a[i];
long long moves = 0;
while (cur) {
mp[cur].insert(moves);
moves++;
cur /= 2;
}
}
long long ans = INT_MAX;
for (long long i = 0; i <= 2e5; i++) {
if (mp[i].size() >= k) {
long long sum = 0, cnt = 1;
for (auto x : mp[i]) {
sum += x;
if (cnt == k) break;
cnt++;
}
ans = min(ans, sum);
}
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n + 10];
set<int> vect;
for (long long i = 0; i < n; i++) {
cin >> a[i];
long long x = a[i];
while (x > 0) {
vect.insert(x);
x /= 2;
}
}
long long ans = 1e10;
set<int>::iterator it;
for (it = vect.begin(); it != vect.end(); it++) {
vector<int> cnt;
for (long long j = 0; j < n; j++) {
long long op = 0;
long long x = a[j];
while (x > (*it)) {
x = x / 2;
op += 1;
}
if (x == (*it)) cnt.push_back(op);
}
if (cnt.size() < k) {
continue;
}
sort(cnt.begin(), cnt.end());
ans = min(ans, (long long)accumulate(cnt.begin(), cnt.begin() + k, 0));
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int T = 1;
while (T--) {
long long int n, k, i, x;
cin >> n >> k;
long long int a[n];
long long int aa[200005] = {0};
priority_queue<long long int> Q[200005];
for (i = 0; i < n; i++) {
cin >> x;
long long int cost = 0;
while (x) {
Q[x].push(cost);
aa[x] += cost;
if (Q[x].size() > k) {
aa[x] -= Q[x].top();
Q[x].pop();
}
cost++;
x /= 2;
}
Q[x].push(cost);
aa[x] += cost;
if (Q[x].size() > k) {
aa[x] -= Q[x].top();
Q[x].pop();
}
}
long long int ans = 1e18;
for (i = 0; i < 200004; i++) {
if (Q[i].size() >= k) ans = min(ans, aa[i]);
}
cout << ans << "\n";
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.