text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
long long raw[maxn], pre[maxn], suf[maxn], cnt;
long long ans = 1e17;
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%lld", &raw[i]);
sort(raw + 1, raw + n + 1);
for (int i = 1; i <= n; i++) {
if (raw[i] != raw[i - 1]) {
if (cnt >= k) {
printf("0");
return 0;
}
cnt = 1;
} else
cnt++;
}
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + raw[i];
for (int i = n; i >= 1; i--) suf[i] = suf[i + 1] + raw[i];
for (int i = 1; i <= n; i++) {
if (i < k)
ans = min(ans,
i * raw[i] - pre[i] + suf[i] - (n - i + 1) * raw[i] - (n - k));
else
ans = min(ans, i * raw[i] - pre[i] - (i - k));
if (n - i + 1 < k)
ans = min(ans,
suf[i] - (n - i + 1) * raw[i] + i * raw[i] - pre[i] - (n - k));
else
ans = min(ans, suf[i] - (n - i + 1) * raw[i] - (n - i + 1 - k));
}
cout << max(ans, 0ll);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long a[200005];
long long pref[200005];
long long count(long long c) {
int b = lower_bound(a + 1, a + 1 + n, c) - a,
e = upper_bound(a + 1, a + 1 + n, c) - a;
int v = k - (e - b);
if (v <= 0) return 0;
long long lc = b * c - pref[b] - (b - 1),
rc = pref[n] - pref[e - 1] - (n - e + 1) * c - (n - e + 1);
if ((b - 1) >= v && (n - e + 1) >= v)
return min(lc + v, rc + v);
else if ((b - 1) >= v && (n - e + 1) < v)
return lc + v;
else if ((b - 1) < v && (n - e + 1) >= v)
return rc + v;
else
return lc + rc + v;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; ++i) {
pref[i] = a[i] + pref[i - 1];
}
long long m = 1e17;
for (int i = 1; i <= n; ++i) {
long long tm = count(a[i]);
if (tm < m) m = tm;
}
cout << m;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
long long n, k;
long long a[MX];
long long sa[MX];
long long querySum(long long b, long long e) {
if (b > e) return 0;
long long s0 = sa[e];
if (b > 0) s0 -= sa[b - 1];
return s0;
}
long long solve() {
memset(sa, 0, sizeof(sa));
for (long long i = 0; i < n; i++) {
sa[i] += a[i];
if (i > 0) sa[i] += sa[i - 1];
}
long long res = sa[n - 1];
long long b = 0, e = 0;
while (b < n && e < n) {
while (e < n && a[e] == a[b]) e++;
long long r = e - b;
if (r >= k) return 0;
long long t = a[b];
long long leftNum = 0, leftCnt = 0;
long long rightNum = 0, rightCnt = 0;
if (b - 1 >= 0) {
leftNum = (t - 1) * b - querySum(0, b - 1);
leftCnt = b;
}
if (e <= n - 1) {
rightCnt = n - e;
rightNum = -(t + 1) * rightCnt + querySum(e, n - 1);
}
if (leftCnt + r >= k) {
res = min(res, leftNum + k - r);
}
if (rightCnt + r >= k) {
res = min(res, rightNum + k - r);
}
res = min(res, leftNum + rightNum + k - r);
b = e;
}
return res;
}
int main() {
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
bool mini(A &a, const B b) {
return a > b ? (a = b, 1) : 0;
}
template <class A, class B>
bool maxi(A &a, const B b) {
return a < b ? (a = b, 1) : 0;
}
const long long maxN = 2e5 + 5;
const long long inf = 1e18;
long long k, n, a[maxN], p[maxN], s[maxN], res = inf, cp, cs, c;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = (1), _b = (n); i <= (_b); i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (long long i = (2), _b = (n); i <= (_b); i++) {
p[i] = p[i - 1] + (a[i] - a[i - 1]) * (i - 1);
}
for (long long i = (n - 1), _b = (1); i >= (_b); i--) {
s[i] = s[i + 1] + (a[i + 1] - a[i]) * (n - i);
}
for (long long j, i = 1; i <= n;) {
for (j = i; i <= n && a[j] == a[i]; i++)
;
if (i - j >= k) {
res = 0;
break;
}
c = k - (i - j);
if (j > 1)
cp = (a[j] - a[j - 1] - 1) * (j - 1) + p[j - 1];
else
cp = inf;
if (i <= n)
cs = (a[i] - a[j] - 1) * (n - i + 1) + s[i];
else
cs = inf;
if (j - 1 >= c) mini(res, cp + c);
if (n - i + 1 >= c) mini(res, cs + c);
mini(res, cp + cs + c);
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cout.tie(nullptr);
cin.tie(nullptr);
int n, k;
cin >> n >> k;
map<int, int> fre;
vector<long long> a(n), f(n, 0), r(n, 0);
for (int i = 0; i < n; ++i) {
cin >> a[i];
fre[a[i]]++;
}
sort(a.begin(), a.end());
long long sum = a[0];
for (int i = 1; i < n; ++i) {
if (a[i] == a[i - 1])
f[i] = f[i - 1];
else
f[i] = (a[i] - 1) * i - sum;
sum += a[i];
2;
}
sum = a[n - 1];
for (int i = n - 2; i >= 0; --i) {
if (a[i] == a[i + 1])
r[i] = r[i + 1];
else
r[i] = sum - (a[i] + 1) * (n - i - 1);
sum += a[i];
}
for (int i = 0; i < n; ++i) {
if (fre[a[i]] >= k) {
cout << 0 << '\n';
return 0;
}
}
2;
2;
2;
long long ans = LLONG_MAX;
for (int i = 0; i < n; ++i) {
if (i >= k - 1) ans = min(ans, f[i] + max(0, k - fre[a[i]]));
if (i <= n - k)
ans = min(ans, r[i] + max(0, k - fre[a[i]]));
else
ans = min(ans, f[i] + r[i] + max(0, k - fre[a[i]]));
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long pinf = 1e18 + 4;
const long long ninf = -pinf;
const long long N = 200005;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
long long A[n];
long long S1[N];
long long C[N];
memset(C, 0, sizeof(C));
memset(S1, 0, sizeof(S1));
long long ans = INT_MAX;
for (long long i = 0; i < n; i++) {
cin >> A[i];
C[A[i]]++;
if (C[A[i]] == k) ans = 0;
}
for (long long j = 1; j < 18; j++) {
for (long long i = 0; i < n; i++) {
long long x = A[i] / 2;
if (A[i] != x) {
A[i] = x;
S1[A[i]] += j;
C[A[i]]++;
if (C[A[i]] == k) ans = min(S1[A[i]], ans);
}
}
}
cout << endl;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long l[n], r[n];
l[0] = r[n - 1] = 0;
long long bst = 1000000000000000000;
for (long long i = 1; i < n; i++)
l[i] = l[i - 1] + i - 1 + i * (a[i] - a[i - 1] - 1);
for (long long i = n - 2; i >= 0; i--)
r[i] = r[i + 1] + n - i - 2 + (n - i - 1) * (a[i + 1] - a[i] - 1);
for (long long i = 0; i < n; i++) {
long long j = i;
while (j < n and a[j] == a[i]) j++;
j--;
long long len = j - i + 1;
long long ans;
if (len >= k)
ans = 0;
else {
if (i >= k - len and n - j - 1 >= k - len)
ans = min(l[i], r[j]);
else if (i >= k - len)
ans = l[i];
else if (n - j - 1 >= k - len)
ans = r[j];
else
ans = l[i] + r[j];
ans += k - len;
}
bst = min(bst, ans);
i = j;
}
cout << bst << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const long long oo = 1e18;
int n, k;
cin >> n >> k;
vector<long long> v(n + 1);
for (int i = 1; i <= n; i++) cin >> v[i];
sort(v.begin() + 1, v.end());
vector<long long> acum(n + 1);
for (int i = 1; i <= n; i++) acum[i] = acum[i - 1] + v[i];
long long ans = oo;
int last = 0;
for (int i = 1; i <= n; i++) {
if (v[i] != v[i + 1] || i == n) {
int many = i - last;
if (many >= k) {
ans = 0;
break;
}
long long left = (v[i] - 1ll) * last - acum[last];
long long right = acum[n] - acum[i] - (v[i] + 1ll) * 1ll * (n - i);
if (i >= k) ans = min(ans, left + 1ll * k - 1ll * many);
if (n >= k + last) ans = min(ans, right + 1ll * k - 1ll * many);
ans = min(ans, left + right + 1ll * k - 1ll * many);
last = i;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
inline int sbt(int x) { return __builtin_popcount(x); }
inline long long gl(long long a, long long b) { return (b - a + 1); }
inline long long mul(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return ((a % m) * (b % m)) % m;
}
inline long long add(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return (a + b) % m;
}
inline long long sub(long long a, long long b,
long long m = (long long)(1e9 + 7)) {
return (a - b + m) % m;
}
long long fastpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b >>= 1;
}
return res;
}
long long modinv(long long a) { return fastpow(a, (long long)(1e9 + 7) - 2); }
void get_ac() {
long long n, k;
cin >> n >> k;
long long a[n], p[n], s[n];
map<long long, long long> m;
for (long i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a, a + n);
p[0] = a[0];
for (auto i = 1; i <= n - 1; i++) {
p[i] = p[i - 1] + a[i];
}
s[n - 1] = a[n - 1];
for (auto i = n - 2; i >= 0; i--) {
s[i] = s[i + 1] + a[i];
}
long long ans = 1e15;
long long sm, lg, lgc, smc, eq;
for (int i = 0; i < n; i++) {
sm = lower_bound(a, a + n, a[i]) - a;
eq = m[a[i]];
if (eq >= k) {
cout << 0;
return;
}
lg = n - sm - eq;
smc = (a[i] - 1) * sm - (sm ? p[sm - 1] : 0);
if (sm + eq >= k) ans = min(ans, max(0LL, smc + k - eq));
lgc = (lg != 0 ? s[n - lg] : 0) - (a[i] + 1) * lg;
if (lg + eq >= k) ans = min(ans, max(0LL, lgc + k - eq));
ans = min(ans, max(0LL, smc + lgc + k - eq));
}
cout << ans;
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin.tie(NULL);
{ get_ac(); }
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxx = 2e5 + 100;
int a[maxx], num[maxx], cnt[maxx];
long long pre[maxx], suf[maxx], pcnt[maxx], scnt[maxx];
int n, k;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
int S = 0, m = 1;
for (int i = 1; i <= n; i++) {
S++;
if (a[i] != a[i + 1]) {
m++;
num[m] = a[i], cnt[m] = S;
S = 0;
}
}
for (int i = 2; i <= m; i++) {
pre[i] = pre[i - 1] + pcnt[i - 1] * (num[i] - num[i - 1]) +
cnt[i - 1] * (num[i] - num[i - 1] - 1);
pcnt[i] = pcnt[i - 1] + cnt[i - 1];
}
for (int i = m - 1; i >= 1; i--) {
suf[i] = suf[i + 1] + scnt[i + 1] * (num[i + 1] - num[i]) +
cnt[i + 1] * (num[i + 1] - num[i] - 1);
scnt[i] = scnt[i + 1] + cnt[i + 1];
}
long long ans = 1e18;
for (int i = 1; i <= m; i++) {
int res = k - cnt[i];
if (res <= 0) {
puts("0");
return 0;
}
if (i > 1 && i < m) ans = min(ans, pre[i] + suf[i] + res);
if (i > 1 && pcnt[i] >= res) ans = min(ans, pre[i] + res);
if (i < m && scnt[i] >= res) ans = min(ans, suf[i] + res);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
long long v[MAXN];
long long pre[MAXN], pos[MAXN];
long long q[MAXN], qp[MAXN];
signed main() {
memset(q, 0, sizeof q);
memset(qp, 0, sizeof qp);
long long n, k;
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> v[i];
sort(v + 1, v + n + 1);
v[0] = 0;
v[n + 1] = 0;
long long soma = 0;
for (long long i = 1; i <= n; i++) {
if (v[i] != v[i - 1]) {
soma += q[i - 1];
soma += (i - 1) * (v[i] - v[i - 1] - 1);
q[i] = i - 1;
} else
q[i] = q[i - 1];
pre[i] = soma;
}
soma = 0;
for (long long i = n; i >= 1; i--) {
if (v[i] != v[i + 1]) {
soma += qp[i + 1];
soma += (n - i) * (v[i + 1] - v[i] - 1);
qp[i] = n - i;
} else
qp[i] = qp[i + 1];
pos[i] = soma;
}
long long resp = -1;
for (long long i = 1; i <= n; i++) {
long long res = -1;
if (i >= k) {
long long h = i - q[i];
if (h >= k)
res = 0;
else
res = pre[i] + k - h;
}
if (n - i + 1 >= k) {
long long h = n - i + 1 - qp[i];
if (h >= k)
res = 0;
else if (res == -1)
res = pos[i] + k - h;
else
res = min(res, pos[i] + k - h);
}
long long h = n - qp[i] - q[i];
if (res == -1)
res = pos[i] + pre[i] + max(k - h, (long long)0);
else
res = min(res, pos[i] + pre[i] + max(k - h, (long long)0));
if (resp == -1)
resp = res;
else
resp = min(resp, res);
}
cout << resp << endl;
}
|
#include <bits/stdc++.h>
using ll = int64_t;
int main() {
using namespace std;
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n, k;
cin >> n >> k;
vector<int> a(n);
vector<vector<int>> dp(n, vector<int>(200010, -1));
int x, maxX = 0;
for (int i = 0, iLen = (n); i < iLen; ++i) {
cin >> x;
maxX = max(maxX, x);
a[i] = x;
dp[i][x] = 0;
while (true) {
dp[i][x / 2] = dp[i][x] + 1;
x /= 2;
if (x == 0) break;
}
}
int ans = 10000000;
for (int i = 0, iLen = (maxX + 1); i < iLen; ++i) {
auto hoge = vector<int>();
for (int j = 0, jLen = (n); j < jLen; ++j)
if (dp[j][i] > -1) hoge.emplace_back(dp[j][i]);
if (hoge.size() < k) continue;
sort(hoge.begin(), hoge.end());
int total = 0;
for (int j = 0, jLen = (k); j < jLen; ++j) total += hoge[j];
ans = min(ans, total);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Tree {
static const ll LOW = 0;
ll f(ll a, ll b) { return a + b; }
vector<ll> s;
int n;
Tree(int n = 0, ll def = 0) : s(2 * n, def), n(n) {}
void update(int pos, ll val) {
for (s[pos += n] = val; pos > 1; pos /= 2)
s[pos / 2] = f(s[pos & (~1)], s[pos | 1]);
}
ll query(int b, int e) {
if (b >= e) return 0;
ll ra = LOW, rb = LOW;
for (b += n, e += n; b < e; b /= 2, e /= 2) {
if (b % 2) ra = f(ra, s[b++]);
if (e % 2) rb = f(s[--e], rb);
}
return f(ra, rb);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n, k;
cin >> n >> k;
Tree rage(n, 1);
ll a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) rage.update(i, a[i]);
ll out = ((ll)1) << 62;
ll cnt = 1;
ll begin = 0;
for (int i = 0; i < n; i++) {
if (i >= 1 && a[i - 1] != a[i]) {
cnt = 1;
begin = i;
}
if (i < n - 1 && a[i] == a[i + 1]) {
cnt++;
continue;
}
ll local = ((ll)1) << 62;
ll needed = k - cnt;
ll target = a[i];
if (needed <= 0) {
cout << 0 << endl;
return 0;
}
ll leftside = rage.query(0, begin);
leftside = abs(begin * (target - 1) - leftside);
ll rightside = rage.query(i + 1, n);
rightside = abs(rightside - (n - (i + 1)) * (target + 1));
local = min(local, leftside + rightside + needed);
if (begin >= needed) {
local = min(local, leftside + needed);
}
if (i < (n - needed)) {
local = min(local, rightside + needed);
}
out = min(out, local);
}
cout << out << endl;
}
|
#include <bits/stdc++.h>
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, -1, 1};
long long mod = 1000000007;
using namespace std;
bool isPrime(long long n) {
long long j;
for (j = 2; j <= sqrt(n); j++) {
if (n % j == 0) {
break;
}
}
if (j > sqrt(n)) {
return 1;
} else {
return 0;
}
}
long long modexpo(long long a, long long b) {
long long ans = 1;
a = a % mod;
while (b > 0) {
if ((b & 1) == 1) {
ans = ((ans % mod) * (a % mod)) % mod;
}
b = b >> 1;
a = ((a % mod) * (a % mod)) % mod;
}
return ans;
}
long long invmod(long long n) { return modexpo(n, mod - 2); }
long long comb(long long n, long long r) {
if (r == 0) {
return 1;
}
long long fact[n + 1];
fact[0] = 1;
for (long long i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
return (fact[n] * invmod(fact[r]) % mod * invmod(fact[n - r]) % mod) % mod;
}
long long gcd(long long a, long long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
set<long long> adj[100005];
vector<long long> ans;
bool vis[100005];
void dfs(long long i) {
ans.push_back(i);
vis[i] = 1;
for (auto j : adj[i]) {
if (vis[j] == 0) {
bool ok = 0, ok1 = 0;
for (auto h : adj[j]) {
if (i == h) {
ok = 1;
}
if (h == ans[(int)ans.size() - 2]) {
ok1 = 1;
}
}
if (ok == 1 && ok1 == 1) {
dfs(j);
}
}
}
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return a.second < b.second;
}
void solve(long long k) {
long long n, d;
cin >> n >> d;
long long a[n];
vector<vector<long long>> v(200005);
for (long long i = 0; i < n; i++) {
cin >> a[i];
long long h = a[i], c = 0;
while (h > 0) {
v[h].push_back(c);
h /= 2;
c++;
}
}
sort(a, a + n);
long long ans = 10000000;
for (long long i = 0; i < 200005; i++) {
sort(v[i].begin(), v[i].end());
if (int(v[i].size()) < d) continue;
ans = min(ans, accumulate(v[i].begin(), v[i].begin() + d, 0ll));
}
long long r = 0;
for (long long i = 0; i < d; i++) {
long long f = a[i];
while (f > 0) {
r++;
f /= 2;
}
}
cout << min(ans, r) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
long long k = 1;
while (k <= t) {
solve(k);
k++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, k, i;
cin >> n >> k;
long long int a[n];
map<long long int, long long int> m;
for (i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a, a + n);
long long int ans[200005] = {};
for (i = 0; i < n; i++) {
if (k <= m[a[i]]) {
cout << 0;
return 0;
}
long long int x = a[i], y = 0;
while (x) {
x /= 2;
y++;
if (m.find(x) == m.end() || m[x] < k) {
m[x]++;
ans[x] += y;
}
}
}
long long int mins = LLONG_MAX;
for (i = 0; i < 200005; i++) {
if (m.find(i) != m.end() && m[i] >= k) mins = min(mins, ans[i]);
}
cout << mins;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j, k, n, m, p, q, t, ans = LLONG_MAX, sum = 0, ct = 0, flag = 0;
cin >> n >> k;
std::vector<long long> v(n);
multiset<long long> st;
std::vector<long long> v1, v2;
for (i = 0; i < n; i++) {
cin >> v[i];
st.insert(v[i]);
}
sort(v.begin(), v.end());
long long cost = 0, pct, low, high;
auto it1 = st.end();
long long num;
auto it2 = st.end();
for (j = 0; j < 200000; j++) {
cost = 0;
q = k;
for (i = 0; i < 20; i++) {
pct = (long long)pow(2, i);
low = pct * j;
high = low + pct - 1;
low--;
if (j == 0 && i > 0) {
low = (long long)pow(2, i - 1) - 1;
high = (long long)pow(2, i) - 1;
}
it2 = st.upper_bound(high);
it1 = st.upper_bound(low);
int dist = distance(it1, it2);
if (dist >= q) {
cost += q * i;
q = 0;
break;
} else {
cost += dist * i;
q -= dist;
}
if (q <= 0) break;
}
if (cost <= ans && q == 0) {
ans = cost;
num = j;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long q, n;
long long presum[200005], precant[200005];
map<long long, long long> freq;
vector<long long> ar;
long long cost(int id) {
long long k = ar[id];
pair<long long, long long> may, men;
men.first = precant[id];
men.second = (k - 1) * precant[id] - presum[id];
may.first = precant[n] - precant[id + 1];
may.second = presum[n] - presum[id + 1] - (k + 1) * may.first;
if (men.first >= q && may.first >= q) {
return min(may.second, men.second) + q;
} else if (men.first >= q) {
return men.second + q;
} else if (may.first >= q) {
return may.second + q;
} else {
return men.second + may.second + q;
}
}
int main() {
cin >> n >> q;
ar.resize(n);
for (int i = 0; i < n; i++) {
cin >> ar[i];
freq[ar[i]]++;
}
sort(ar.begin(), ar.end());
ar.resize(unique(ar.begin(), ar.end()) - ar.begin());
n = ar.size();
presum[0] = 0;
precant[0] = 0;
for (int i = 1; i <= n; i++) {
presum[i] = presum[i - 1] + ar[i - 1] * freq[ar[i - 1]];
precant[i] = precant[i - 1] + freq[ar[i - 1]];
}
long long mini = 1e18;
for (int i = 0; i < n; i++) {
q -= freq[ar[i]];
if (q <= 0) {
mini = 0;
continue;
}
mini = min(mini, cost(i));
q += freq[ar[i]];
}
cout << mini << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N];
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>> values(200 * 1000 + 11);
for (int i = 0; i < n; ++i) {
int x = a[i], cur = 0;
while (x > 0) {
values[x].push_back(cur);
x >>= 1;
++cur;
}
}
int ans = 1e9;
for (int i = 0; i <= 200 * 1000; ++i) {
sort(values[i].begin(), values[i].end());
if (int(values[i].size()) < k) continue;
ans = min(ans, accumulate(values[i].begin(), values[i].begin() + k, 0));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
map<long long, long long> mm;
long long arr[n];
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
mm[x]++;
arr[i] = x;
}
long long cur = 0;
sort(arr, arr + n);
for (long long i = 0; i < n; i++) {
long long j = i;
while (arr[j] == arr[i] && j < n) j++;
cur = max(cur, j - i);
i = j - 1;
}
cerr << cur << " " << k;
for (long long i = 0; i < n; i++) cerr << " " << arr[i];
if (cur >= k)
cout << "0";
else {
map<long long, long long> front;
map<long long, long long> back;
long long A = 0, B = 0;
auto itr = mm.begin();
long long mn = itr->first;
long long freq = itr->second;
long long cost = 0;
itr++;
for (; itr != mm.end(); itr++) {
long long val = itr->first;
long long FR = itr->second;
cost += (val - mn) * freq;
freq = FR + freq;
mn = val;
front[val] = cost;
if (freq >= k && A == 0) A = cost - (freq - k);
}
auto i = mm.rbegin();
long long mx = i->first;
freq = i->second;
i++;
long long costt = 0;
for (; i != mm.rend(); ++i) {
long long val = i->first;
long long FR = i->second;
costt += (mx - val) * freq;
freq = FR + freq;
mx = val;
back[val] = costt;
if (freq >= k && B == 0) B = costt - (freq - k);
}
long long ans = min(A, B);
for (long long i = 1; i < n - 1; i++) {
long long val = arr[i];
ans = min(ans, front[val] + back[val] - (n - k));
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LL_INF = (long long)2e18 + 5;
const int SIZE = 1e6 + 10;
long long n, k, K, res = LL_INF;
long long a[SIZE];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> K;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int tar = 0; tar <= a[n - 1]; tar++) {
for (int i = 0; i < n; i++) {
if (a[i] < tar) continue;
int j = i;
long long op = 0;
k = K;
for (j; k && j < n; j++) {
if (a[j] == tar)
k--;
else {
long long cnt = 0;
long long tmp = a[j];
while (tmp > tar) {
tmp /= 2;
cnt++;
}
if (tmp == tar) {
op += cnt;
k--;
}
}
}
if (k == 0) res = min(res, op);
break;
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
map<int, long long> fr;
long long cnt = 0, prefSum = 0, sum = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
sum += a;
fr[a]++;
}
long long ans = 1e18;
for (auto it : fr) {
if (it.second >= k) {
ans = 0;
break;
}
{
long long rem = k - it.second;
long long cur = (it.first - 1) * cnt - prefSum;
cur += min(rem, cnt);
if (cnt >= rem)
ans = min(ans, cur), rem = 0;
else
rem -= cnt;
cur += (sum - prefSum - it.first * 1LL * it.second) -
(it.first + 1) * (n - cnt - it.second);
cur += rem;
ans = min(ans, cur);
}
{
long long rem = k - it.second;
long long cur = (sum - prefSum - it.first * 1LL * it.second) -
(it.first + 1) * (n - cnt - it.second);
cur += min(rem, (n - cnt - it.second));
if ((n - cnt - it.second) >= rem)
ans = min(ans, cur), rem = 0;
else
rem -= (n - cnt - it.second);
cur += (it.first - 1) * cnt - prefSum;
;
cur += rem;
ans = min(ans, cur);
}
prefSum += it.second * 1LL * it.first;
cnt += it.second;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
const double PI = acos(-1.);
const int N = 2e5 + 5;
const int Ai = 5e5 + 5;
vector<int> ab[N];
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> ve;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
ve.push_back(x);
int temp = x;
int sum = 0;
while (temp) {
ab[temp].push_back(sum);
temp /= 2;
sum++;
}
}
for (int i = 1; i < N; i++) sort(ab[i].begin(), ab[i].end());
int res = 1e9;
for (int i = 1; i < N; i++) {
if (ab[i].size() < k) continue;
int sum = 0;
for (int j = 0; j < k; j++) sum += ab[i][j];
res = min(res, sum);
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
map<int, int> cnt;
for (int i = 0, x; i < n; ++i) {
cin >> x;
cnt[x] += 1;
}
vector<pair<int, int>> a;
for (auto p : cnt) {
a.push_back(p);
}
vector<pair<LL, int>> cl(a.size()), cr(a.size());
LL sum = 0, cc = 0;
for (int i = 0; i < a.size(); ++i) {
auto [x, y] = a[i];
cl[i] = {cc * (x - 1) - sum, cc};
sum += 1LL * x * y;
cc += y;
}
sum = 0;
cc = 0;
for (int i = (int)a.size() - 1; i >= 0; --i) {
auto [x, y] = a[i];
cr[i] = {sum - cc * (x + 1), cc};
sum += 1LL * x * y;
cc += y;
}
LL ans = numeric_limits<LL>::max();
for (int i = 0; i < (int)a.size(); ++i) {
if (a[i].second >= k) {
ans = 0;
break;
}
if (a[i].second + cl[i].second >= k) {
ans = min(ans, cl[i].first + k - a[i].second);
}
if (a[i].second + cr[i].second >= k) {
ans = min(ans, cr[i].first + k - a[i].second);
}
ans = min(ans, cl[i].first + cr[i].first + k - a[i].second);
}
cout << ans << '\n';
}
|
#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];
map<int, vector<int>> dist;
for (int i = 0; i < n; i++) {
int m = 0;
do {
dist[a[i]].push_back(m);
a[i] >>= 1;
m++;
} while (a[i] > 0);
}
int ans = (int)(1e18);
for (auto v : dist)
if (v.second.size() >= k) {
int S = 0;
sort(v.second.begin(), v.second.end());
for (int i = 0; i < k; i++) S += v.second[i];
ans = min(ans, S);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, co;
cin >> n >> k;
vector<pair<int, int>> li(200001, make_pair(0, 0));
vector<int> da(n);
for (int i = (0); i < (int)(n); i++) {
cin >> da[i];
li[da[i]].first++;
if (li[da[i]].first > k - 1) {
cout << 0 << endl;
return 0;
}
}
bool ju = true;
co = 0;
int ans = INT_MAX;
while (ju) {
co++;
ju = false;
for (int i = (0); i < (int)(n); i++) {
if (da[i]) {
da[i] /= 2;
li[da[i]].first++;
li[da[i]].second += co;
ju = true;
if (li[da[i]].first > k - 1) {
ans = min(ans, li[da[i]].second);
}
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
long long t, n, a, k, res = 1e18;
vector<long long> v[N];
int solve() {
scanf("%lld%lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &a);
long long cnt = 0;
v[a].push_back(cnt);
while (a) {
a /= 2;
cnt++;
v[a].push_back(cnt);
}
}
for (int i = 0; i <= 200000; i++) {
sort(v[i].begin(), v[i].end());
if ((long long)v[i].size() >= k) {
a = 0;
for (int j = 0; j < k; j++) {
a += v[i][j];
}
res = min(a, res);
}
}
printf("%lld\n", res);
return 0;
}
int main() { return solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 51, MOD = 998244353, inf = 0x3f3f3f3f;
struct BIT {
long long sz;
long long num[MAXN];
inline void add(long long pos, long long val) {
for (; pos <= sz; pos += pos & -pos) {
num[pos] += val;
}
}
inline long long query(long long pos) {
long long res = 0;
for (; pos; pos -= pos & -pos) {
res += num[pos];
}
return res;
}
};
BIT bit;
long long n, kk, flg, tot, sum, wyx, wyxkk, sm1, sm2, res;
long long x[MAXN], t[MAXN], num[MAXN], p[MAXN], c[MAXN];
inline long long read() {
register long long num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') neg = -1, ch = getchar();
while (isdigit(ch))
num = (num << 3) + (num << 1) + (ch - '0'), ch = getchar();
return neg == 1 ? num : -num;
}
inline long long int readu() {
register long long int num = 0;
register char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch))
num = (num << 3) + (num << 1) + (ch - '0'), ch = getchar();
return num;
}
template <class T>
inline void writep(T x) {
if (x < 0) {
return (void)putchar('-'), writep(-x);
}
if (x < 10) {
return (void)putchar(x | 48);
}
writep(x / 10), putchar((x % 10) | 48);
}
template <class T>
inline void write(T x, char ch = ' ') {
writep(x), putchar(ch);
}
template <class T>
inline void writeln(T x) {
writep(x), putchar('\n');
}
template <class T>
inline void chkmax(T &x, const T &y) {
x = x > y ? x : y;
}
template <class T>
inline void chkmin(T &x, const T &y) {
x = x < y ? x : y;
}
template <class T, class Compare>
inline void sort(vector<T> &v, Compare cmp = less<T>()) {
sort(v.begin(), v.end(), cmp);
}
template <class T>
inline void reverse(vector<T> &v) {
reverse(v.begin(), v.end());
}
template <class T>
inline void clear(T *arr) {
memset(arr, 0, sizeof(arr));
}
template <class T>
inline void setInf(T *arr) {
memset(arr, 0x3f, sizeof(arr));
}
inline long long qpow(long long base, long long exponent) {
long long int res = 1;
while (exponent) {
if (exponent & 1) {
res = (long long int)res * base % MOD;
}
base = (long long int)base * base % MOD, exponent >>= 1;
}
return res;
}
inline long long gcd(long long x, long long y) {
return !y ? x : gcd(y, x % y);
}
inline long long int lcm(long long x, long long y) { return x / gcd(x, y) * y; }
int main() {
n = bit.sz = read(), kk = read();
for (register int i = 1; i <= n; i++) {
sum += (x[i] = read());
}
sort(x + 1, x + n + 1);
for (register int i = 1; i <= n; i++) {
x[i] != x[i - 1] ? (p[i] = ++tot, num[tot] = i) : p[i] = tot;
bit.add(p[i], x[i]), t[tot]++;
}
num[++tot] = n + 1, res = 1e18;
for (register int i = 1; i <= n; i++) {
if (p[i] != p[i - 1]) {
wyx = num[p[i]] - 1, wyxkk = n - num[p[i] + 1] + 1;
sm1 = (x[i] - 1) * wyx - bit.query(p[i] - 1);
sm2 = sum - bit.query(p[i]) - (x[i] + 1) * wyxkk;
if (t[p[i]] >= kk) {
return puts("0"), 0;
}
flg = 1;
if (wyx + t[p[i]] >= kk) {
res = min(res, sm1 + kk - t[p[i]]), flg = 0;
}
if (wyxkk + t[p[i]] >= kk) {
res = min(res, sm2 + kk - t[p[i]]), flg = 0;
}
if (flg) {
res = min(res, sm1 + sm2 + kk - t[p[i]]);
}
}
}
printf("%lld\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 9;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<long long> pref(n, 0), suf(n, 0);
for (long long i = 1, sm = a[0]; i < n; i++) {
pref[i] = a[i] * i - sm;
sm += a[i];
}
for (long long i = n - 2, sm = a[n - 1]; i >= 0; i--) {
suf[i] = sm - a[i] * (n - i - 1);
sm += a[i];
}
long long ans = INF;
for (long long i = 0, j = 0; i < n; i = j) {
for (; j < n && a[j] == a[i]; j++)
;
long long prev = 0, forw = 0;
long long base = INF;
prev += pref[i];
prev -= i;
if (i >= k - j + i) base = min(base, prev);
forw += suf[j - 1];
forw -= (n - j);
if (n - j >= k - j + i) base = min(base, forw);
base = min(base, prev + forw);
ans = min(ans, base + k - (j - i));
if (j - i >= k) ans = 0;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NUM = 2e5 + 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int num_tests = 1;
while (num_tests-- > 0) {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (auto &i : a) cin >> i;
vector<int> moves[NUM];
for (int i = 0; i < n; i++) {
int make = a[i];
int curr = 0;
while (make > 0) {
moves[make].push_back(curr);
curr++;
make /= 2;
}
}
int ans = INT_MAX;
for (int i = 0; i < NUM; i++) {
if (moves[i].size() < k) continue;
sort(moves[i].begin(), moves[i].end());
int cnt = 0;
for (int j = 0; j < k; j++) cnt += moves[i][j];
ans = min(ans, cnt);
}
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6, INF = 1e9 + 7;
int n, k, a[N];
vector<pair<int, int> > g;
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];
g.push_back(make_pair(a[i], 0));
int c = 1;
while (a[i] > 0) {
g.push_back(make_pair(a[i] / 2, c));
c++, a[i] /= 2;
}
}
int ans = INF;
sort(g.begin(), g.end());
for (int i = 0, sum = 0, j = 0; i < (int)g.size(); i++) {
if (i == 0 || g[i].first != g[i - 1].first) {
sum = g[i].second, j = 1;
} else {
j += 1, sum += g[i].second;
}
if (j == k) {
ans = min(ans, sum);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T maxelement(T x, T y) {
return (x > y) ? x : y;
}
long long a[500005];
map<long long, long long> mp;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i, j, k, l, n;
cin >> n >> k;
set<long long> s;
for (i = 1; i <= n; i++) {
cin >> a[i];
mp[a[i]]++;
s.insert(a[i]);
}
vector<long long> elements(s.size() + 1, 0);
long long st = 1;
for (auto x : s) {
elements[st++] = x;
}
vector<long long> sum(s.size() + 1, 0);
vector<long long> fre(s.size() + 1, 0);
long long sz = s.size();
for (i = 1; i <= sz; i++) {
fre[i] = fre[i - 1] + mp[elements[i]];
sum[i] = sum[i - 1] + mp[elements[i]] * elements[i];
}
long long ans = 1e18;
for (i = 1; i <= sz; i++) {
long long req = max(0LL, k - mp[elements[i]]);
if (req == 0) {
cout << "0";
return 0;
}
if (fre[i - 1] >= req || ((fre[sz] - fre[i]) >= req)) {
long long Leftmini = 1e17;
long long Rightmini = 1e17;
if (fre[i - 1] >= req) {
Leftmini = min(Leftmini, fre[i - 1] * (elements[i] - 1) - sum[i - 1]);
Leftmini += req;
}
if (fre[sz] - fre[i] >= req) {
Rightmini = min(Rightmini, (sum[sz] - sum[i] -
(fre[sz] - fre[i]) * (elements[i] + 1)));
Rightmini += req;
}
ans = min(ans, min(Leftmini, Rightmini));
} else {
long long Leftmini = 0;
long long Rightmini = 0;
Leftmini = fre[i - 1] * (elements[i] - 1) - sum[i - 1];
Rightmini = sum[sz] - sum[i] - (fre[sz] - fre[i]) * (elements[i] + 1);
ans = min(ans, Leftmini + Rightmini + req);
}
}
cout << max(ans, 0LL) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const long long llINF = 0x3f3f3f3f3f3f3f3f;
inline bool read(long long &num) {
char in;
bool IsN = false;
in = getchar();
if (in == EOF) return false;
while (in != '-' && (in < '0' || in > '9')) in = getchar();
if (in == '-') {
IsN = true;
num = 0;
} else
num = in - '0';
while (in = getchar(), in >= '0' && in <= '9') {
num *= 10, num += in - '0';
}
if (IsN) num = -num;
return true;
}
long long a[N], x, n, k;
set<long long> st;
long long num[N], ti[N];
int main() {
read(n);
read(k);
for (int i = (1); i <= (n); i++) read(a[i]);
sort(a + 1, a + n + 1);
long long ans = 9999999999999;
for (int i = (1); i <= (n); i++) {
long long x = a[i];
int cnt = 0;
while (x) {
num[x]++;
ti[x] += cnt;
if (num[x] >= k) ans = min(ans, ti[x]);
cnt++;
x /= 2;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, p[200005], s[200005], a[200005];
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false), cin.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 0; i <= n - k; ++i) {
if (a[i] == a[i + k - 1]) return cout << 0, 0;
}
p[0] = a[0];
for (int i = 1; i < n; ++i) {
p[i] = a[i] + p[i - 1];
}
s[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; --i) {
s[i] = a[i] + s[i + 1];
}
long long j = 0, ans = LLONG_MAX;
for (int i = 0; i < n;) {
while (j < n && a[j] == a[i]) j++;
long long pans = 0, sans = 0, cnt = (j - i);
if (i == 0)
pans = LLONG_MAX;
else {
pans = i * (a[i] - 1) - p[i - 1];
pans += min(k - cnt, (long long)i);
if (j < k) {
pans += s[j] - (n - j) * (a[i] + 1);
pans += (k - j);
}
}
if (j == n)
sans = LLONG_MAX;
else {
sans = s[j] - (n - j) * (a[i] + 1);
sans += min(n - j, k - (j - i));
if (n - i < k) {
sans += i * (a[i] - 1) - p[i - 1];
sans += (k - (n - i));
}
}
ans = min(ans, min(sans, pans));
i = j;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 11;
long long a[N], s[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
int pos = 1;
long long ans = 2e18;
for (int i = 1; i <= n; i++)
if (a[i] != a[i + 1]) {
int kol = i - pos + 1;
if (kol >= k) {
ans = 0;
break;
}
if (i >= k) {
long long res = 0;
res += (a[i] - 1) * 1ll * (pos - 1) - s[pos - 1];
res += k - kol;
ans = min(ans, res);
}
if (kol + n - i >= k) {
long long res = 0;
res += s[n] - s[i] - (a[i] + 1) * 1ll * (n - i);
res += k - kol;
ans = min(ans, res);
}
long long res = 0;
res += (a[i] - 1) * 1ll * (pos - 1) - s[pos - 1];
res += s[n] - s[i] - (a[i] + 1) * 1ll * (n - i);
res += k - kol;
ans = min(ans, res);
pos = i + 1;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, k, a[N];
long long s[N], ans = 1e18, pre[N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = n; i >= 1; i--) pre[i] = pre[i + 1] + a[i];
for (int i = 1; i <= n; i++) {
s[i] = s[i - 1] + a[i];
if (i >= k && a[i] == a[i - k + 1]) return cout << 0, 0;
}
for (int i = 1, j; i <= n; i = j) {
j = i;
while (j + 1 <= n && a[j + 1] == a[i]) ++j;
int x = i - 1, y = n - j, z = j - i + 1;
if (z + x >= k) {
ans = min(ans, -s[x] + 1ll * x * a[i] - (x - (k - z)));
}
if (y + z >= k) {
ans = min(ans, pre[j + 1] - 1ll * y * a[j] - (y - (k - z)));
}
ans = min(ans, -s[x] + 1ll * x * a[i] + pre[j + 1] - 1ll * y * a[j] -
(x + y - (k - z)));
++j;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
using ll = long long;
int a[N];
ll pre[N];
void solve() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i];
ll ans = LLONG_MAX;
for (int l = 1, r; l <= n; l = r) {
r = l;
while (r <= n && a[r] == a[l]) r++;
ll cnt = r - l;
if (cnt >= k) {
ans = 0;
break;
}
ll need = k - cnt;
ll l_target = a[l] - 1;
ll l_cnt = l - 1;
ll l_base = l_cnt * l_target - pre[l - 1];
ll r_target = a[l] + 1;
ll r_cnt = n + 1 - r;
ll r_base = pre[n] - pre[r - 1] - r_cnt * r_target;
if (l_cnt >= need) {
ans = min(ans, l_base + need);
}
if (r_cnt >= need) {
ans = min(ans, r_base + need);
}
ans = min(ans, l_base + r_base + need);
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int a[200005] = {0}, ci[200005] = {0}, now[200005] = {0};
int main() {
int n, kk;
scanf("%d", &n), scanf("%d", &kk);
int ans = 0x3f3f3f3f;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
now[a[i]]++;
if (now[a[i]] >= kk) ans = 0;
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
int temp = a[i];
int k = 1;
while (temp != 0) {
temp /= 2;
ci[temp] += k;
now[temp]++;
if (now[temp] >= kk) ans = min(ci[temp], ans);
k++;
}
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
const long long N = 100005;
using namespace std;
void pairsort(long long a[], long long b[], long long n) {
pair<long long, long long> pairt[n];
for (long long i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
bool isPrime(long long n) {
if (n < 2) return 0;
for (long long i = 2; i <= sqrt(n); i++) {
if (n % i == 0) return 0;
}
return 1;
}
long long factorial(long long n) {
long long i = 1;
for (long long j = 1; j <= n; j++) i *= j;
return i;
}
long long nCr(long long n, long long r) {
return factorial(n) / (factorial(r) * factorial(n - r));
}
long double modd(long double x) {
if (x >= 0) return x;
return -1 * x;
}
long long dp(long long y) {
long long s = 0;
while (y != 0) {
long long r = y % 10;
s += r;
y /= 10;
}
if (s % 10 == 0) return 1;
return 0;
}
long long sd(long long n) {
long long s = 0;
while (n != 0) {
s += n % 10;
n /= 10;
}
return s;
}
long long mod = 998244353;
long long modexpo(long long x, unsigned long long y) {
long long res = 1;
x = x % mod;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
long long ps(long long n) {
long double x = (long double)n;
if (ceil(sqrt(x)) == floor(sqrt(x))) return 1;
return 0;
}
vector<long long> adj[N];
vector<long long> cost;
long long src, des, w, u, v;
vector<long long> vis;
vector<long long> dist, res, parent;
long long n, k;
long long p = 1;
void dfs(long long x) {
vis[x] = 1;
for (long long i = 0; i < adj[x].size(); i++) {
if (!vis[adj[x][i]]) {
dfs(adj[x][i]);
}
}
}
void bfs() {
long long s = 1;
queue<long long> q;
q.push(s);
parent[s] = 1;
vis[s] = 1;
while (!q.empty()) {
s = q.front();
q.pop();
for (long long i = 0; i < adj[s].size(); i++) {
if (!vis[adj[s][i]]) {
q.push(adj[s][i]);
vis[adj[s][i]] = 1;
parent[adj[s][i]] = s;
}
}
}
}
long long g, h;
bool prime[1000005];
vector<long long> pp;
void sieve() {
memset(prime, true, sizeof(prime));
long long n = 1000005;
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
long long mod1(string num, long long a) {
long long res = 0;
for (long long i = 0; i < num.length(); i++)
res = (res * 10 + (long long)num[i] - '0') % a;
return res;
}
long long reach(long long x, long long y) {
while (x != 0) {
if (x == y) return 1;
x /= 2;
}
if (x == y) return 1;
return 0;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long ma = *max_element(a, a + n);
vector<map<long long, long long> > vv;
for (long long i = 0; i < n; i++) {
map<long long, long long> ans;
long long x = a[i];
long long ct = 0;
ans[x] = 0;
while (x != 0) {
ct++;
x /= 2;
ans[x] = ct;
}
ans[x] = ct;
vv.push_back(ans);
}
long long mi = 1e9, temp = 0;
for (long long i = 0; i <= ma; i++) {
temp = 0;
vector<long long> xx;
for (long long j = 0; j < n; j++) {
if (reach(a[j], i) == 1) xx.push_back(vv[j][i]);
}
sort(xx.begin(), xx.end());
if (xx.size() >= k) {
for (long long j = 0; j < k; j++) temp += xx[j];
mi = (mi < temp ? mi : temp);
}
}
cout << mi;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
int n, k, a;
int vis_time[MAX], vis_cnt[MAX], ans;
struct data {
int size, op;
bool operator<(data b) const {
if (size == b.size)
return op > b.op;
else
return size < b.size;
}
};
priority_queue<data> line;
int main() {
scanf("%d%d", &n, &k);
for (register int i = 1; i <= n; ++i) {
scanf("%d", &a);
line.push((data){a, 0});
}
ans = 0x3f3f3f3f;
while (!line.empty()) {
data tmp = line.top();
line.pop();
int size = tmp.size, op = tmp.op;
vis_time[size]++;
vis_cnt[size] += op;
if (vis_time[size] == k) {
ans = min(ans, vis_cnt[size]);
}
if (!size)
continue;
else
line.push((data){size / 2, op + 1});
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, mn = 999999999, x;
long long p[200009][20];
void solve() {
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> x;
int z = 0;
while (x > 0) {
p[x][z]++;
z++;
x /= 2;
}
}
for (long long i = 1; i < 200009; i++) {
long long y = m, an = 0;
for (long long j = 0; j < 20; j++) {
if (p[i][j] < y)
y -= p[i][j], an = an + j * p[i][j];
else {
an = an + j * y;
y = 0;
break;
}
}
if (y == 0) mn = min(mn, an);
}
cout << mn;
}
int main() {
long long t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T& a, const T& b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename T>
T integer_partition_point(T l, T r, const function<bool(T)>& predicate) {
while (r - l > 1) {
T m = (l + r) / 2;
if (predicate(m)) {
l = m;
} else {
r = m;
}
}
return l;
}
template <typename T>
T argminimal(const function<T(T)>& f, T l, T r) {
while (r - l > 1) {
T m = (l + r) / 2;
if (f(m) - f(m - 1) < 0) {
l = m;
} else {
r = m;
}
}
return l;
}
template <typename T>
T minimal(const function<T(T)>& f, T l, T r) {
return f(argminimal<T>(f, l, r));
}
template <typename T>
T argmaximal(const function<T(T)>& f, T l, T r) {
while (r - l > 1) {
T m = (l + r) / 2;
if (f(m) - f(m - 1) > 0) {
l = m;
} else {
r = m;
}
}
return l;
}
template <typename T>
T maximal(const function<T(T)>& f, T l, T r) {
return f(argmaximal<T>(f, l, r));
}
double argminimal(const function<double(double)>& f, double l, double r,
int iter = 80) {
for (int i = 0; i < iter; ++i) {
double c1 = (l * 2 + r) / 3, c2 = (l + r * 2) / 3;
if (f(c1) > f(c2)) {
l = c1;
} else {
r = c2;
}
}
return l;
}
double minimal(const function<double(double)>& f, double l, double r,
int iter = 80) {
return f(argminimal(f, l, r, iter));
}
double argmaximal(const function<double(double)>& f, double l, double r,
int iter = 80) {
for (int i = 0; i < iter; ++i) {
double c1 = (l * 2 + r) / 3, c2 = (l + r * 2) / 3;
if (f(c1) > f(c2)) {
r = c2;
} else {
l = c1;
}
}
return l;
}
double maximul(const function<double(double)>& f, double l, double r,
int iter = 80) {
return f(argmaximal(f, l, r, iter));
}
int main() {
int n, k;
cin >> n >> k;
vector<long long> a(n);
map<int, long long> hist;
for (int i = 0; i < (int)(n); ++i) {
scanf("%lld", &a[i]);
++hist[a[i]];
}
for (auto& p : hist) {
if (p.second >= k) {
cout << 0 << endl;
return 0;
}
}
const long long INF = 1e18;
long long ans = 1e18;
long long u =
integer_partition_point<long long>(0, 1e9 + 1, [&](long long m) {
int c = count_if((a).begin(), (a).end(), [&](int v) { return v >= m; });
return c >= k;
});
chmin(ans, accumulate((a).begin(), (a).end(), k - hist[u],
[&](long long a, long long e) {
return a + max(e - (u + 1), 0LL);
}));
long long d =
integer_partition_point<long long>(0, 1e9 + 1, [&](long long m) {
int c = count_if((a).begin(), (a).end(), [&](int v) { return v <= m; });
return c < k;
});
++d;
chmin(ans, accumulate((a).begin(), (a).end(), k - hist[d],
[&](long long a, long long e) {
return a + max(d - 1 - e, 0LL);
}));
auto sandCost = [&](long long m) -> long long {
return accumulate((a).begin(), (a).end(), k - hist[m],
[&](long long a, long long e) {
a += max(e - (m + 1), 0LL);
a += max(m - 1 - e, 0LL);
return a;
});
};
chmin(ans, minimal<long long>(sandCost, 0, 1e9 + 1));
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int nums[55];
int divs(int num, int target) {
if (num < target) return 0x3f3f3f3f;
if (num == target) return 0;
return 1 + divs(num / 2, target);
}
int main() {
cin >> n >> k;
int max_num = 0;
for (int i = 0; i < n; i++) {
cin >> nums[i];
max_num = max(max_num, nums[i]);
}
int ans = 0x3f3f3f3f;
for (int j = 0; j <= max_num; j++) {
vector<int> qtd_div;
for (int i = 0; i < n; i++) {
int log_2 = divs(nums[i], j);
qtd_div.push_back(log_2);
}
sort(qtd_div.begin(), qtd_div.end());
int swap_min = 0;
bool is_valid = true;
for (int i = 0; i < k && is_valid; i++) {
is_valid = qtd_div[i] < 212345;
if (!is_valid) break;
swap_min += qtd_div[i];
}
if (!is_valid) continue;
ans = min(ans, swap_min);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, i, j, m, a[200008], c[200008];
int main() {
for (scanf("%I64d%I64d", &n, &k); i++ < n; scanf("%I64d", a + i))
;
for (sort(a + 1, a + n + 1), i = 0; i++ < n; c[i] = c[i - 1] + a[i])
;
for (i = n - k; i++ < n; m += a[i] - a[n + 1 - k])
;
for (i = n + 1 - k; a[n + 1 - k] == a[--i]; --m)
;
for (i = 0; i++ < k; j += a[k] - a[i])
;
for (i = k; a[k] == a[++i]; --j)
;
for (j < m ? m = j : 0, i = 1; i <= n && 0 < m;
j < i + k ? m = min(m, c[n] - (c[i] << 1) + a[i] * (i + i - n) + k - n)
: m = 0,
i = j)
for (j = i; a[i] == a[++j];)
;
printf("%I64d\n", m < 0 ? 0 : m), exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int binaryExponentiation(long long int x, long long int n) {
if (x == 0) return 0;
if (n == 0)
return 1;
else if (n % 2 == 0)
return binaryExponentiation(x * x, n / 2);
else
return x * binaryExponentiation(x * x, (n - 1) / 2);
}
long long int modularExponentiation(long long int x, long long int n,
long long int M) {
if (x == 0) return 0;
if (n == 0)
return 1;
else if (n % 2 == 0)
return modularExponentiation((x * x) % M, n / 2, M);
else
return (x * modularExponentiation((x * x) % M, (n - 1) / 2, M)) % M;
}
bool prime_check(long long x) {
bool prime = (x >= 2);
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
prime = false;
break;
}
}
return prime;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
long long arr[n];
long long val[n];
for (long long int i = 1; i < n + 1; i++) {
cin >> arr[i - 1];
}
sort(arr, arr + n);
long long mini = 1000000000000000000;
for (long long int i = 0; i < arr[n - 1] + 1; i++) {
long long s = 0;
long long c = 0;
for (long long int j = 0; j < n; j++) {
c = 0;
long long x = arr[j];
if (x < i)
val[j] = INT_MAX;
else {
while (x >= i) {
if (x == i) {
val[j] = c;
break;
}
c++;
x /= 2;
if (x < i) val[j] = INT_MAX;
}
}
}
sort(val, val + n);
for (long long int j = 0; j < k; j++) {
s += val[j];
}
mini = min(mini, s);
}
cout << mini << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void setIO(string name) {
freopen((name + ".in").c_str(), "r", stdin);
freopen((name + ".out").c_str(), "w", stdout);
}
const int MN = 200 * 1e3 + 5, LN = 17, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
int a[MN];
long long ps[MN];
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) ps[i] = ps[i - 1] + a[i];
long long mn = LLONG_MAX;
for (int i = 1, j = 1; i <= n; i = j) {
for (; j <= n && a[j] == a[i]; j++)
;
long long c = j - i;
if (c >= k) {
mn = 0;
break;
}
if (i - 1 >= k - c)
mn = min(mn, (i - 1) * ((long long)a[i] - 1) - ps[i - 1] + k - c);
if (n - j + 1 >= k - c)
mn = min(mn, -(n - j + 1) * ((long long)(a[i] + 1)) + ps[n] - ps[j - 1] +
k - c);
mn = min(mn, (i - 1) * ((long long)a[i] - 1) - ps[i - 1] -
(n - j + 1) * ((long long)(a[i] + 1)) + ps[n] - ps[j - 1] +
k - c);
}
cout << mn << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1919810], m[1919810], s[1919810], n, k, minn = 1234567890, maxx;
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
maxx = max(maxx, a[i]);
m[a[i]]++;
if (m[a[i]] == k) exit(0 & puts("0"));
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
int step = 0;
while (a[i] != 0) {
a[i] >>= 1, ++step;
if (m[a[i]] == k) continue;
++m[a[i]], s[a[i]] += step;
}
if (a[i] == 0) ++m[0], s[0] += step;
}
int ans = 999999999;
for (int i = 1; i <= maxx; i++)
if (m[i] >= k) ans = min(ans, s[i]);
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll getForwardAns(vector<int> arr, int k) {
map<int, int> eqCountIfTakenHere;
map<int, ll> stepsNeeded;
map<int, int> outsiders;
int n = arr.size();
vector<int> outsiderPerElem(n);
vector<ll> forwardCC(n);
for (ll i = 1; i < n; ++i) {
forwardCC[i] = forwardCC[i - 1] + i * abs(arr[i] - arr[i - 1]);
}
for (int i = 0; i < n; ++i) {
if (i > 0 && arr[i] != arr[i - 1])
outsiderPerElem[i] = i;
else if (i > 0)
outsiderPerElem[i] = outsiderPerElem[i - 1];
}
for (int i = 0; i < n; ++i) {
eqCountIfTakenHere[arr[i]] = i + 1;
stepsNeeded[arr[i]] = forwardCC[i];
outsiders[arr[i]] = outsiderPerElem[i];
}
ll ans = 1e18;
for (int x : arr) {
if (eqCountIfTakenHere[x] < k) continue;
int core = eqCountIfTakenHere[x] - outsiders[x];
if (core >= k) {
ans = 0;
} else {
int needed = k - core;
ans = min(ans, stepsNeeded[x] - outsiders[x] + needed);
}
}
return ans;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
vector<int> arr(n);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
sort(begin(arr), end(arr));
ll ans = 0;
int medOutsiders = 0;
for (int i = 0; i < n; ++i) {
ans += abs(arr[i] - arr[n / 2]);
if (arr[i] != arr[n / 2]) ++medOutsiders;
}
if (n - medOutsiders < k) {
int needed = k - (n - medOutsiders);
ans += (needed - medOutsiders);
} else {
ans = 0;
}
ans = min(ans, getForwardAns(arr, k));
reverse(begin(arr), end(arr));
ans = min(ans, getForwardAns(arr, k));
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<vector<int>> v(MAXN);
int ans = 1e9 + 10;
for (long long i = 0; i < n; i++) {
int a;
cin >> a;
int curr = 0;
while (a > 0) {
v[a].push_back(curr);
a /= 2;
curr++;
}
}
for (long long i = 0; i < MAXN; i++) {
if (v[i].size() < k) continue;
sort(v[i].begin(), v[i].end());
int ac = 0;
for (long long j = 0; j < k; j++) ac += v[i][j];
ans = min(ans, ac);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int N = 200005;
int n, k, i, a, miss, s, s2, last;
long long sum, res;
map<int, int> mapa;
map<int, int>::iterator it;
map<int, int>::reverse_iterator rit;
map<int, long long> low, high;
int main() {
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &a);
mapa[a]++;
}
for (auto& w : mapa)
if (w.second >= k) {
printf("0\n");
return 0;
}
s = 0;
s2 = 0;
last = -1;
sum = 0;
for (it = mapa.begin(); it != mapa.end(); it++) {
sum += (it->first - last) * 1LL * s;
sum += (it->first - last - 1) * 1LL * s2;
low[it->first] = sum;
if (last != -1) s += mapa[last];
s2 = it->second;
last = it->first;
}
s = 0;
s2 = 0;
last = -1;
sum = 0;
for (rit = mapa.rbegin(); rit != mapa.rend(); rit++) {
sum += (last - rit->first) * 1LL * s;
sum += (last - 1 - rit->first) * 1LL * s2;
high[rit->first] = sum;
if (last != -1) s += mapa[last];
s2 = rit->second;
last = rit->first;
}
res = INF * 1LL * INF;
s = 0;
for (auto& w : mapa) {
miss = k - w.second;
if (w.second + s >= k) res = min(res, low[w.first] + miss);
if (n - s >= k) res = min(res, high[w.first] + miss);
res = min(res, low[w.first] + high[w.first] + miss);
s += w.second;
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll md = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n, k;
cin >> n >> k;
vector<ll> a(n);
for (ll i = 0; i < n; i++) {
cin >> a[i];
}
map<ll, priority_queue<ll>> mp;
map<ll, ll> sum;
for (ll i = 0; i < n; i++) {
ll cur = a[i];
ll op = 0;
while (1) {
if (mp[cur].size() < k) {
mp[cur].push(op);
sum[cur] += op;
} else {
ll tp = mp[cur].top();
if (tp > op) {
sum[cur] -= tp;
sum[cur] += op;
mp[cur].pop();
mp[cur].push(op);
}
}
cur >>= 1;
op++;
if (cur == 0) {
if (mp[cur].size() < k) {
mp[cur].push(op);
sum[cur] += op;
} else {
ll tp = mp[cur].top();
if (tp > op) {
sum[cur] -= tp;
sum[cur] += op;
mp[cur].pop();
mp[cur].push(op);
}
}
break;
}
}
}
ll ans = 1e18;
for (auto i : mp) {
priority_queue<ll> pq = i.second;
if ((ll)pq.size() < k) {
continue;
}
ans = min(ans, sum[i.first]);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 200100, INF = 0x3f3f3f3f3f3f3f3f;
long long n, k, v[MAXN], pfxcnt[MAXN], pfxsum[MAXN], sfxcnt[MAXN], sfxsum[MAXN],
ans = INF;
vector<pair<long long, long long>> a;
signed main() {
scanf("%lld %lld", &n, &k);
for (long long i = 1; i <= n; i++) scanf("%lld", &v[i]);
sort(v + 1, v + 1 + n);
for (long long i = 1, cnt = 0; i <= n + 1; i++) {
if (i != 1 && v[i] != v[i - 1]) a.emplace_back(v[i - 1], cnt), cnt = 0;
cnt++;
}
pfxcnt[0] = a[0].second, pfxsum[0] = a[0].first * a[0].second;
for (long long i = 1; i < (long long)a.size(); i++)
pfxcnt[i] = pfxcnt[i - 1] + a[i].second,
pfxsum[i] = pfxsum[i - 1] + a[i].first * a[i].second;
sfxcnt[a.size() - 1] = a[a.size() - 1].second,
sfxsum[a.size() - 1] =
a[a.size() - 1].first * a[a.size() - 1].second;
for (long long i = (long long)a.size() - 2; i >= 0; i--)
sfxcnt[i] = sfxcnt[i + 1] + a[i].second,
sfxsum[i] = sfxsum[i + 1] + a[i].first * a[i].second;
for (long long i = 0; i < a.size(); i++) {
long long val = a[i].first, freq = a[i].second;
long long need = max(0ll, k - freq), curl = 0, curr = 0;
if (need == 0) ans = 0;
if (pfxcnt[i - 1] + sfxcnt[i + 1] < need || need == 0) continue;
if (pfxcnt[i - 1] >= need) {
curl = (val - 1) * pfxcnt[i - 1] - pfxsum[i - 1] + need;
} else {
curl = val * pfxcnt[i - 1] - pfxsum[i - 1] +
(1e9 - val - 1) * sfxcnt[i + 1] -
(1e9 * sfxcnt[i + 1] - sfxsum[i + 1]) + (need - pfxcnt[i - 1]);
}
if (sfxcnt[i + 1] >= need) {
curr = ((1e9 - val - 1) * sfxcnt[i + 1]) - (1e9 * sfxcnt[i + 1]) +
sfxsum[i + 1] + need;
} else {
curr = (1e9 - val) * sfxcnt[i + 1] -
(1e9 * sfxcnt[i + 1] - sfxsum[i + 1]) + (val - 1) * pfxcnt[i - 1] -
pfxsum[i - 1] + (need - sfxcnt[i + 1]);
}
ans = min({ans, curl, curr});
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[202020];
long long l[202020], r[202020];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 2; i <= n; i++)
if (a[i] == a[i - 1])
l[i] = l[i - 1];
else
l[i] = l[i - 1] + 1LL * (i - 1) * (a[i] - a[i - 1]);
for (int i = n - 1; i >= 1; i--)
if (a[i] == a[i + 1])
r[i] = r[i + 1];
else
r[i] = r[i + 1] + 1LL * (n - i) * (a[i + 1] - a[i]);
long long ans = (1LL << 62);
for (int i = 1; i <= n; i++) {
int save = i;
while (a[i] == a[i + 1]) i++;
int cnt = i - save + 1;
if (cnt >= k) {
ans = 0;
break;
}
long long ans1 = r[i + 1] + 1LL * (a[i + 1] - a[i] - 1) * (n - i);
int cnt1 = n - i;
if (cnt + cnt1 >= k) {
ans1 += k - cnt;
} else {
ans1 += l[save - 1] + 1LL * (a[save] - a[save - 1] - 1) * (save - 1);
ans1 += k - cnt;
}
long long ans2 =
l[save - 1] + 1LL * (a[save] - a[save - 1] - 1) * (save - 1);
int cnt2 = save - 1;
if (cnt + cnt2 >= k)
ans2 += k - cnt;
else {
ans2 += r[i + 1] + 1LL * (a[i + 1] - a[i] - 1) * (n - i);
ans2 += k - cnt;
}
ans = min(ans, min(ans1, ans2));
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long expo(long long x, long long n, long long m) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return expo((x * x) % m, n / 2, m);
else
return (x * expo((x * x) % m, (n - 1) / 2, m)) % m;
}
int arr[200005];
int steps[200005];
void solve() {
vector<int> v;
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
v.push_back(t);
}
int a;
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
a = v[i];
arr[a] = arr[a] + 1;
int j = 1;
while (a != 0) {
a /= 2;
arr[a]++;
if (arr[a] <= k) {
steps[a] += j;
}
j++;
}
}
int ans = 2147483647;
for (int i = 1; i <= 200005; i++)
if (arr[i] >= k) ans = min(ans, steps[i]);
cout << ans << endl;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<int, int>;
const int mod = 998244353;
const int inf = 1 << 30;
const int maxn = 200000 + 5;
int n, k, a[maxn];
ll pre[maxn], suf[maxn];
int main() {
scanf("%d%d", &n, &k);
map<int, int> cnt;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
cnt[a[i]]++;
}
for (auto& x : cnt) {
if (x.second >= k) {
puts("0");
return 0;
}
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
pre[i] = a[i] + pre[i - 1];
}
for (int i = n; i >= 1; i--) {
suf[i] = suf[i + 1] + a[i];
}
auto qL = [&](int x) {
int k = upper_bound(a + 1, a + 1 + n, x) - a - 1;
return make_pair(k, 1ll * k * x - pre[k]);
};
auto qR = [&](int x) {
int k = lower_bound(a + 1, a + 1 + n, x) - a;
return make_pair(n - k + 1, suf[k] - 1ll * x * (n - k + 1));
};
ll ans = 1e18;
for (auto& x : cnt) {
auto a = qL(x.first - 1);
auto b = qR(x.first + 1);
if (a.first + x.second >= k) {
ans = min(ans, a.second + k - x.second);
}
if (b.first + x.second >= k) {
ans = min(ans, b.second + k - x.second);
}
ans = min(ans, a.second + b.second + k - x.second);
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double pii = 2 * pi;
const double eps = 1e-6;
const long long MOD = 1e9 + 7;
inline long long __min(long long a, long long b) {
return (a == -1 || b == -1) ? (a + b + 1) : (min(a, b));
}
long long valf(long long val, int k, long long cum_suml, long long cum_sumr,
int num_l, int num_r) {
if (k <= 0) return 0ll;
long long ans = -1;
if (num_l >= k) {
ans = __min(ans, (val - 1) * num_l - cum_suml + k);
}
if (num_r >= k) {
ans = __min(ans, cum_sumr - (val + 1) * num_r + k);
}
ans = __min(ans,
cum_sumr - (val + 1) * num_r + (val - 1) * num_l - cum_suml + k);
return ans;
}
void solve() {
int n, k;
cin >> n >> k;
vector<long long> a(n, 0ll);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int cnt_dist = 0;
vector<long long> dist_elements, sum_cum;
vector<int> number_of_elements;
long long tot_sum = 0;
for (int i = 0; i < n; i++) {
tot_sum += a[i];
if (cnt_dist > 0 && dist_elements[cnt_dist - 1] == a[i]) {
sum_cum[cnt_dist - 1] += a[i];
number_of_elements[cnt_dist - 1]++;
} else {
dist_elements.push_back(a[i]);
sum_cum.push_back(a[i]);
number_of_elements.push_back(1);
cnt_dist++;
}
}
long long ans = -1, sum_so_far = 0;
long long l, r, mid, v1, v2, v3;
int ele_so_far = 0;
cnt_dist = dist_elements.size();
for (int i = 0; i < cnt_dist; i++) {
ans = __min(ans, valf(dist_elements[i], k - number_of_elements[i],
sum_so_far, tot_sum - sum_cum[i] - sum_so_far,
ele_so_far, n - ele_so_far - number_of_elements[i]));
if (i > 0 && dist_elements[i] - dist_elements[i - 1] > 1) {
l = dist_elements[i - 1] + 1;
r = dist_elements[i] - 1;
while (r - l > 1) {
mid = (l + r) / 2;
v1 = valf(mid - 1, k, sum_so_far, tot_sum - sum_so_far, ele_so_far,
n - ele_so_far);
v2 = valf(mid, k, sum_so_far, tot_sum - sum_so_far, ele_so_far,
n - ele_so_far);
v3 = valf(mid + 1, k, sum_so_far, tot_sum - sum_so_far, ele_so_far,
n - ele_so_far);
if (v1 >= v2 && v2 >= v3) {
l = mid;
} else {
r = mid;
}
}
v1 = valf(l, k, sum_so_far, tot_sum - sum_so_far, ele_so_far,
n - ele_so_far);
v2 = valf(r, k, sum_so_far, tot_sum - sum_so_far, ele_so_far,
n - ele_so_far);
ans = __min(ans, __min(v1, v2));
}
sum_so_far += sum_cum[i];
ele_so_far += number_of_elements[i];
}
cout << ans << "\n";
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
ll d, x, y;
ll power(ll x, ll n, ll mod = 1e9 + 7) {
ll result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result % mod * x % mod) % mod;
x = (x % mod * x % mod) % mod;
n = n / 2;
}
return result;
}
void gcd(ll a, ll b) {
if (b == 0)
d = a, x = 1, y = 0;
else {
gcd(b, a % b);
ll temp = x;
x = y;
y = temp - (a / b) * y;
}
}
ll modInverse(ll a, ll m) {
gcd(a, m);
return (x % m + m) % m;
}
vector<ll> factors(ll n) {
vector<ll> res;
for (ll i = 2; i <= sqrt(n); i++) {
while (n % i == 0) {
res.push_back(i);
n /= i;
}
}
return res;
}
int main() {
ll n, k;
cin >> n >> k;
vector<ll> a(n);
for (ll &it : a) cin >> it;
sort(a.begin(), a.end());
ll mx = *max_element(a.begin(), a.end());
ll ans = INT_MAX;
for (ll i = 0; i <= mx; i++) {
ll c = 0;
ll x = 0;
for (ll it : a) {
ll temp = it;
ll t = 0;
while (temp > i) {
temp = temp / 2;
t++;
}
if (temp == i) {
c++;
x += t;
}
if (c == k) {
break;
}
}
if (c == k) ans = min(ans, x);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
long long int a[n];
vector<long long int> all;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
long long int x = a[i];
while (x > 0) {
all.push_back(x);
x = x / 2;
}
}
sort(a, a + n);
long long int ans = 1e9;
for (auto x : all) {
long long int c = 0;
long long int count = 0;
for (long long int i = 0; i < n; i++) {
long long int y = a[i];
if (x == y) {
count++;
} else {
long long int t = 0;
while (y > 0) {
if (x == y) {
count++;
c += t;
break;
}
t++;
y = y / 2;
}
}
if (count >= k) {
ans = min(ans, c);
break;
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long P = 1e9 + 7;
long long P1 = 998244353;
const int sqr = 500;
const int arrn = 4e6 + 5;
const int arrn2 = 6e3 + 5;
void solve() {
int n, k;
cin >> n >> k;
map<long long, int> cnt;
long long tot = 0;
for (int i = 0; i < n; i++) {
long long k;
cin >> k;
tot += k;
cnt[k]++;
}
int lft = 0;
long long lsum = 0;
long long ans = LLONG_MAX;
for (auto i : cnt) {
int rem = k - i.second;
int rig = n - i.second - lft;
long long rsum = tot - lsum - (i.first * i.second);
if (rem <= 0) {
ans = 0;
break;
}
if (rem <= lft) {
long long oper = (i.first - 1) * lft - lsum;
oper += rem;
ans = min(ans, oper);
}
if (rem <= rig) {
long long oper = rsum - (i.first + 1) * rig;
oper += rem;
ans = min(ans, oper);
}
long long oper =
(rsum - (i.first + 1) * rig) + ((i.first - 1) * lft - lsum);
oper += rem;
ans = min(ans, oper);
lft += i.second;
lsum += i.first * i.second;
}
cout << ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int INF = INT_MAX;
const int mod = 1e9 + 7;
const int N = 2e5 + 10;
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline int mul(int x, int y) {
x = (1LL * x * y) % mod;
return x;
}
clock_t time_p = clock();
long long pref[N];
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i <= n - 1; ++i) cin >> a[i];
sort(a.begin(), a.end());
pref[0] = a[0];
for (int i = 1; i <= n - 1; ++i) pref[i] = a[i] + pref[i - 1];
long long ans = 1e18;
for (int i = 0; i <= n - 1; ++i) {
int get = a[i];
int n1 = lower_bound(a.begin(), a.end(), get - 1) - a.begin();
int n2 = a.end() - upper_bound(a.begin(), a.end(), get + 1);
int n3 = upper_bound(a.begin(), a.end(), get - 1) -
lower_bound(a.begin(), a.end(), get - 1);
int n4 = upper_bound(a.begin(), a.end(), get) -
lower_bound(a.begin(), a.end(), get);
int n5 = upper_bound(a.begin(), a.end(), get + 1) -
lower_bound(a.begin(), a.end(), get + 1);
long long c1 = n1 * 1LL * (get - 1) - (n1 == 0 ? 0 : pref[n1 - 1]);
long long c2 =
(pref[n - 1] - (n2 == n ? 0 : pref[n - 1 - n2])) - n2 * 1LL * (get + 1);
;
if (n4 >= k) {
ans = 0;
break;
}
if (n1 + n3 >= k - n4) {
ans = min(ans, c1 + k - n4);
}
if (n2 + n5 >= k - n4) {
ans = min(ans, c2 + k - n4);
}
if (n1 + n3 + n2 + n5 >= k - n4) {
ans = min(ans, c1 + c2 + k - n4);
}
}
cout << ans << "\n";
time_p = clock() - time_p;
cerr << "\nTime Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m;
pair<long long, long long> a[2000111], b[2000111], c[2000111], d[2000111];
void lam() {
cin >> n >> m;
long long nn = n, kt = 0, bd = 1, qq = LLONG_MAX;
for (int i = 1; i <= nn; i++) cin >> a[i].first;
sort(a + 1, a + n + 1);
for (int i = 2; i <= n + 1; i++)
if (a[i].first != a[i - 1].first) {
b[++kt].second = i - bd, bd = i;
b[kt].first = a[i - 1].first;
}
for (int i = kt; i >= 1; i--) {
c[i].first = c[i + 1].first + b[i].first * b[i].second;
c[i].second = c[i + 1].second + b[i].second;
}
for (int i = 1; i <= kt; i++) {
long long doa = m - b[i].second;
pair<long long, long long> xx = pair<long long, long long>(
(b[i].first - 1) * d[i - 1].second -
d[i - 1].first,
d[i - 1].second),
yy = pair<long long, long long>(
c[i + 1].first -
(b[i].first + 1) * c[i + 1].second,
c[i + 1].second);
if (xx.first > yy.first) swap(xx, yy);
if (doa <= 0)
qq = 0;
else if (xx.second >= doa)
qq = min(qq, xx.first + doa);
else if (yy.second >= doa)
qq = min(qq, yy.first + doa);
else
qq = min(qq, xx.first + yy.first + doa);
d[i].first = d[i - 1].first + b[i].first * b[i].second;
d[i].second = d[i - 1].second + b[i].second;
}
cout << qq;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
lam();
}
|
#include <bits/stdc++.h>
using namespace std;
long long __gcd(long long a, long long b) { return b ? __gcd(b, a % b) : a; }
long long pwmod(long long a, long long b) {
if (b == 0) return 1;
long long tmp = pwmod(a, b / 2);
tmp = (tmp * tmp) % 998244353;
if (b & 1) tmp = (tmp * a) % 998244353;
return tmp;
}
void solve() {
long long n, k;
cin >> n >> k;
long long arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
vector<long long> cost[200001];
for (long long i = 0; i < n; i++) {
long long curr = 0;
while (arr[i]) {
cost[arr[i]].push_back(curr);
arr[i] /= 2;
curr++;
}
cost[0].push_back(curr);
}
long long mn = LLONG_MAX;
for (long long i = 0; i < 200001; i++) {
if (cost[i].size() >= k) {
sort(cost[i].begin(), cost[i].end());
long long sum = 0;
for (long long j = 0; j < k; j++) {
sum += cost[i][j];
}
mn = min(mn, sum);
}
}
cout << mn;
}
void preset() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int32_t main() {
preset();
solve();
return 0;
long long t;
cin >> t;
long long i = 1;
while (t--) {
solve();
cout << '\n';
i++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 7;
const int MOD = (int)1e9 + 7;
const long long INF = (long long)1e18 + 7;
long long a[N], s[N];
int n, k;
long long sum(int l, int r) { return s[r] - s[l - 1]; }
long long proc(int l, int r) {
int rem = k - (r - l + 1);
if (rem <= 0) return 0;
long long lef = l != 1 ? (a[l] - 1) * (l - 1) - sum(1, l - 1) : 0;
long long rig = r != n ? sum(r + 1, n) - (a[r] + 1) * (n - r) : 0;
long long afterL = k - r;
long long afterR = k - (n - l + 1);
long long ans1 = 1LL * min(rem, l - 1) + lef;
if (afterL > 0) ans1 += rig + afterL;
long long ans2 = 1LL * min(rem, n - r) + rig;
if (afterR > 0) ans2 += lef + afterR;
return min(ans1, ans2);
}
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];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
long long ans = INF;
for (int l = 1; l <= n;) {
int r = l;
while (a[r + 1] == a[l] && r < n) r++;
ans = min(ans, proc(l, r));
l = r + 1;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9, oo = 1e9;
void solve() {
int n, x, k;
cin >> n >> k;
map<int, pair<int, int> > m;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
x = 0;
while (v[i] != 1) {
if (m[v[i]].first < k) {
m[v[i]].first++;
m[v[i]].second += x;
}
v[i] /= 2;
x++;
}
if (m[1].first < k) {
m[1].first++;
m[1].second += x;
}
}
long long ans = LLONG_MAX;
for (auto it : m) {
if (it.second.first == k) ans = min(ans, 1ll * it.second.second);
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int fx[] = {+1, -1, +0, +0};
const int fy[] = {+0, +0, +1, -1};
vector<long long int> v, v1, res;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int a, b, c, d, e, f, i, j, x, k, cnt1 = 0, id, chk = 0, sum = 0,
cnt2 = 0;
string s1, s2;
cin >> a >> b;
for (i = 0; i < a; i++) {
cin >> c;
v.push_back(c);
}
sort(v.begin(), v.end());
long long int mx = *max_element(v.begin(), v.end());
for (i = 0; i <= mx; i++) {
res.clear();
for (j = 0; j < a; j++) {
long long int n = v[j];
cnt1 = 0;
while (n > i) {
n /= 2;
cnt1++;
}
if (n == i) {
res.push_back(cnt1);
}
}
sort(res.begin(), res.end());
if (res.size() >= b) {
sum = 0;
for (j = 0; j < b; j++) {
sum += res[j];
}
v1.push_back(sum);
}
}
cout << *min_element(v1.begin(), v1.end());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
vector<long long> adj[N + 3];
int main() {
long long n, k, ans = 1e12;
cin >> n >> k;
long long a[n + 2];
vector<long long> valu;
valu.push_back(0);
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n; i++) {
long long val = a[i];
long long cnt = 0;
while (val >= 0) {
adj[val].push_back(cnt);
if (val == 0) break;
cnt++;
val /= 2;
}
}
for (long long i = 0; i <= N; i++) {
sort(adj[i].begin(), adj[i].end());
if (adj[i].size() < k) continue;
long long sum = 0;
for (long long j = 0; j < k; j++) {
sum += adj[i][j];
}
ans = min(sum, ans);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k;
cin >> n >> k;
vector<long long> arr(n);
for (auto &u : arr) cin >> u;
sort(arr.begin(), arr.end());
map<long long, pair<long long, long long>> mp;
long long ans = 9e18;
for (auto u : arr) {
mp[u].first++;
if (mp[u].first >= k) ans = min(ans, mp[u].second);
long long pr = 0;
while (u) {
pr++;
u /= 2;
mp[u].first++;
mp[u].second += pr;
if (mp[u].first >= k) ans = min(ans, mp[u].second);
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9, M = 1e5 + 9, OO = 0x3f3f3f3f, MOD = 1e9 + 7;
long long n, k;
long long arr[N];
map<long long, vector<long long> > canReach;
void process(long long f) {
long long ret = 0;
while (f) {
long long accSum = 0;
canReach[f].push_back(ret);
f /= 2;
++ret;
}
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
process(arr[i]);
}
long long mn = OO;
for (auto i : canReach) {
sort(i.second.begin(), i.second.end());
if (i.second.size() >= k) {
long long tmp = 0;
for (int j = 0; j < k; ++j) tmp += i.second[j];
mn = min(mn, tmp);
}
}
cout << mn;
}
|
#include <bits/stdc++.h>
using namespace std;
long long all[200005];
bool cmp(long long a, long long b) { return a < b; }
struct A {
long long how;
long long con;
long long a;
long long b;
long long xx;
long long yy;
} temp[200005];
int main() {
long long N, K, i, now = 0, ans = 1e18;
scanf("%lld %lld", &N, &K);
for (i = 0; i < N; i++) scanf("%lld", &all[i]);
sort(all, all + N, cmp);
now = -1;
for (i = 0; i < N; i++) {
if (i == 0 || all[i] != all[i - 1]) {
now++;
temp[now].how = all[i];
temp[now].con = 0;
temp[now].xx = 0;
temp[now].yy = 0;
temp[now].a = 0;
temp[now].b = 0;
}
temp[now].con++;
if (temp[now].con >= K) ans = 0;
}
now++;
temp[0].a = temp[0].con;
temp[0].xx = 0;
for (i = 1; i < now; i++) {
temp[i].a = temp[i - 1].a + temp[i].con;
temp[i].xx =
temp[i - 1].xx + temp[i - 1].a * (temp[i].how - temp[i - 1].how);
if (temp[i].a >= K) ans = min(ans, temp[i].xx - (temp[i].a - K));
}
temp[now - 1].b = temp[now - 1].con;
temp[now - 1].yy = 0;
for (i = now - 2; i >= 0; i--) {
temp[i].b = temp[i + 1].b + temp[i].con;
temp[i].yy =
temp[i + 1].yy + temp[i + 1].b * (temp[i + 1].how - temp[i].how);
if (temp[i].b >= K) ans = min(ans, temp[i].yy - (temp[i].b - K));
}
for (i = 0; i < now; i++) {
if (temp[i].a >= K)
ans = min(ans, temp[i].xx);
else {
if (i + 1 != now)
ans = min(ans, temp[i].xx + temp[i + 1].yy + (K - temp[i].a) +
temp[i + 1].b * (temp[i + 1].how - temp[i].how - 1));
}
if (temp[i].b >= K)
ans = min(ans, temp[i].yy);
else {
if (i)
ans = min(ans, temp[i].yy + temp[i - 1].xx + (K - temp[i].b) +
temp[i - 1].a * (temp[i].how - temp[i - 1].how - 1));
}
}
printf("%lld\n", max(ans, (long long)0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 100;
int n, k;
int a[MAX_N];
int cnt[MAX_N];
int cost[MAX_N];
int has[MAX_N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
memset(cnt, 0, sizeof cnt);
memset(cost, 0, sizeof cost);
memset(has, 0, sizeof has);
bool ok = false;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
cnt[a[i]]++;
if (cnt[a[i]] >= k) {
ok = true;
}
}
if (ok) {
cout << "0" << endl;
return 0;
}
sort(a + 1, a + 1 + n);
int ans = 1e9;
while (1) {
bool can = false;
for (int i = 1; i <= n; ++i) {
if (a[i] != -1) {
can = true;
a[i] >>= 1;
has[i]++;
cnt[a[i]]++;
cost[a[i]] += has[i];
if (cnt[a[i]] >= k) {
ans = min(cost[a[i]], ans);
}
if (a[i] == 0) a[i] = -1;
}
}
if (!can) break;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
long long i, j, k, m, n, q, r, c, t;
cin >> n >> k;
map<long long, long long> make_pair;
for (long long(i) = (0); (i) < (n); ++(i)) {
cin >> j;
make_pair[j]++;
}
n = make_pair.size();
vector<long long> le(n + 2, 0), re(n + 2, 0), lc(n + 2, 0), rc(n + 2, 0);
auto it = make_pair.begin();
i = 2;
le[1] = it->second;
j = it->first;
++it;
vector<long long> cu(n + 2, 0);
cu[1] = le[1];
for (; it != make_pair.end(); ++it) {
cu[i] = it->second;
le[i] = le[i - 1] + it->second;
lc[i] = le[i - 1] * (it->first - j) + lc[i - 1];
i++;
j = it->first;
}
auto itt = make_pair.rbegin();
i = n - 1;
re[n] = itt->second;
j = itt->first;
++itt;
for (; itt != make_pair.rend(); ++itt) {
re[i] = re[i + 1] + itt->second;
rc[i] = re[i + 1] * (j - itt->first) + rc[i + 1];
i--;
j = itt->first;
}
long long ans = 1e18;
long long left, right, sum, kk;
for (i = 2; i <= n - 1; i++) {
if (cu[i] >= k) {
cout << "0";
return 0;
}
kk = k - cu[i];
if (le[i - 1] < kk && re[i + 1] < kk) {
j = kk - le[i - 1];
sum = lc[i];
sum += rc[i] - (re[i + 1] - j);
ans = min(ans, sum);
j = kk - re[i + 1];
sum = rc[i];
sum += lc[i] - (le[i - 1] - j);
ans = min(ans, sum);
} else {
if (le[i - 1] >= kk) {
left = lc[i] - (le[i - 1] - kk);
ans = min(ans, left);
}
if (re[i + 1] >= kk) {
right = rc[i] - (re[i + 1] - kk);
ans = min(ans, right);
}
}
}
if (cu[1] >= k) {
cout << "0";
return 0;
}
kk = k - cu[1];
ans = min(ans, rc[1] - (re[2] - kk));
if (cu[n] >= k) {
cout << "0";
return 0;
}
kk = k - cu[n];
ans = min(ans, lc[n] - (le[n - 1] - kk));
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int N = 2e5 + 7;
int arr[N];
long long sum[N];
map<int, int> mp;
int main() {
int n, k, num = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++)
scanf("%d", &arr[i]), mp[arr[i]]++, num = max(num, mp[arr[i]]);
if (num >= k) {
cout << 0 << endl;
return 0;
}
sort(arr + 1, arr + n + 1);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + arr[i];
long long ans = INF;
for (int i = 1; i <= n; i++) {
if (i >= k) ans = min(ans, (long long)arr[i] * (i)-sum[i] - (i - k));
if (n - i + 1 >= k)
ans = min(
ans, sum[n] - sum[i] - (long long)arr[i] * (n - i) - (n - i + 1 - k));
ans = min(ans, (long long)arr[i] * (i)-sum[i] + sum[n] - sum[i] -
(long long)arr[i] * (n - i) - (n - k));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 1;
map<long long, long long> p;
vector<pair<long long, long long>> v;
long long k, sum1[maxn], sum2[maxn], num1[maxn], num2[maxn], a[maxn];
int main() {
int n;
scanf("%d %lld", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]), p[a[i]]++;
for (auto it = p.begin(); it != p.end(); it++)
v.push_back({it->first, it->second});
long long t = 0, tt = 0, ans = 1e18;
for (int i = 0; i < v.size(); ++i) {
num1[i] = t;
sum1[i] = tt;
t += v[i].second;
tt += v[i].first * v[i].second;
}
t = tt = 0;
for (int i = v.size() - 1; i >= 0; --i) {
num2[i] = t;
sum2[i] = tt;
t += v[i].second;
tt += v[i].first * v[i].second;
}
for (int i = 0; i < v.size(); ++i) {
if (v[i].second >= k) {
puts("0");
return 0;
}
long long left = num1[i] * (v[i].first - 1) - sum1[i],
right = sum2[i] - num2[i] * (v[i].first + 1);
if (v[i].second + num1[i] >= k) ans = min(ans, left + k - v[i].second);
if (v[i].second + num2[i] >= k) ans = min(ans, right + k - v[i].second);
ans = min(ans, left + right + k - v[i].second);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
multiset<int> s[200005];
int num[200005];
int sz[200005];
long long sum[200005];
int main() {
int n, k, t;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &t);
int cost = 0;
while (true) {
s[t].insert(cost);
sz[t]++;
sum[t] += cost;
if (sz[t] > k) {
sz[t]--;
auto it = s[t].end();
it--;
sum[t] -= *it;
s[t].erase(it);
}
if (t == 0) break;
cost++;
t /= 2;
}
}
long long ans = 1e18;
for (int i = 0; i <= 200000; i++) {
if (sz[i] == k) {
ans = min(ans, sum[i]);
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
set<int> av;
for (int i = 0; i < n; i++) {
cin >> a[i];
int w = a[i];
av.insert(w);
while (w) {
w >>= 1;
av.insert(w);
}
}
vector<int> u;
for (auto q : av) u.push_back(q);
vector<vector<int> > t(n, vector<int>(av.size()));
for (int i = 0; i < n; i++) {
for (int j = 0; j < av.size(); j++) {
if (a[i] < u[j])
t[i][j] = 1e9;
else {
t[i][j] = 1e9;
int w = a[i];
if (u[j] == w) {
t[i][j] = 0;
}
int cur = 0;
while (w) {
w >>= 1;
cur++;
if (u[j] == w) t[i][j] = cur;
}
}
}
}
t[0][0] = t[0][0];
long long res = 1e9;
for (int i = 0; i < av.size(); i++) {
vector<int> nw;
for (int j = 0; j < n; j++) nw.push_back(t[j][i]);
sort(nw.begin(), nw.end());
bool f = false;
for (int j = 0; j < k; j++)
if (nw[j] == 1e9) {
f = true;
}
if (!f) {
long long q = 0;
for (int j = 0; j < k; j++) q += nw[j];
res = min(res, q);
}
}
cout << res;
cin >> res;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
if (k == 1) {
cout << "0";
return;
}
long long mx = *max_element(a, a + n);
vector<long long> v[mx + 1];
for (long long i = 0; i < n; i++) {
long long x = a[i], j = 0;
while (x) {
v[x].push_back(j);
x /= 2;
j++;
}
v[0].push_back(j);
}
long long ans = LONG_MAX;
for (long long i = 0; i <= mx; i++)
if (v[i].size() >= k) {
sort(v[i].begin(), v[i].end());
long long s = 0;
for (long long j = 0; j < k; j++) s += v[i][j];
ans = min(ans, s);
}
cout << ans;
return;
}
int32_t main() {
long long test;
test = 1;
while (test--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 7;
const int MOD = (int)1e9 + 7;
const long long INF = (long long)1e18 + 7;
long long a[N], s[N];
int n, k;
long long sum(int l, int r) { return s[r] - s[l - 1]; }
long long proc(int l, int r) {
int rem = k - (r - l + 1);
if (rem <= 0) return 0;
long long lef = l != 1 ? (a[l] - 1LL) * (l - 1) - sum(1, l - 1) : 0;
long long rig = r != n ? sum(r + 1, n) - (a[r] + 1) * (n - r) : 0;
long long afterL = k - r;
long long afterR = k - (n - l + 1);
long long ans1 = 1LL * min(rem, l - 1) + lef;
if (afterL > 0) ans1 += rig + afterL;
long long ans2 = 1LL * min(rem, n - r) + rig;
if (afterR > 0) ans2 += lef + afterR;
return min(ans1, ans2);
}
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];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
long long ans = INF;
for (int l = 1; l <= n;) {
int r = l;
while (a[r + 1] == a[l] && r < n) r++;
ans = min(ans, proc(l, r));
l = r + 1;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
long long a[n + 1];
map<long long, long long> freq;
map<long long, long long> first, last;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
freq[a[i]]++;
}
sort(a + 1, a + n + 1);
long long pre[n + 1];
pre[0] = 0;
for (long long i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
if (!first[a[i]]) {
first[a[i]] = i;
}
last[a[i]] = i;
}
map<long long, long long>::iterator it;
long long res = LONG_LONG_MAX;
for (it = freq.begin(); it != freq.end(); it++) {
if (k <= (*it).second) {
res = 0;
break;
}
long long small = first[(*it).first] - 1;
long long big = n - last[(*it).first];
long long ctr = k - (*it).second;
long long sum1 = pre[small] - pre[0];
long long sum2 = pre[n] - pre[last[(*it).first]];
sum1 = small * ((*it).first - 1) - sum1;
sum2 -= big * ((*it).first + 1);
if ((ctr <= small) && (ctr <= big)) {
long long sum = min(sum1, sum2);
sum += ctr;
res = min(res, sum);
} else if ((ctr <= small)) {
long long sum = sum1;
sum += ctr;
res = min(res, sum);
} else if (ctr <= big) {
long long sum = sum2;
sum += ctr;
res = min(res, sum);
} else {
long long sum = sum1 + sum2;
sum += ctr;
res = min(res, sum);
}
}
if (res < 0) {
res = 0;
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt;
long long sum[200100], csum[200100], total, mk[200100], k,
ans = 999999999999999;
int a[200100], b[200100];
map<int, int> mp;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
total += a[i];
}
sort(1 + b, 1 + b + n);
for (int i = 1; i <= n; i++) {
if (mp.find(b[i]) == mp.end()) {
mp[b[i]] = ++cnt;
mk[cnt] = b[i];
}
csum[cnt] += b[i];
sum[cnt]++;
}
bool flag = false;
for (int i = 1; i <= cnt; i++) {
if (sum[i] >= m) flag = true;
csum[i] += csum[i - 1];
sum[i] += sum[i - 1];
}
if (flag) {
printf("0\n");
return 0;
}
for (int i = 1; i <= cnt; i++) {
if (sum[i] >= m) {
k = sum[i] * mk[i] - (sum[i] - m) - csum[i];
ans = min(ans, k);
}
if (n - sum[i - 1] >= m) {
k = total - csum[i - 1] -
((n - sum[i - 1]) * mk[i] + ((n - sum[i - 1]) - m));
ans = min(ans, k);
}
k = (sum[i - 1] * mk[i] - csum[i - 1]) +
((total - csum[i]) - (n - sum[i]) * mk[i]) - (n - m);
ans = min(ans, k);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long a[N], pre[N], suf[N], cnt[N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i];
for (int i = 1; i <= n; i++) pre[i] = i * a[i] - pre[i];
for (int i = n; i >= 1; i--) suf[i] = suf[i + 1] + a[i];
for (int i = n; i >= 1; i--) suf[i] = suf[i] - a[i] * (n - i + 1);
for (int i = 1; i <= n; i++) cnt[i] = (a[i] == a[i - 1] ? cnt[i - 1] + 1 : 1);
long long ans = 0x3f3f3f3f3f3f3f3fll;
for (int i = 1; i <= n; i++)
if (cnt[i] >= k) {
printf("0\n");
return 0;
}
for (int i = 1; i <= n; i++) {
if (i < k)
ans = min(ans, pre[i] + suf[i] - (n - k));
else
ans = min(ans, pre[i] - (i - k));
if (i > n - k + 1)
ans = min(ans, suf[i] + pre[i] - (n - k));
else
ans = min(ans, suf[i] - (n - i + 1 - k));
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k, i, costL = 0, costR = 0, x, mx = 0;
vector<long long> v;
map<long long, long long> cnt;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
cnt[x]++;
mx = max(mx, cnt[x]);
}
if (mx >= k) {
cout << 0 << "\n";
return 0;
}
sort(v.begin(), v.end());
for (i = 0; i < k; i++) {
costL += v[k - 1] - v[i];
}
for (i = k; i < n; i++) {
if (v[k - 1] == v[i])
costL--;
else
break;
}
for (i = n - k; i < n; i++) {
costR += v[i] - v[n - k];
}
for (i = k; i < n; i++) {
if (v[n - k] == v[n - i - 1])
costR--;
else
break;
}
long long total = 0LL;
for (i = 0; i + i < n; i++) {
total += v[n - i - 1] - v[i];
}
total -= (n - k);
long long ans = min({total, costL, costR});
cout << max(0LL, ans) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
multiset<long long> s[200004];
long long a[200005];
long long su[200005];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long x;
for (long long i = 0; i < n; i++) {
x = 0;
while (true) {
s[a[i]].insert(x);
su[a[i]] += x;
if (s[a[i]].size() > k) {
set<long long>::iterator pointer = s[a[i]].end();
pointer--;
su[a[i]] -= *pointer;
s[a[i]].erase(pointer);
}
if (a[i] == 0) break;
a[i] /= 2;
x++;
}
}
long long minn = 1e9;
for (long long i = 0; i < 200005; i++) {
if (s[i].size() == k) {
minn = min(minn, su[i]);
}
}
cout << minn;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 400010;
inline long long read() {
long long s = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
long long n, K, a[N], qz[N], hz[N], Ans = 1e18;
signed main() {
n = read(), K = read();
for (register long long i = 1; i <= n; i++) a[i] = read();
sort(a + 1, a + 1 + n);
long long now = 0;
for (register long long i = 1; i <= n; i++) {
if (i == 1 || a[i] == a[i - 1])
now++;
else {
if (now >= K) return puts("0") & 0;
now = 1;
}
}
for (register long long i = 1; i <= n; i++) qz[i] = qz[i - 1] + a[i];
for (register long long i = n; i; i--) hz[i] = hz[i + 1] + a[i];
for (register long long i = 1; i <= n; i++) {
if (i >= K) Ans = min(Ans, a[i] * i - qz[i] - (i - K));
if (n - i + 1 >= K)
Ans = min(Ans, hz[i] - a[i] * (n - i + 1) - (n - i + 1 - K));
Ans = min(Ans, hz[i] - a[i] * (n - i + 1) - qz[i] + a[i] * i - (n - K));
}
printf("%lld\n", max(Ans, 0ll));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 2 * (1e5 + 2);
const long long int mod = 1e3 + 2;
map<long long int, vector<long long int> > m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, k;
cin >> n >> k;
long long int a[n + 2], ans = INT_MAX;
for (long long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (long long int i = 0; i < n; ++i) {
long long int num = a[i], c = 0;
while (num) {
m[num].push_back(c);
num = num / 2;
c = c + 1;
}
}
for (long long int i = 1; i < maxn; i++) {
long long int t = 0;
if (m[i].size() >= k) {
for (long long int j = 0; j < k; ++j) t = t + m[i][j];
ans = min(ans, t);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
const long long N = 2e5 + 7;
long long n, k;
long long p[N], s[N];
long long get_p(long long x) {
if (x < 0) {
return 0;
}
return p[x];
}
long long get_s(long long x) {
if (x >= n) {
return 0;
}
return s[x];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (long long i = 0; i < n; i++) {
p[i] = a[i] + (i ? p[i - 1] : 0);
}
for (long long i = n - 1; i >= 0; i--) {
s[i] = a[i] + (i != n - 1 ? s[i + 1] : 0);
}
long long lst = -1;
long long ans = 1e18 + 7;
for (long long i = 0; i < n; i++) {
if (i == 0 || a[i] != a[i - 1]) {
lst = i;
}
if (i + 1 < n && a[i + 1] == a[i]) {
continue;
}
long long cnt = i - lst + 1;
if (cnt >= k) {
cout << 0 << '\n';
return 0;
}
long long cnt_l = lst;
long long cnt_r = n - i - 1;
long long need = k - cnt;
if (cnt_l < need) {
long long sum = cnt_l * a[i];
long long have = need - cnt_l;
sum = sum - get_p(lst - 1);
long long kek = have * a[i];
kek += (cnt_r - have) * (a[i] + 1);
kek = get_s(i + 1) - kek;
ans = min(ans, kek + sum);
} else {
long long sum = need * a[i];
sum += (cnt_l - need) * (a[i] - 1);
sum = sum - get_p(lst - 1);
ans = min(ans, sum);
}
if (cnt_r < need) {
long long sum = cnt_r * a[i];
long long have = need - cnt_r;
sum = get_s(i + 1) - sum;
long long kek = have * a[i];
kek += (cnt_l - have) * (a[i] - 1);
kek = kek - get_p(lst - 1);
ans = min(ans, kek + sum);
} else {
long long sum = need * a[i];
sum += (cnt_r - need) * (a[i] + 1);
sum = get_s(i + 1) - sum;
ans = min(ans, sum);
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mt(time(0));
long long solve(long long target, int k, long long sum1, long long sum2,
int cnt1, int cnt2) {
if (k <= 0) return 0;
long long ret1 = (target - 1) * cnt1 - sum1;
ret1 += min(k, cnt1);
int k1 = k - min(k, cnt1);
if (k1 > 0) {
ret1 += sum2 - (target + 1) * cnt2;
ret1 += k1;
}
long long ret2 = sum2 - (target + 1) * cnt2;
ret2 += min(k, cnt2);
int k2 = k - min(k, cnt2);
if (k2 > 0) {
ret2 += (target - 1) * cnt1 - sum1;
ret2 += k2;
}
return min(ret1, ret2);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
int n, k, val;
cin >> n >> k;
map<int, int> table;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> val;
table[val]++;
sum += val;
}
int cur_cnt = 0;
long long cur_sum = 0, ret = LLONG_MAX;
for (const auto& item : table) {
int tmp_cnt = item.second;
long long tmp_sum = item.first * (long long)tmp_cnt;
long long tmp =
solve(item.first, k - tmp_cnt, cur_sum, sum - cur_sum - tmp_sum,
cur_cnt, n - cur_cnt - tmp_cnt);
ret = min(ret, tmp);
cur_sum += tmp_sum;
cur_cnt += tmp_cnt;
}
cout << ret << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD;
long long exp(long long a, long long n) {
if (n == 0) return 1;
long long result = a, residue = 1;
while (n > 1LL) {
if (n % 2LL == 1LL) residue = residue * result % MOD;
result = result * result % MOD;
n = (n >> 1LL);
}
return result * residue % MOD;
}
void extended(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return;
}
extended(b % a, a, x, y);
long long temp = y;
y = x;
x = temp - (b / a) * x;
}
int rs(long long a) {
int val = 0;
while (a > 0LL) {
a = (a >> 1LL);
val++;
}
return val;
}
int main() {
long long n, k;
cin >> n >> k;
vector<long long> a(200001, 0), presum(200002, 0), sufsum(200002, 0);
map<long long, long long> f;
long long ans = 4000000000000000LL, temp = 0, fact;
for (int i = 1; i <= n; i++) cin >> a[i], f[a[i]]++;
sort(a.begin() + 1, a.begin() + n + 1);
for (int i = 1; i <= n; i++) presum[i] = presum[i - 1] + a[i];
for (int i = n; i > 0; i--) sufsum[i] = sufsum[i + 1] + a[i];
for (long long i = 1; i <= n; i++) {
long long val = a[i];
long long req = max(0LL, k - f[a[i]]);
long long lefttemp = 0;
if (req > 0)
lefttemp = (i - 1) * (val - 1) - presum[i - 1] + min(req, i - 1);
req -= min(req, i - 1);
if (req > 0)
lefttemp += sufsum[i + f[a[i]]] - (n - i - f[a[i]] + 1) * (val + 1) + req;
ans = min(ans, lefttemp);
req = max(0LL, k - f[a[i]]);
long long righttemp = 0;
if (req > 0)
righttemp = sufsum[i + f[a[i]]] - (n - i - f[a[i]] + 1) * (val + 1) +
min(req, n - i - f[a[i]] + 1);
req -= min(req, n - i - f[a[i]] + 1);
if (req > 0) righttemp += (i - 1) * (val - 1) - presum[i - 1] + req;
ans = min(ans, righttemp);
i += f[a[i]] - 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
vector<int> A[200001];
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
int x, cnt = 0;
cin >> x;
while (x) {
A[x].push_back(cnt++);
if (x == 0) break;
x >>= 1;
}
}
int ans = 1e9;
for (int i = 0; i <= 200000; ++i) {
sort(A[i].begin(), A[i].end());
if (A[i].size() < k) continue;
int sum = 0;
for (int j = 0; j < k; ++j) sum += A[i][j];
ans = min(ans, sum);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i;
cin >> n >> k;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
map<long long int, vector<long long int> > m;
for (i = 0; i < n; i++) {
long long int c = a[i], cnt = 0;
while (c > 0) {
m[c].push_back(cnt);
c = c / 2;
cnt++;
}
}
long long int ans = 0, mini = 100000000000;
for (auto it = m.begin(); it != m.end(); it++) {
ans = 0;
if (it->second.size() >= k) {
for (i = 0; i < k; i++) ans = ans + it->second[i];
mini = min(ans, mini);
}
}
cout << mini;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[200001];
int vis[200001];
int op[200001];
void print(int a[]) {
for (int i = 0; i < n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
int main(int argc, char *argv[]) {
int res = 0x3f3f3f3f;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
vis[a[i]]++;
if (vis[a[i]] >= k) {
printf("0\n");
return 0;
}
}
sort(a, a + n);
for (int i = 0; i < n; i++) {
int div = 0;
while (a[i] != 0) {
a[i] /= 2;
div++;
vis[a[i]]++;
op[a[i]] += div;
if (vis[a[i]] == k) {
res = min(res, op[a[i]]);
}
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string sfrom(string s, int i, int j) { return s.substr(i, j - i + 1); }
template <typename reservedArgs>
string to_string(reservedArgs args) {
stringstream sso;
sso << args;
return sso.str();
}
template <typename reservedArgs>
string to_string(reservedArgs args, int precision) {
stringstream sso;
sso << fixed << setprecision(precision);
sso << args;
return sso.str();
}
long long hell = 1000000007LL;
template <typename reservedArgs>
reservedArgs gcd(reservedArgs n1, reservedArgs n2) {
return (n2 == 0 ? n1 : gcd(n2, n1 % n2));
}
class compare {
public:
bool operator()(int lowPriority, int highPriority) {
return lowPriority < highPriority;
}
};
priority_queue<int, vector<int>, compare> pq;
const int N = 2e5 + 5;
vector<int> dist[N];
void main1() {
int n, k, a;
cin >> n >> k;
for (int(i1) = 0; (i1) < (n); (i1)++) {
cin >> a;
for (int i = 0; true; i++, a /= 2) {
dist[a].push_back(i);
if (a == 0) break;
}
}
int ans = INT_MAX, tmp;
for (int(i) = 0; (i) < (N); (i)++) {
if (dist[i].size() >= k) {
sort(dist[i].begin(), dist[i].end());
tmp = 0;
for (int(j) = 0; (j) < (k); (j)++) tmp += dist[i][j];
ans = min(ans, tmp);
}
}
cout << ans << endl;
}
int main() {
int t = 1;
for (int(i1) = 0; (i1) < (t); (i1)++) {
main1();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
vector<int> count[200000 + 1];
for (int i = 0; i < n; i++) {
cin >> a[i];
int step = 0;
while (a[i]) {
count[a[i]].push_back(step);
step++;
a[i] = a[i] / 2;
}
}
for (int i = 0; i < 2e5 + 1; i++) {
sort(count[i].begin(), count[i].end());
}
int ans = INT_MAX;
for (int i = 0; i < 2e5 + 1; i++) {
if (count[i].size() >= k) {
int sum = 0;
for (int j = 0; j < k; j++) sum += count[i][j];
ans = min(ans, sum);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 2e5 + 10;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
map<int, long long> mp;
map<int, long long> posf;
map<int, long long> posb;
int n, m, q, k;
cin >> n >> m;
long long pre[N], suf[N];
long long a[N];
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
a[0] = 0;
a[n + 1] = 0;
pre[0] = 0;
suf[n + 1] = 0;
for (int i = 1; i <= n; i++) {
mp[a[i]]++;
if (a[i] != a[i - 1]) posf[a[i]] = i - 1;
if (mp[a[i]] >= m) {
cout << 0 << '\n';
return 0;
}
pre[i] = pre[i - 1] + a[i];
}
for (int i = n; i >= 1; i--) {
if (a[i] != a[i + 1]) posb[a[i]] = n - i;
suf[i] = suf[i + 1] + a[i];
}
long long ans = 2e15;
for (auto x : mp) {
int need = m - x.second;
if (posf[x.first] >= need) {
long long t = (x.first - 1) * (posf[x.first]) - pre[posf[x.first]] + need;
ans = (ans > t ? t : ans);
}
if (posb[x.first] >= need) {
long long t =
suf[n - posb[x.first] + 1] - (x.first + 1) * (posb[x.first]) + need;
ans = (ans > t ? t : ans);
}
long long t = suf[n - posb[x.first] + 1] - (x.first + 1) * (posb[x.first]) +
need + (x.first - 1) * (posf[x.first]) - pre[posf[x.first]];
ans = (ans > t ? t : ans);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
const long long maxn = 1e6;
const long long maxx = 1e15;
using namespace std;
long long a[maxn];
long long num[maxn], cnt[maxn], pre[maxn], suf[maxn], pcnt[maxn], psuf[maxn];
int m, s;
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
s++;
if (a[i] != a[i + 1]) {
m++;
num[m] = a[i];
cnt[m] = s;
s = 0;
}
}
for (int i = 2; i <= m; i++) {
pre[i] = pre[i - 1] + pcnt[i - 1] * (num[i] - num[i - 1]) +
cnt[i - 1] * (num[i] - num[i - 1] - 1);
pcnt[i] = pcnt[i - 1] + cnt[i - 1];
}
for (int i = m - 1; i >= 1; i--) {
suf[i] = suf[i + 1] + psuf[i + 1] * (num[i + 1] - num[i]) +
cnt[i + 1] * (num[i + 1] - num[i] - 1);
psuf[i] = cnt[i + 1] + psuf[i + 1];
}
long long real = maxx, flag = 0;
for (int i = 1; i <= m; i++) {
long long ans1 = maxx, ans2 = maxx, ans3 = maxx;
int res = k - cnt[i];
if (res <= 0) {
cout << "0\n";
flag = 1;
break;
} else {
if (pcnt[i] - res >= 0) ans1 = pre[i] + res;
if (psuf[i] - res >= 0) ans2 = suf[i] + res;
ans3 = pre[i] + suf[i] + res;
real =
real < min(ans1, min(ans2, ans3)) ? real : min(ans1, min(ans2, ans3));
}
}
if (flag == 0) cout << real << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 1e9;
const long long IINF = 1e18;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const char dir[4] = {'D', 'R', 'U', 'L'};
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
os << v[i] << (i + 1 == v.size() ? '\n' : ' ');
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
cout << '(' << p.first << ',' << p.second << ')';
return os;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int MAX = 2e5 + 10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
vector<priority_queue<int, vector<int>, greater<int>>> pqv(MAX);
for (int i = 0; i < n; ++i) {
for (int j = 0;; ++j) {
pqv[a[i]].emplace(j);
if (!a[i]) break;
a[i] >>= 1;
}
}
int ans = INF;
for (int i = 0; i < MAX; ++i) {
if (pqv[i].size() < k) continue;
int cnt = 0;
for (int j = 0; j < k; ++j) {
cnt += pqv[i].top();
pqv[i].pop();
}
chmin(ans, cnt);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
const double eps = 1e-8, pi = acos(-1.0);
const int maxS = 1e6 + 13;
const int maxT = 1e3 + 13;
const int MOD = 835672545;
const int base = 19260817;
const int layer = 20;
using namespace std;
inline void read(char &x) { scanf("%c", &x); }
inline void read(long long &x) { scanf("%lld", &x); }
inline void read(long long &x, long long &y) {
read(x);
read(y);
}
inline void read(long long &x, long long &y, long long &z) {
read(x, y);
read(z);
}
inline void read(int &x) { scanf("%d", &x); }
inline void read(int &x, int &y) {
read(x);
read(y);
}
inline void read(int &x, int &y, int &z) {
read(x, y);
read(z);
}
int n, m, x, y, z, k, T, kase = 0;
int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
int a[maxS], res[maxS], cnt[maxS];
int main() {
read(n, m);
for (int i = 0; i < n; i++) read(a[i]);
sort(a, a + n);
for (int i = 0; i < n; i++) {
int x = a[i], k = 0;
while (x >= 0) {
if (cnt[x] == m) break;
cnt[x]++;
res[x] += k;
k++;
if (x)
x /= 2;
else
x = -1;
}
}
int ans = 1e9;
for (int i = 0; i <= 2e5; i++)
if (cnt[i] == m) ans = min(ans, res[i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long a[maxn];
long long s[maxn], ans, n, k;
bool cmp(int x, int y) { return x < y; }
int main() {
long long i, j, d;
long long ans1, ans2;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n; i++) s[i] = s[i - 1] + a[i];
ans = s[n];
for (i = 1; i <= n; i = j + 1) {
for (j = i; j <= n; j++)
if (a[j] > a[i]) break;
j--;
if (j - i + 1 >= k) {
printf("0\n");
return 0;
}
d = k - (j - i + 1);
if (i - 1 >= d && n - j >= d) {
ans1 = a[i] * (i - 1) - s[i - 1] - (i - 1);
ans2 = s[n] - s[j] - (n - j) * a[j] - (n - j);
ans = min(ans, min(ans1, ans2) + d);
}
if (i - 1 >= d && n - j < d) {
ans1 = a[i] * (i - 1) - s[i - 1] - (i - 1);
ans = min(ans, ans1 + d);
}
if (i - 1 < d && n - j >= d) {
ans2 = s[n] - s[j] - (n - j) * a[j] - (n - j);
ans = min(ans, ans2 + d);
}
if (i - 1 < d && n - j < d) {
ans1 = a[i] * (i - 1) - s[i - 1] - (i - 1);
ans2 = s[n] - s[j] - (n - j) * a[j] - (n - j);
ans = min(ans, ans1 + ans2 + d);
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N];
vector<int> ve[N];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int cnt = 0;
int t = a[i];
ve[t].push_back(0);
while (t) {
cnt++;
t >>= 1;
ve[t].push_back(cnt);
}
}
int ans = n * n + 5;
for (int i = 0; i < N; i++) {
if (ve[i].size() < k) continue;
sort(ve[i].begin(), ve[i].end());
int cnt = 0;
for (int j = 0; j < k; j++) cnt += ve[i][j];
ans = min(ans, cnt);
}
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<int> poss;
for (int i = 0; i < n; ++i) {
int x = a[i];
while (x > 0) {
poss.push_back(x);
x /= 2;
}
}
int ans = 1e9;
for (auto res : poss) {
vector<int> cnt;
for (int i = 0; i < n; ++i) {
int x = a[i];
int cur = 0;
while (x > res) {
x /= 2;
++cur;
}
if (x == res) {
cnt.push_back(cur);
}
}
if (int(cnt.size()) < k) continue;
sort(cnt.begin(), cnt.end());
ans = min(ans, accumulate(cnt.begin(), cnt.begin() + k, 0));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[1000000], pref[1000000], suf[1000000];
int main() {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (long long i = 0; i < n; i++) pref[i + 1] = pref[i] + arr[i];
long long mini = 1e18;
for (long long i = 0, j = 0; i < n; i = j) {
for (; j < n && arr[j] == arr[i]; j++)
;
long long dif = j - i;
if (dif >= k) {
cout << 0;
return 0;
}
long long l = ((arr[i] - 1) * i) - pref[i],
r = pref[n] - pref[j] - ((arr[i] + 1) * (n - j));
if (i + dif >= k && mini > l + k - dif) mini = l + k - dif;
if (dif + n - j >= k && mini > r + k - dif) mini = r + k - dif;
if (mini > l + r + k - dif) mini = l + r + k - dif;
}
cout << mini;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
vector<int> v[maxn];
int main() {
int n, k, x;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> x;
int cnt = 0;
while (x) {
v[x].push_back(cnt);
x /= 2;
cnt++;
}
}
int ans = 1e9;
for (int i = 0; i <= 200000; i++) {
if (v[i].size() >= k) {
sort(v[i].begin(), v[i].end());
int cnt = 0;
for (int j = 0; j < k; j++) cnt += v[i][j];
ans = min(ans, cnt);
}
}
cout << ans << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.