text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> valuesMap;
int getSteps(int first, int second) {
if (first < second) {
return -1;
}
if (first == second) {
return 0;
}
int steps = 0;
while (true) {
first = first / 2;
steps++;
if (first == second) {
return steps;
}
if (first == 0) {
return -1;
}
}
}
int findMin(map<int, int>& iNumbers, int pivot, int k) {
int res = 0;
int samesCount = 0;
for (auto it = iNumbers.begin(); it != iNumbers.end(); it++) {
int number = it->first;
if (number < pivot) {
continue;
}
if (valuesMap[{number, pivot}] == 0) {
samesCount = samesCount + it->second;
if (samesCount >= k) {
return res;
}
continue;
}
if (number > pivot) {
int curSteps = 0;
bool isFirstZero = false;
while (!isFirstZero) {
curSteps++;
number = number / 2;
if (number == 0) {
isFirstZero = true;
}
if (number == pivot) {
samesCount = samesCount + it->second;
res = res + curSteps * it->second;
if (samesCount >= k) {
return res - (samesCount - k) * curSteps;
}
}
if (number < pivot) {
break;
}
}
}
}
return 1000 * 1000 * 1000;
}
int main() {
int n;
cin >> n;
int k;
cin >> k;
if (n == 1 || k == 1) {
cout << 0;
return 0;
}
map<int, int> numbers;
for (int i = 0; i < n; i++) {
int number;
cin >> number;
numbers[number]++;
}
set<int> candidates;
candidates.insert(0);
for (auto it = numbers.begin(); it != numbers.end(); it++) {
auto number = it->first;
candidates.insert(number);
while (number > 0) {
number = number / 2;
candidates.insert(number);
}
}
for (auto it = numbers.begin(); it != numbers.end(); it++) {
for (auto jt = candidates.begin(); jt != candidates.end(); jt++) {
int value = getSteps(it->first, *jt);
valuesMap[{it->first, *jt}] = value;
}
}
int ans = 1000 * 1000 * 1000;
for (auto it : candidates) {
ans = min(findMin(numbers, it, k), ans);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[200005], scnt;
long long s[200005], ans = ~(1LL << 63);
map<int, int> mp;
int main() {
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 = 1; i <= n; i++) {
mp[a[i]]++;
s[i] = s[i - 1] + a[i];
}
for (auto i : mp) {
int x = i.first, cnt = i.second;
if (cnt >= k) return puts("0"), 0;
int l = k - cnt;
long long f1 = 1LL * (x - 1) * scnt - s[scnt];
long long f2 = (s[n] - s[scnt + cnt]) - 1LL * (x + 1) * (n - scnt - cnt);
if (scnt >= l) ans = min(ans, f1 + l);
if (n - scnt - cnt >= l) ans = min(ans, f2 + l);
ans = min(ans, l + f1 + f2);
scnt += cnt;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
long long solve(int n, int k, vector<int>& A) {
int N = *max_element(A.begin(), A.end());
vector<vector<int>> S(N + 1);
for (auto x : A) {
int h = 0;
int bk = x;
while (x > 0) {
++h;
x >>= 1;
}
x = bk;
S[x].push_back(h);
}
auto merge = [&](vector<int>& A, vector<int>& B, vector<int>& C) {
int n = A.size(), m = B.size();
C.resize(n + m);
for (int i = 0, j = 0, k = 0; i < n || j < m; ++k) {
if (i == n) {
C[k] = B[j++];
continue;
}
if (j == m) {
C[k] = A[i++];
continue;
}
if (A[i] <= B[j]) {
C[k] = A[i++];
} else {
C[k] = B[j++];
}
}
};
long long res = 1LL << 30;
vector<int> tmp;
for (int i = N; i > 0; --i) {
int h = 0;
int x = i;
while (x > 0) {
++h;
x >>= 1;
}
x = i;
int l = x << 1, r = x << 1 | 1;
if (l <= N) {
if (r <= N) {
merge(S[l], S[r], tmp);
} else {
tmp = S[l];
}
} else {
tmp.clear();
}
for (auto x : tmp) {
S[i].push_back(x);
}
if (S[i].size() >= k) {
long long cand = 0;
for (int j = 0; j < k; ++j) {
cand += S[i][j] - h;
}
res = min(res, cand);
}
}
return res;
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
Solution sol;
int n, k;
cin >> n >> k;
vector<int> A(n);
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
cout << sol.solve(n, k, A) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 7;
const long long INF = 1e18;
long long n, k, a[N], pre[N], ans = INF;
map<long long, long long> mp;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
mp[a[i]]++;
if (mp[a[i]] >= 2) {
a[i] = 0;
}
}
for (long long i = 1; i <= n; i++) {
if (a[i] == 0) {
continue;
}
long long need = k - mp[a[i]];
if (need <= 0) {
cout << 0;
return 0;
}
long long q_up = n - i - mp[a[i]] + 1;
long long q_down = i - 1;
long long cost_up =
(pre[n] - pre[i]) - (mp[a[i]] - 1) * a[i] - q_up * (a[i] + 1);
long long cost_down = (a[i] - 1) * (i - 1) - pre[i - 1];
if (q_up >= need) {
ans = min(ans, need + cost_up);
} else {
ans = min(ans, need + cost_up + cost_down);
}
if (q_down >= need) {
ans = min(ans, need + cost_down);
} else {
ans = min(ans, need + cost_down + cost_up);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
vector<long long> pre(n);
pre[0] = a[0];
for (int i = 1; i < n; i++) pre[i] = a[i] + pre[i - 1];
vector<int> pos;
for (int i = 0; i < n - 1; i++)
if (a[i] != a[i + 1]) pos.push_back(i);
pos.push_back(n - 1);
long long ans = 1e18;
for (int i = 0; i < pos.size(); i++) {
int lpos = (i ? pos[i - 1] + 1 : 0);
int rpos = pos[i];
long long need = k - (rpos - lpos + 1);
if (need <= 0) {
cout << 0;
return 0;
}
long long lsum = (lpos * a[lpos]) - (lpos ? pre[lpos - 1] : 0);
long long rsum = (pre[n - 1] - pre[rpos]) - (n - rpos - 1) * a[lpos];
if (lpos >= need) ans = min(ans, lsum - lpos + need);
if (n - rpos - 1 >= need) ans = min(ans, rsum - (n - rpos - 1) + need);
ans = min(ans, lsum + rsum - (n - k));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200005];
long long sum, ans = 0;
int main() {
int n, k, i, x, cnt;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> x;
cnt = 0;
while (x) {
v[x].push_back(cnt++);
if (x == 0) break;
x >>= 1;
}
}
sum = 1e9;
for (i = 0; i < 200001; i++) {
if (v[i].size() < k) continue;
sort(v[i].begin(), v[i].end());
ans = 0;
for (int j = 0; j < k; j++) {
ans += v[i][j];
}
sum = min(sum, ans);
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimization("O2")
#pragma GCC optimization("avx2, unroll-loops")
using namespace std;
const int N = 2e5 + 5;
int n, k, a[N], ans;
vector<int> V[N];
void read_input() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
}
void add(int x) {
int cnt = 0;
while (x) {
V[x].push_back(cnt++);
x >>= 1;
}
V[x].push_back(cnt);
}
void solve() {
sort(a, a + n);
for (int i = 0; i < n; i++) {
add(a[i]);
}
ans = 1e9;
for (int i = 0; i < N; i++) {
if ((int)V[i].size() >= k) {
ans = min(ans, accumulate(V[i].begin(), V[i].begin() + k, 0));
}
}
}
void write_output() { cout << ans; }
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) {
read_input(), solve(), write_output();
}
return 0;
}
|
#include <bits/stdc++.h>
const long long N = 2e5 + 5;
long long a[N], num[N], cnt[N];
long long pre[N], suf[N], pcnt[N], scnt[N];
long long ans = 1e18;
using namespace std;
long long quick_power_mod(long long a, long long b, long long m) {
a %= m;
long long result = 1;
while (b > 0) {
if (b & 1) result = (result * a) % m;
a = (a * a) % m;
b >>= 1;
}
return result;
}
long long comp(long long a, long long b, long long p) {
if (a < b) return 0;
if (a == b) return 1;
if (b > a - b) b = a - b;
long long ans = 1, ca = 1, cb = 1;
for (long long i = 0; i < b; i++) {
ca = (ca * (a - i)) % p;
cb = (cb * (b - i)) % p;
}
ans = (ca * quick_power_mod(cb, p - 2, p)) % p;
return ans;
}
long long lucas(long long n, long long m, long long p) {
long long ans = 1;
while (n && m && ans) {
ans = (ans * comp(n % p, m % p, p)) % p;
n /= p;
m /= p;
}
return ans;
}
long long ssum(long long x) {
long long s = 0;
for (long long i = 0; i < x; i++) {
s += i;
}
return s;
}
long long visss[1005];
void PPrime() {
for (long long i = 2; i < 1000; i++) {
if (visss[i] == 0) {
for (long long j = 2 * i; j < 1000; j += i) {
visss[j] = 1;
}
}
}
}
long long n, k;
long long C(long long x) { return x * (x - 1) / 2; }
bool solve(long long i) {
long long num = C(n - i);
long long temp = k - num;
if (temp <= n - i) {
long long x = i, y = n - temp + 1;
for (long long i = 1; i <= n; i++)
if (i != x && i != y)
printf("a");
else
printf("b");
puts("");
return 1;
}
return 0;
}
vector<long long> f, g;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
lucas(1000, 100, 1000007);
lucas(1000, 200, 1000007);
ssum(100);
PPrime();
long long n, k, m = 0;
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
long long S = 0;
for (long long i = 1; i <= n; i++) {
S++;
if (a[i] != a[i + 1]) {
m++;
num[m] = a[i], cnt[m] = S;
S = 0;
}
}
for (long long 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 (long long 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];
}
for (long long i = 1; i <= m; i++) {
long long res = k - cnt[i];
if (res <= 0) {
cout << "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);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, MOD = 1e9 + 7, inf = 100000000000000;
long long a[N], pref[N], suff[N];
struct grp {
long long f = 0, st, en;
};
void solve() {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
pref[0] = a[0];
for (long long i = 1; i < n; i++) pref[i] = pref[i - 1] + a[i];
suff[0] = a[n - 1];
for (long long i = n - 2, j = 1; i >= 0; i--, j++)
suff[j] = suff[j - 1] + a[i];
map<long long, grp> mp;
mp[a[0]].f++;
mp[a[0]].st = mp[a[0]].en = 0;
for (long long i = 1; i < n; i++) {
mp[a[i]].f++;
if (a[i] != a[i - 1]) {
mp[a[i]].st = mp[a[i]].en = i;
mp[a[i - 1]].en = i - 1;
}
}
if (a[n - 1] == a[n - 2]) mp[a[n - 1]].en = n - 1;
long long ans = inf;
for (auto x : mp) {
if (x.second.f >= k) {
cout << 0 << "\n";
return;
}
long long idx1, idx2, req = k - x.second.f, temp = 0, val = x.first;
idx1 = x.second.st - 1;
idx2 = x.second.en + 1;
if (req <= idx1 + 1) {
temp = (idx1 + 1) * (val - 1) - pref[idx1];
temp += req;
ans = min(ans, temp);
} else {
if (idx1 >= 0) temp = (idx1 + 1) * (val - 1) - pref[idx1];
if (n - idx2 - 1 >= 0)
temp += suff[n - idx2 - 1] - (n - idx2) * (val + 1);
temp += req;
ans = min(ans, temp);
}
if (req <= n - idx2) {
temp = suff[n - idx2 - 1] - (n - idx2) * (val + 1);
temp += req;
ans = min(ans, temp);
} else {
if (idx1 >= 0) temp = (idx1 + 1) * (val - 1) - pref[idx1];
if (n - idx2 - 1 >= 0)
temp += suff[n - idx2 - 1] - (n - idx2) * (val + 1);
temp += req;
ans = min(ans, temp);
}
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
vector<long long> ar(n + 5);
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
map<int, vector<int>> mp;
for (int i = 0; i < n; i++) {
int cur = ar[i];
int j = 0;
while (cur > 0) {
mp[cur].push_back(j);
cur = cur >> 1;
j++;
if (cur == 0) mp[cur].push_back(j);
}
}
long long ans = 1e10;
for (auto &v : mp) {
if (v.second.size() >= k) {
sort(v.second.begin(), v.second.end());
long long s = 0;
for (int i = 0; i < k; i++) {
s += v.second[i];
}
ans = min(s, ans);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 2e5 + 10;
int a[mxn];
int main() {
map<int, int> mark, ans;
map<int, int>::iterator it;
int n, k;
cin >> n >> k;
int a[n + 2];
for (int i = 0; i < n; i++) {
cin >> a[i];
mark[a[i]]++;
}
sort(a, a + n);
for (int i = 0; i < n; i++)
if (mark[a[i]] >= k) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
int op = 0;
while (a[i] > 0) {
a[i] /= 2;
op++;
if (mark[a[i]] < k) {
mark[a[i]]++;
ans[a[i]] += op;
}
}
}
int res = 1e9;
for (it = ans.begin(); it != ans.end(); it++)
if (mark[it->first] == k) res = min(res, it->second);
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fac[2000005];
void pre() {
fac[0] = 1;
fac[1] = 1;
for (int i = 2; i < 200005; i++) fac[i] = (i * fac[i - 1]) % 1000000007;
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b = b / 2;
}
return res % 1000000007;
}
long long ncr(long long n, long long r) {
return ((fac[n] * power(fac[r], 1000000007 - 2)) % 1000000007 *
power(fac[n - r], 1000000007 - 2)) %
1000000007;
}
long long n, m;
long long a[200005];
long long tot = 0;
long long can(long long p6) {
long long sum1 = 0;
long long sum2 = 0;
long long f = 0;
for (int i = 0; i < n; i++) {
long long have = 0;
long long p1 = tot - sum1 - a[i];
long long p2 = i * a[i] - sum1;
have += p2;
if (i + 1 >= m && have - (i + 1 - m) <= p6) {
f = 1;
break;
}
long long p3 = (n - i - 1) * a[i];
p1 -= p3;
if (n - i >= m && p1 - (n - i - m) <= p6) {
f = 1;
break;
}
have += p1;
long long can1 = n - m;
if (have - can1 <= p6) {
f = 1;
break;
}
sum1 += a[i];
}
return f;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
t = 1;
while (t--) {
cin >> n >> m;
map<long long, long long> mp;
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
tot += a[i];
}
sort(a, a + n);
for (auto it : mp) {
if (it.second >= m) {
cout << "0" << endl;
return 0;
}
}
long long lo = 1;
long long hi = 1e18;
long long ans = -1;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (can(mid)) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
cout << ans << endl;
}
}
|
#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;
}
double argminimal(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(function<double(double)> f, double l, double r, int iter = 80) {
return f(argminimal(f, l, r, iter));
}
double argmaximal(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(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;
}
}
long long ans = 1e18;
{
auto achievable = [&](int m) {
int c = 0;
for (int i = 0; i < (int)(n); ++i) c += (a[i] >= m);
return c >= k;
};
int l = 0, r = 1e9 + 1;
while (r - l > 1) {
int m = (l + r) / 2;
if (achievable(m)) {
l = m;
} else {
r = m;
}
}
long long res = 0;
for (int i = 0; i < (int)(n); ++i) res += max(a[i] - (l + 1), 0LL);
res += k - hist[l];
chmin(ans, res);
}
{
auto achievable = [&](int m) {
int c = 0;
for (int i = 0; i < (int)(n); ++i) c += (a[i] <= m);
return c >= k;
};
int l = 0, r = 1e9;
while (r - l > 1) {
int m = (l + r) / 2;
if (achievable(m)) {
r = m;
} else {
l = m;
}
}
long long res = 0;
for (int i = 0; i < (int)(n); ++i) res += max(r - 1 - a[i], 0LL);
res += k - hist[r];
chmin(ans, res);
}
{
auto cost = [&](int m) {
long long c = 0;
for (int i = 0; i < (int)(n); ++i) {
if (a[i] == m) continue;
c += max(a[i] - (m + 1), 0LL);
c += max(m - 1 - a[i], 0LL);
}
c += k - hist[m];
return c;
};
auto negativeGradient = [&](int m) { return cost(m + 1) - cost(m) < 0; };
int l = 0, r = 1e9;
while (r - l > 1) {
int m = (l + r) / 2;
if (negativeGradient(m)) {
l = m;
} else {
r = m;
}
}
chmin(ans, cost(r));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int>> m;
int32_t main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
m[a].push_back(0);
int j = 1;
while (a) {
a >>= 1;
m[a].push_back(j++);
}
}
int ans = 411111111;
for (auto &p : m) {
if (p.second.size() >= k) {
sort(p.second.begin(), p.second.end());
int aux = 0;
for (int i = 0; i < p.second.size() and i < k; i++) aux += p.second[i];
ans = min(ans, aux);
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long fw[200005], bk[200005];
int af[200005], ab[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n >> k;
map<int, int> mp;
for (int i = 0, x; i < n; i++) cin >> x, mp[x]++;
vector<pair<int, int>> b(mp.begin(), mp.end());
for (auto [x, y] : b)
if (y >= k) return cout << "0\n", 0;
int m = b.size();
long long cost = 0;
int amt = 0;
for (int i = 0; i < m - 1; i++) {
fw[i] = cost;
amt += b[i].second;
af[i] = amt;
cost += 1ll * (b[i + 1].first - b[i].first) * amt;
}
cost = 0;
amt = 0;
for (int i = m - 1; i > 0; i--) {
bk[i] = cost;
amt += b[i].second;
ab[i] = amt;
cost += 1ll * (b[i].first - b[i - 1].first) * amt;
}
long long sol = 1e18;
for (int i = 0; i < m; i++) {
if (i > 0 && af[i - 1] + b[i].second >= k)
sol =
min(sol, fw[i - 1] + (b[i].first - b[i - 1].first - 1ll) * af[i - 1] +
k - b[i].second);
if (i + 1 < m && ab[i + 1] + b[i].second >= k)
sol =
min(sol, bk[i + 1] + (b[i + 1].first - b[i].first - 1ll) * ab[i + 1] +
k - b[i].second);
if (i > 0 && i + 1 < m) {
sol = min(
sol, fw[i - 1] + (b[i].first - b[i - 1].first - 1ll) * af[i - 1] +
bk[i + 1] + (b[i + 1].first - b[i].first - 1ll) * ab[i + 1] +
k - b[i].second);
}
}
cout << sol << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ans = 1e9;
vector<int> a(200000 + 10);
vector<vector<int> > v(200000 + 10);
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
int x = a[i], cur = 0;
while (x > 0) {
v[x].push_back(cur);
x /= 2;
cur++;
}
}
for (int i = 0; i <= 200000; i++) {
sort(v[i].begin(), v[i].end());
if (int(v[i].size()) < k) continue;
ans = min(ans, accumulate(v[i].begin(), v[i].begin() + k, 0));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const long long int mod = 9999999999999983;
long long int primes[6] = {1125899906842597, 1495921043, 1005985879,
1495921043, 1005985879, 1495921043};
using namespace std;
vector<long long int> adj[2000009];
long long int parent[2000009];
long long int vis[2000009];
long long int level[2000009];
long long int dist[2000009];
long long int dp[100009];
long long int arr[100009];
long long int brr[2000009];
long long int crr[2000009];
long long int hashing[2000009];
long long int ar[509][509];
long long int br[509][509];
long long int cr[509][509];
long long int multiply(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
long long int sub(long long int a, long long int b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = ((res % p) * (x % p)) % p;
y = y >> 1;
x = ((x % p) * (x % p)) % p;
}
return res;
}
int main() {
int start_s = clock();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vector<long long int> vect, vt, vct;
vector<long long int>::iterator itt;
set<long long int> st;
set<long long int>::iterator itr;
map<long long int, long long int> mp, mpp, mp1, mp2;
map<long long int, long long int>::iterator it;
long long int i, j, k, n, m, p, res1, res2, q, t, a, b, c,
maxi = INT_MIN, mini = INT_MAX, sum = 0, ans = 0, res = 0, val = 0,
ans1 = 0, ans2 = 0, rem = 0, diff = 0, cnt = 0, l, r, flag = 0, e, index,
val1 = 0, val2 = 0, z, h = 0, u, v, mid, len, tot, fl = 0;
string str, str1, str2;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> arr[i];
}
sort(arr + 1, arr + n + 1);
for (i = 1; i <= n; i++) {
cnt = 0;
mp[arr[i]]++;
if (mp[arr[i]] >= k) {
vis[arr[i]] = 1;
}
val = arr[i];
while (val > 0) {
cnt++;
val /= 2;
if (vis[val] == 0) {
mp[val]++;
mpp[val] += cnt;
if (mp[val] >= k) {
vis[val] = 1;
}
}
}
}
for (it = mp.begin(); it != mp.end(); it++) {
if (it->second >= k) mini = min(mini, mpp[it->first]);
}
cout << mini;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
const long double PI = (long double)(3.1415926535897932384626433832795);
void solve() {
map<int, vector<int> > mp;
int n, k;
cin >> n >> k;
for (long long i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
int cnt = 0;
mp[tmp].push_back(cnt);
while (tmp) {
tmp /= 2;
cnt++;
mp[tmp].push_back(cnt);
}
}
long long mn = (long long)1e18;
for (auto x : mp) {
if (x.second.size() >= k) {
long long tmp = 0;
sort((x.second).begin(), (x.second).end());
for (long long i = 0; i < k; ++i) {
tmp += x.second[i];
}
mn = min(mn, tmp);
}
}
cout << mn << endl;
}
int main() {
long long t = 1;
for (long long i = 0; i < t; ++i) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
int n, k;
int a[100001];
int b[100001];
int min = 0x3f3f3f3f;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
b[a[i]]++;
}
std::sort(a + 1, a + n + 1);
for (int i = 0; i <= 200001; ++i) {
int ans = i, answer = 0, need = k;
for (int j = 1; j <= n; ++j) {
int kk = a[j];
int step = 0;
while (kk > ans) kk /= 2, ++step;
if (kk == ans && need) answer += step, --need;
if (!need) break;
}
if (!need) min = std::min(answer, min);
}
printf("%d", min);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const long long mod = 998244353;
const long double eps = 1e-9;
const long double PI = acos(-1.0);
long long n, k, ans = 223372036854775807, num[501000], s[501000];
map<long long, long long> mp;
int main() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) cin >> num[i];
for (int i = 1; i <= n; i++) {
mp[num[i]]++;
if (mp[num[i]] >= k) {
cout << 0;
return 0;
}
}
sort(num + 1, num + 1 + n);
for (long long i = 1; i <= n; i++) s[i] = s[i - 1] + num[i];
for (long long i = 1; i <= n; i++) {
long long buf;
if (num[i] != num[i - 1]) {
buf = s[n] - s[i] - (n - i) * num[i];
if (n - i + 1 < k)
buf += (i - 1) * (num[i] - 1) - s[i - 1] + k - (n - i + 1);
ans = min(ans, buf);
if (i - 1 + mp[num[i]] >= k)
buf = (i - 1) * (num[i] - 1) - s[i - 1] + (k - mp[num[i]]);
ans = min(ans, buf);
}
if (num[i] != num[i + 1]) {
long long buf = (i - 1) * num[i] - s[i - 1];
if (i < k) buf += s[n] - s[i] - (n - i) * (num[i] + 1) + k - i;
ans = min(ans, buf);
if (n - i + mp[num[i]] >= k)
buf = s[n] - s[i] - (n - i) * (num[i] + 1) + (k - mp[num[i]]);
ans = min(ans, buf);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int32_t main() {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
map<long long, multiset<long long> > m;
for (long long i = 0; i < n; i++) {
long long temp = a[i];
long long cnt = 0;
m[temp].insert(cnt);
while (temp) {
temp /= 2;
cnt++;
m[temp].insert(cnt);
}
}
long long ans = INT_MAX;
for (auto x : m) {
if (x.second.size() >= k) {
long long cnt = 0;
long long t = 0;
for (auto y : x.second) {
if (t >= k) break;
cnt += y;
t++;
}
ans = min(ans, cnt);
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
pair<long long, long long> pre[N];
pair<long long, long long> suf[N];
int n, k, t;
unordered_map<int, int> ma;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
bool ok = false;
for (int i = 0; i < n; ++i) {
cin >> t;
++ma[t];
if (ma[t] >= k) ok = true;
}
if (ok) {
cout << 0 << endl;
exit(0);
}
vector<pair<long long, long long> > v(ma.begin(), ma.end());
sort(v.begin(), v.end());
pair<long long, long long> p = {v[0].second, 0};
pre[0] = p;
for (int i = 1; i < v.size(); ++i) {
p.second += p.first * (v[i].first - v[i - 1].first);
p.first += v[i].second;
pre[i] = p;
}
p = {v.back().second, 0};
suf[v.size() - 1] = p;
for (int i = v.size() - 2; i >= 0; --i) {
p.second += p.first * (v[i + 1].first - v[i].first);
p.first += v[i].second;
suf[i] = p;
}
long long res = 0x3f3f3f3f3f3f3f3f;
for (int i = 0; i < v.size(); ++i) {
auto [lcnt, lmov] = pre[i];
auto [rcnt, rmov] = suf[i];
if (lcnt >= k) {
res = min(res, lmov - (lcnt - k));
}
if (rcnt >= k) {
res = min(res, rmov - (rcnt - k));
}
if (lcnt < k && rcnt < k) {
res = min(res, lmov + rmov - (n - k));
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > V;
int main() {
int n, k, i, j;
scanf("%d %d", &n, &k);
int arr[n];
long long int suffix_total = 0;
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
suffix_total = suffix_total + arr[i];
}
sort(arr, arr + n);
pair<int, int> p;
p.first = arr[0];
p.second = 1;
V.push_back(p);
for (i = 1; i < n; i++) {
if (arr[i] == V[V.size() - 1].first) {
V[V.size() - 1].second++;
} else {
p.first = arr[i];
V.push_back(p);
}
}
if (V[0].second >= k || V[V.size() - 1].second >= k) {
printf("0");
return 0;
}
long long int ans = 1000000000000000000, prefix_total = 0;
int prefix_num = 0, suffix_num = n;
for (i = 0; i < V.size(); i++) {
if (V[i].second >= k) {
printf("0");
return 0;
}
int current_num = V[i].second;
long long int current_sum = V[i].first;
current_sum = current_sum * current_num;
suffix_total = suffix_total - current_sum;
suffix_num = suffix_num - current_num;
long long int cc = (k - V[i].second);
long long int first = V[i].first - 1, last = V[i].first + 1;
first = first * prefix_num - prefix_total;
last = suffix_total - last * suffix_num;
if (V[i].second + suffix_num >= k) {
ans = min(ans, last + cc);
}
if (V[i].second + prefix_num >= k) {
ans = min(ans, first + cc);
}
ans = min(ans, first + last + cc);
prefix_num = prefix_num + current_num;
prefix_total = prefix_total + current_sum;
}
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int sz = 2e5 + 5;
int n, k, f[sz], s[sz], mini = INT_MAX, a[sz];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
int num = a[i];
f[num]++;
if (f[num] >= k) mini = min(mini, s[num]);
int c = 0;
while (num > 0) {
num /= 2;
c++;
f[num]++;
s[num] += c;
if (f[num] >= k) mini = min(mini, s[num]);
}
}
cout << mini << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = int(1e9) + 7;
int main() {
int n, k;
scanf("%d%d", &n, &k);
map<int, vector<int>> m;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
int c = 0;
m[x].push_back(c);
while (x != 0) {
x /= 2;
c++;
m[x].push_back(c);
}
}
for (auto& h : m) {
sort(h.second.begin(), h.second.end());
}
int ans = mod;
for (auto& h : m) {
int f = h.second.size();
if (f >= k) {
int y = 0;
for (int i = 0; i < k; ++i) {
y += h.second[i];
}
ans = min(ans, y);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int64_t> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<int64_t> values;
vector<int64_t> counts;
int prev = 0;
for (int i = 1; i < n; ++i) {
if (a[i] != a[prev]) {
values.push_back(a[prev]);
counts.push_back(i - prev);
prev = i;
}
}
values.push_back(a[n - 1]);
counts.push_back(n - prev);
int m = values.size();
vector<int64_t> prefCount(m, 0);
vector<int64_t> prefSum(m, 0);
for (int i = 1; i < m; ++i) {
prefCount[i] = prefCount[i - 1] + counts[i - 1];
prefSum[i] = prefSum[i - 1] + values[i - 1] * counts[i - 1];
}
vector<int64_t> sufCount(m, 0);
vector<int64_t> sufSum(m, 0);
for (int i = m - 2; i >= 0; --i) {
sufCount[i] = sufCount[i + 1] + counts[i + 1];
sufSum[i] = sufSum[i + 1] + values[i + 1] * counts[i + 1];
}
int64_t result = 1e18;
for (int i = 0; i < m; ++i) {
int64_t need = k - counts[i];
if (need <= 0) {
result = 0;
continue;
}
{
int64_t needl = min(need, prefCount[i]);
int64_t costl =
needl == 0 ? 0 : prefCount[i] * (values[i] - 1) - prefSum[i] + needl;
int64_t needr = need - needl;
int64_t costr =
needr == 0 ? 0 : sufSum[i] - sufCount[i] * (values[i] + 1) + needr;
result = min(result, costl + costr);
}
{
int64_t needr = min(need, sufCount[i]);
int64_t costr =
needr == 0 ? 0 : sufSum[i] - sufCount[i] * (values[i] + 1) + needr;
int64_t needl = need - needr;
int64_t costl =
needl == 0 ? 0 : prefCount[i] * (values[i] - 1) - prefSum[i] + needl;
result = min(result, costl + costr);
}
}
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int pw(long long int a, long long int p,
long long int m = 1000000007) {
if (p == 1) return a;
long long int t = pw(a, p / 2);
t = (m + (t * t) % m) % m;
if (p % 2 != 0) t *= a;
return (t + m) % m;
}
long long int nts[200005][22], n, k;
long long int getk(long long int p) {
long long int ms = 0;
for (long long int i = 0; i < (21); i++) ms += nts[p][i];
if (ms < k) return 1000000007;
long long int ta = 0, tc = 0;
for (long long int i = 0; i < (21); i++) {
if (ta + nts[p][i] >= k) {
long long int req = k - ta;
ta += req;
tc += req * i;
} else {
ta += nts[p][i];
tc += nts[p][i] * i;
}
}
return tc;
}
void solve() {
cin >> n >> k;
for (long long int i = 0; i < (n); i++) {
long long int a;
cin >> a;
long long int steps = 0;
while (a > 0) {
nts[a][steps]++;
a = a / 2;
steps++;
}
nts[a][steps]++;
}
long long int mi = 1000000007;
for (long long int i = 0; i < (200005); i++) mi = min(mi, getk(i));
cout << mi << endl;
}
int main() {
ios::sync_with_stdio(0);
long long int t = 1;
for (long long int i = 0; i < (t); i++) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 9;
long long Cl[N];
long long Cr[N];
int sl[N];
int sr[N];
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
vector<pair<int, int> > cmp;
for (int i = 0; i < n; i++) {
if (cmp.empty() || a[i] != cmp.back().first) {
cmp.push_back(make_pair(a[i], 1));
} else {
cmp.back().second++;
}
}
int m = cmp.size();
for (int i = 0; i < m; i++) {
if (cmp[i].second >= k) {
cout << "0\n";
return 0;
}
}
Cl[0] = 0;
sl[0] = cmp[0].second;
for (int i = 1; i < m; i++) {
sl[i] = sl[i - 1] + cmp[i].second;
Cl[i] = Cl[i - 1] + (sl[i - 1] * 1ll * (cmp[i].first - cmp[i - 1].first));
}
Cr[m - 1] = 0;
sr[m - 1] = cmp[m - 1].second;
for (int i = m - 2; i >= 0; i--) {
sr[i] = sr[i + 1] + cmp[i].second;
Cr[i] = Cr[i + 1] + (sr[i + 1] * 1ll * (cmp[i + 1].first - cmp[i].first));
}
long long ans = (long long)1e18;
long long cost;
for (int i = 1; i + 1 < m; i++) {
cost = Cl[i - 1] + Cr[i + 1];
cost += (cmp[i + 1].first - cmp[i].first - 1) * 1ll * sr[i + 1];
cost += (cmp[i].first - cmp[i - 1].first - 1) * 1ll * sl[i - 1];
cost += k - cmp[i].second;
ans = min(ans, cost);
}
for (int i = 1; i < m; i++) {
if (sl[i] >= k) {
cost = Cl[i - 1];
cost += (cmp[i].first - cmp[i - 1].first - 1) * 1ll * sl[i - 1];
cost += k - cmp[i].second;
ans = min(ans, cost);
}
}
for (int i = m - 2; i >= 0; i--) {
if (sr[i] >= k) {
cost = Cr[i + 1];
cost += (cmp[i + 1].first - cmp[i].first - 1) * 1ll * sr[i + 1];
cost += k - cmp[i].second;
ans = min(ans, cost);
break;
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar(), f = 0;
for (; c < 48 || c > 57; c = getchar())
if (!(c ^ 45)) f = 1;
for (; c >= 48 && c <= 57; c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
f ? x = -x : x;
}
const int N = 200005;
int n, K, a[N], cnt[N];
long long qz[N], hz[N];
int main() {
read(n), read(K);
for (int i = 1; i <= n; i++) read(a[i]);
sort(a + 1, a + n + 1);
for (int i = n; i; i--) hz[i] = hz[i + 1] + a[i];
for (int i = 1; i <= n; i++) qz[i] = qz[i - 1] + a[i];
for (int i = 1; i <= n; i++) qz[i] = 1ll * a[i] * i - qz[i];
for (int i = n; i; i--) hz[i] = hz[i] - 1ll * a[i] * (n - i + 1);
for (int i = 1; i <= n; i++) cnt[i] = (a[i] == a[i - 1]) * cnt[i - 1] + 1;
long long res = 1e18;
for (int i = 1; i <= n; i++)
if (cnt[i] >= K) return puts("0"), 0;
for (int i = 1; i <= n; i++) {
if (i < K)
res = min(res, qz[i] + hz[i] - n + K);
else
res = min(res, qz[i] - i + K);
if (i > n - K + 1)
res = min(res, qz[i] + hz[i] - n + K);
else
res = min(res, hz[i] - n + i + K - 1);
}
return printf("%lld\n", res), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[200002];
pair<int, int> vec[200002];
long long st[200002], dr[200002];
int cntst[200002], cntdr[200002];
int cnt1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, cnt = 1, i;
long long min1 = (long long)2e17;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> v[i];
sort(v + 1, v + n + 1);
for (i = 1; i <= n; i++) {
if (v[i] != v[i + 1]) {
vec[++cnt1] = {v[i], cnt};
cnt = 0;
}
cnt++;
}
n = cnt1;
for (i = 1; i <= n; i++)
if (vec[i].second >= k) {
cout << "0";
return 0;
}
for (i = 1; i <= n; i++) {
st[i] = st[i - 1] + 1LL * cntst[i - 1] * (vec[i].first - vec[i - 1].first);
cntst[i] = cntst[i - 1] + vec[i].second;
if (cntst[i] >= k) min1 = min(min1, st[i] - (cntst[i] - k));
}
for (i = n; i >= 1; i--) {
dr[i] = dr[i + 1] + 1LL * cntdr[i + 1] * (vec[i + 1].first - vec[i].first);
cntdr[i] = cntdr[i + 1] + vec[i].second;
if (cntdr[i] >= k) min1 = min(min1, dr[i] - (cntdr[i] - k));
}
for (i = 1; i <= n; i++) {
if (k > cntst[i])
min1 = min(
min1, st[i] + dr[i + 1] + (k - cntst[i]) +
1LL * cntdr[i + 1] * (vec[i + 1].first - vec[i].first - 1));
else
break;
}
for (i = n; i >= 1; i--) {
if (k > cntdr[i])
min1 = min(
min1, st[i - 1] + dr[i] + (k - cntdr[i]) +
1LL * cntst[i - 1] * (vec[i].first - vec[i - 1].first - 1));
else
break;
}
cout << min1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long a[maxn];
long long b[maxn];
map<long long, int> m;
int main() {
int n, k;
cin >> n >> k;
int flag = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
m[a[i]]++;
if (m[a[i]] >= k) flag = 1;
}
if (flag) {
cout << 0 << endl;
return 0;
}
sort(a + 1, a + 1 + n);
long long minn = 1e16;
for (int i = 1; i <= n; i++) {
b[i] = b[i - 1] + a[i];
}
for (int i = 1; i <= n; i++) {
minn =
min(minn, (-b[i] + i * a[i]) - (n - k) + b[n] - b[i] - (n - i) * a[i]);
if (i >= k) minn = min(minn, (-b[i] + i * a[i]) - (i - k));
if (i + k <= n + 1)
minn = min(minn, b[n] - b[i - 1] - (n - i + 1) * a[i] - (n - i + 1 - k));
}
cout << minn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, i, j, ans;
cin >> n >> k;
vector<long long> v(n);
for (auto &it : v) {
cin >> it;
}
sort(v.begin(), v.end());
long long pre[n + 1];
pre[0] = 0;
for (i = 0; i < n; i++) {
pre[i + 1] = pre[i] + v[i];
}
ans = LLONG_MAX;
for (i = 0; i < n; i = j) {
j = upper_bound(v.begin(), v.end(), v[i]) - v.begin();
if (j - i >= k) {
ans = 0;
break;
}
if (i >= k - j + i) {
ans = min(ans, k - j + i + ((v[i] - 1) * i) - pre[i]);
}
if (n - j >= k - j + i) {
ans = min(ans, k - j + i - ((v[i] + 1) * (n - j)) + pre[n] - pre[j]);
}
ans = min(ans, k - j + i + ((v[i] - 1) * i) - pre[i] -
((v[i] + 1) * (n - j)) + pre[n] - pre[j]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
using namespace std;
int n;
int k;
int tot[N];
int a[N];
int ans[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
tot[a[i]]++;
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; ++i) {
int tmp = a[i];
int cur = 0;
bool flag = false;
while (tmp >= 0) {
if (flag) break;
tmp /= 2;
cur++;
if (tot[tmp] < k) {
tot[tmp]++;
ans[tmp] += cur;
}
if (tmp == 0) flag = true;
}
}
int res = INF;
for (int i = 0; i <= 200010; ++i) {
if (tot[i] >= k) res = min(res, ans[i]);
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[200002];
long long PS[200001];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
((void)0);
((void)0);
((void)0);
int N, K;
long long ans, m = 0x7fffffffffffffffLL;
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];
if (i + K - 1 <= N && A[i] == A[i + K - 1]) {
cout << "0\n";
return 0;
}
}
for (int i = K; i <= N; i++) {
ans = 1LL * K * A[K] - PS[K] - i + K;
if (A[i] != A[i + 1]) break;
}
for (int i = N - K; i >= 0; i--) {
ans = min(ans, PS[N] - PS[N - K] - 1LL * K * A[N - K + 1] - (N - K - i));
if (A[i] != A[i + 1]) break;
}
for (int i = 1; i <= N; i++)
m = min(m, PS[N] - 2 * PS[i] - 1LL * (N - 2 * i) * A[i]);
cout << min(ans, m - N + K) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[150000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
vector<vector<int>> vals(200 * 1000);
for (int i = 0; i < n; i++) {
int x = v[i];
int cur = 0;
while (x > 0) {
vals[x].push_back(cur);
x /= 2;
++cur;
}
}
int ans = 1e9;
for (int i = 0; i <= 200 * 1000; i++) {
sort(vals[i].begin(), vals[i].end());
if (int(vals[i].size()) < k) continue;
ans = min(ans, accumulate(vals[i].begin(), vals[i].begin() + k, 0));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
using namespace std;
long long int n, k, a[200005], dp[200005];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (long long int i = 1; i <= n; i++) dp[i] = dp[i - 1] + a[i];
long long int i = 1, ans = -1;
while (i <= n) {
long long int j = i;
while (j + 1 <= n && a[j + 1] == a[j]) {
j++;
}
long long int cnt = j - i + 1;
if (cnt >= k) {
ans = 0;
break;
}
long long int cur = 1e18;
long long int s1 = i - 1;
long long int s2 = n - j;
long long int ans1 = 0, ans2 = 0;
ans1 = s1 * (a[i] - 1) - dp[i - 1] + dp[0];
ans2 = dp[n] - dp[j] - s2 * (a[i] + 1);
if (s2 + cnt >= k) {
cur = min(cur, ans2);
}
if (s1 + cnt >= k) {
cur = min(cur, ans1);
}
cur = min(cur, ans1 + ans2);
cur = cur + k - cnt;
if (ans == -1) {
ans = cur;
} else
ans = min(ans, cur);
i = j + 1;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> vec;
set<long long int> s;
long long int cnt[200009], val[200009];
long long int cnt2[200009], val2[200009];
long long int n, k;
map<long long int, long long int> mp;
long long int call(long long int x) {
long long int a, b, c, y, i, j, ans;
long long int ans1, ans2;
ans1 = ans2 = 0;
ans = 0;
if (mp[x] >= k) {
return ans;
}
y = k - mp[x];
a = lower_bound(vec.begin(), vec.end(), x) - vec.begin();
a--;
b = upper_bound(vec.begin(), vec.end(), x) - vec.begin();
if (b == n) {
ans += val[a] + (((x - 1) - vec[a]) * cnt[a]) + y;
} else if (a < 0) {
ans += val2[b] + ((vec[b] - (x + 1)) * cnt2[b]) + y;
} else {
long long int yy = y;
ans1 += val[a];
c = min(cnt[a], y);
ans1 += (((x - 1) - vec[a]) * cnt[a]) + c;
y -= c;
if (y > 0) {
ans1 += val2[b];
ans1 += ((vec[b] - (x + 1)) * cnt2[b]) + y;
}
y = yy;
ans2 += val2[b];
c = min(cnt2[b], y);
ans2 += ((vec[b] - (x + 1)) * cnt2[b]) + c;
y -= c;
if (y > 0) {
ans2 += val[a];
ans2 += (((x - 1) - vec[a]) * cnt[a]) + y;
}
ans = min(ans1, ans2);
}
return ans;
}
int main() {
long long int a, b, c, d, e, i, j, l, m, x, y, t, p, r;
scanf("%lld%lld", &n, &k);
for (i = 0; i < n; i++) {
scanf("%lld", &a);
mp[a]++;
s.insert(a);
}
for (auto it = s.begin(); it != s.end(); it++) {
vec.push_back(*it);
}
n = vec.size();
cnt[0] = mp[vec[0]];
cnt2[n - 1] = mp[vec[n - 1]];
for (i = 1; i < n; i++) {
cnt[i] = cnt[i - 1] + (mp[vec[i]]);
val[i] = val[i - 1] + ((vec[i] - vec[i - 1]) * (cnt[i - 1]));
}
for (i = n - 2; i >= 0; i--) {
cnt2[i] = cnt2[i + 1] + mp[vec[i]];
val2[i] = val2[i + 1] + ((vec[i + 1] - vec[i]) * cnt2[i + 1]);
}
x = 999999999999999999;
for (i = 0; i < n; i++) {
y = call(vec[i]);
x = min(x, y);
}
printf("%lld\n", x);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
map<int, vector<int>> m;
for (int i = 0; i < n; i++) {
int x, count = 0;
cin >> x;
m[x].push_back(0);
while (x) {
count++;
x >>= 1;
m[x].push_back(count);
}
}
int ans = INT_MAX;
for (auto it = m.begin(); it != m.end(); it++) {
if (it->second.size() >= k) {
int sum = 0;
sort(it->second.begin(), it->second.end());
auto ss = it->second.begin();
for (int j = 0; j < k; j++) {
sum += (*ss);
ss++;
}
ans = min(ans, sum);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
const double pi = acos(-1.0);
const double eps = 1e-9;
using namespace std;
int n, k;
void solve() {
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort((a).begin(), (a).end());
vector<pair<long long, long long>> b;
for (int i = 0; i < n; i++) {
int j = i;
while (j < n && a[i] == a[j]) {
j++;
}
b.push_back({a[i], j - i});
i = j - 1;
}
for (auto x : b) {
if (x.second >= k) {
cout << 0 << endl;
return;
}
}
for (auto x : b) {
}
int len = b.size();
vector<long long> prefAns(len), prefKol(len);
vector<long long> suffAns(len), suffKol(len);
prefKol[0] = b[0].second;
prefAns[0] = 0;
for (int i = 1; i < b.size(); i++) {
prefAns[i] =
(b[i].first - b[i - 1].first) * prefKol[i - 1] + prefAns[i - 1];
prefKol[i] = b[i].second + prefKol[i - 1];
}
suffKol[len - 1] = b[len - 1].second;
suffAns[len - 1] = 0;
for (int i = b.size() - 2; i >= 0; i--) {
suffAns[i] =
(b[i + 1].first - b[i].first) * suffKol[i + 1] + suffAns[i + 1];
suffKol[i] = b[i].second + suffKol[i + 1];
}
long long ans = 1e18;
for (int i = 0; i < len; i++) {
long long need = k - b[i].second;
if (need <= prefKol[i] - b[i].second) {
long long ansPref = 0;
if (i > 0) {
ansPref =
prefAns[i - 1] + (b[i].first - 1 - b[i - 1].first) * prefKol[i - 1];
ans = min(ans, ansPref + need);
}
}
if (need <= suffKol[i] - b[i].second) {
long long ansSuff = 0;
if (i != len - 1) {
ansSuff =
suffAns[i + 1] + (b[i + 1].first - 1 - b[i].first) * suffKol[i + 1];
ans = min(ans, ansSuff + need);
}
}
if (i > 0 && i != len - 1) {
if (prefKol[i - 1] < need) {
long long newNeed = need - prefKol[i - 1];
assert(newNeed > 0);
long long del = (b[i + 1].first - 1 - b[i].first) * suffKol[i + 1];
ans = min(ans, prefAns[i] + suffAns[i + 1] + newNeed + del);
}
if (suffKol[i + 1] < need) {
long long newNeed = need - suffKol[i + 1];
assert(newNeed > 0);
long long del = (b[i].first - 1 - b[i - 1].first) * prefKol[i - 1];
ans = min(ans, prefAns[i - 1] + suffAns[i] + newNeed + del);
}
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(NULL), cin.tie(0), cout.tie(0);
cout.setf(ios::fixed), cout.precision(7);
int step = 1;
for (int i = 0; i < step; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m, i, v, j;
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> v;
int cnt = 0, temp;
temp = v;
while (temp > 0) {
g[temp].push_back(cnt);
temp /= 2;
cnt++;
}
g[temp].push_back(cnt);
}
int ans = 1e9;
;
for (i = 0; i < 200005; i++) {
if (g[i].size() < m) continue;
sort(g[i].begin(), g[i].end());
int cost = 0;
for (j = 0; j < m; j++) cost += g[i][j];
ans = min(ans, cost);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " , ";
__f(comma + 1, args...);
}
const int INF = 1e16;
const int nax = 2e5 + 5;
vector<int> v[nax];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
int cnt = 0;
while (x) {
v[x].push_back(cnt);
x /= 2;
cnt++;
}
}
int ans = INF;
for (int i = 1; i < nax; i++) {
sort(v[i].begin(), v[i].end());
int sum = INF;
if (v[i].size() >= k) {
sum = 0;
for (int j = 0; j < k; j++) {
sum += v[i][j];
}
}
ans = min(ans, sum);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
vector<vector<int> > arr;
arr.reserve(20);
vector<int> temp(n);
for (int i = 0; i < n; i++) cin >> temp[i];
sort(temp.begin(), temp.end());
arr.push_back(temp);
bool is = true;
int i = 0;
while (is) {
is = false;
for (int j = 0; j < n; j++) {
temp[j] = arr[i][j] / 2;
if (temp[j]) is = true;
}
arr.push_back(temp);
i++;
}
int ans = 0;
int temp_ans;
int fre, p, l = arr.size(), fre_temp;
int mx = *max_element(arr[0].begin(), arr[0].end());
for (int i = 0; i < k; i++) ans += log2(arr[0][i]) + 1;
for (int i = 1; i <= mx; i++) {
temp_ans = 0;
fre = 0, fre_temp = 0;
p = 0;
for (int j = 0; j < l; j++) {
fre_temp = upper_bound(arr[j].begin(), arr[j].end(), i) -
lower_bound(arr[j].begin(), arr[j].end(), i);
if (fre + fre_temp >= k) {
temp_ans += p * (k - fre);
fre = k;
break;
}
fre += fre_temp;
temp_ans += p * fre_temp;
p++;
}
if (fre >= k) ans = min(ans, temp_ans);
}
cout << ans << "\n";
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.sync_with_stdio(false), cin.tie(nullptr);
int n, k;
cin >> n >> k;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a.begin() + 1, a.end());
vector<ll> sum(n + 1, 0);
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + a[i];
}
ll res = sum[n];
for (int l = 1, r; l <= n; l = r + 1) {
r = l;
while (r + 1 <= n && a[r] == a[r + 1]) {
++r;
}
if (r - l + 1 >= k) {
res = 0;
break;
}
int need_l = min(l - 1, k - (r - l + 1)), need_r = k - (r - l + 1) - need_l;
if (need_r <= n - r) {
ll current = 0;
if (need_l) {
current += (ll)(l - 1) * (a[l] - 1) - sum[l - 1] + need_l;
}
if (need_r) {
current += (sum[n] - sum[r]) - (ll)(n - r) * (a[r] + 1) + need_r;
}
res = min(res, current);
}
need_r = min(n - r, k - (r - l + 1)), need_l = k - (r - l + 1) - need_r;
if (need_l <= l - 1) {
ll current = 0;
if (need_l) {
current += (ll)(l - 1) * (a[l] - 1) - sum[l - 1] + need_l;
}
if (need_r) {
current += (sum[n] - sum[r]) - (ll)(n - r) * (a[r] + 1) + need_r;
}
res = min(res, current);
}
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int ara[51];
map<int, int> mp, mo;
int main() {
int n, i, mn, c, ans, k;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &ara[i]);
mp[ara[i]]++;
}
sort(ara, ara + n);
mn = 0;
ans = -1;
for (i = 0; i < n; i++) {
c = 0;
if (mp[ara[i]] >= k) {
if (ans == -1)
ans = mo[ara[i]];
else
ans = min(ans, mo[ara[i]]);
}
while (true) {
c++;
ara[i] = ara[i] >> 1;
mp[ara[i]]++;
mo[ara[i]] += c;
if (mp[ara[i]] >= k) {
if (ans == -1)
ans = mo[ara[i]];
else
ans = min(ans, mo[ara[i]]);
}
if (ara[i] == 0) break;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long cnt[3000000];
long long cost[3000000];
int main() {
long long n, k;
cin >> n >> k;
long long ans = 1e9;
vector<long long> inputs;
for (long long i = 0; i < n; ++i) {
long long a;
cin >> a;
inputs.push_back(a);
}
sort(inputs.begin(), inputs.end());
for (long long i = 0; i < n; ++i) {
long long a = inputs[i];
long long now_cost = 0;
while (a != 0) {
cnt[a]++;
cost[a] += now_cost;
if (cnt[a] >= k) {
ans = min(ans, cost[a]);
}
now_cost++;
a /= 2;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
using Float = long double;
void solve() {
Int n, k;
cin >> n >> k;
vector<pair<Int, Int>> A;
A.push_back(make_pair(0, 0));
{
map<Int, Int> mp;
for (Int(i) = (1); (i) <= (n); (i)++) {
Int a;
cin >> a;
mp[a]++;
}
for (auto x : mp) {
A.push_back(x);
}
}
A.push_back(make_pair(200001, 0));
Int m = A.size() - 2;
vector<Int> cuml(m + 2), cumr(m + 2), cntl(m + 2), cntr(m + 2);
for (Int(i) = (1); (i) <= (m); (i)++) {
cuml[i] = cuml[i - 1] + A[i].first * A[i].second;
cntl[i] = cntl[i - 1] + A[i].second;
}
for (Int(i) = (m); (i) >= (1); (i)--) {
cumr[i] = cumr[i + 1] + A[i].first * A[i].second;
cntr[i] = cntr[i + 1] + A[i].second;
}
Int res = Int(1e16);
for (Int(i) = (1); (i) <= (m); (i)++) {
Int need = max(0LL, k - A[i].second);
if (need == 0) {
cout << 0 << "\n";
return;
}
{
if (cntl[i - 1] >= need) {
Int sumk = need * A[i].first;
Int sumkm1 = (cntl[i - 1] - need) * (A[i].first - 1);
res = min(res, sumk + sumkm1 - cuml[i - 1]);
} else {
Int resl = cntl[i - 1] * A[i].first - cuml[i - 1];
Int needr = need - cntl[i - 1];
Int sumkr = needr * A[i].first;
Int sumkrp1 = (cntr[i + 1] - needr) * (A[i].first + 1);
Int resr = cumr[i + 1] - (sumkr + sumkrp1);
res = min(res, resl + resr);
}
}
{
if (cntr[i + 1] >= need) {
Int sumk = need * A[i].first;
Int sumkp1 = (cntr[i + 1] - need) * (A[i].first + 1);
res = min(res, cumr[i + 1] - (sumk + sumkp1));
} else {
Int resr = cumr[i + 1] - cntr[i + 1] * A[i].first;
Int needl = need - cntr[i + 1];
Int sumkl = needl * A[i].first;
Int sumklm1 = (cntl[i - 1] - needl) * (A[i].first - 1);
Int resl = (sumkl + sumklm1) - cuml[i - 1];
res = min(res, resr + resl);
}
}
}
cout << res << "\n";
return;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
vector<long long> v;
for (long long i = 0; i < n; i++) {
long long num = a[i];
while (num > 0) {
v.push_back(num);
num /= 2;
}
}
long long ans = 1e17;
for (auto num : v) {
vector<long long> cnt;
long long cnt1 = 0;
for (long long i = 0; i < n; i++) {
long long x = a[i];
cnt1 = 0;
while (x > num) {
cnt1++;
x /= 2;
}
if (x == num) {
cnt.push_back(cnt1);
}
}
if (cnt.size() >= k) {
sort(cnt.begin(), cnt.end());
long long sum = 0;
for (long long i = 0; i < k; i++) {
sum += cnt[i];
}
ans = min(ans, sum);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {-1, 1, 0, 0};
const int N = 2e5 + 2;
int n, k, a[N];
long long psum[N], ssum[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
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++) psum[i] = psum[i - 1] + a[i];
for (int i = n; i >= 1; i--) ssum[i] = ssum[i + 1] + a[i];
long long res = 1ll * INF * INF;
for (int i = 1; i <= n; i++) {
if (a[i] == a[i - 1]) continue;
int j = i;
while (j < n && a[j + 1] == a[j]) j++;
int x = i - 1;
int y = n - j;
int need = k - (j - i + 1);
if (need <= 0) return cout << 0, 0;
long long costL = 1ll * a[i] * x - psum[i - 1];
long long costR = ssum[j + 1] - 1ll * a[i] * y;
res = min(res, costL + costR - (x + y - need));
if (x >= need) res = min(res, costL - (x - need));
if (y >= need) res = min(res, costR - (y - need));
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
vector<int> g[N];
map<int, int> a;
map<int, int> res[N];
int am[N];
int d[N];
void build(int x = 0) {
int i = 2 * x, d = 2 * x + 1;
if (i < N && i > 0) {
g[x].push_back(i);
build(i);
}
if (d < N) {
g[x].push_back(d);
build(d);
}
}
void solve(int x, int l = 0) {
for (auto y : g[x]) {
solve(y, l + 1);
for (auto z : res[y]) {
res[x][z.first] += z.second;
}
am[x] += am[y];
}
if (a[x]) res[x][l] += a[x], am[x] += a[x];
d[x] = l;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[x]++;
}
build();
solve(0);
int r = 1e9;
for (int i = 0; i < N; i++) {
if (am[i] >= k) {
int qty = 0;
int sum = 0;
for (auto x : res[i]) {
int dd = min(k - qty, x.second);
qty += dd;
sum += dd * (x.first - d[i]);
}
r = min(r, sum);
}
}
cout << r << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, res = 1e9, ma;
int d[3][500005], a[500005];
vector<int> b[100005];
map<int, int> s[200005];
int main() {
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++) {
ma = max(ma, a[i]);
d[1][a[i]]++;
int t = a[i];
int f = 0;
while (t != 0) {
f++;
d[2][t / 2]++;
s[t / 2][d[2][t / 2]] = s[t / 2][d[2][t / 2] - 1] + f;
t = t / 2;
}
}
for (int i = 0; i <= ma; i++) {
if (d[1][i] + d[2][i] >= k) {
if (d[1][i] >= k)
res = min(res, 0);
else
res = min(res, s[i][k - d[1][i]]);
}
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
vector<vector<int> > DATA(2123456);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
int cnt = 0;
while (x > 0) {
DATA[x].push_back(cnt);
cnt++;
x /= 2;
}
DATA[0].push_back(cnt);
}
int answer = 987654321;
for (int i = 0; i <= 2123456; i++) {
if (DATA[i].size() < k) {
continue;
}
sort(DATA[i].begin(), DATA[i].end());
int answer1 = 0;
for (int j = 0; j < k; j++) {
answer1 += DATA[i][j];
}
answer = min(answer, answer1);
}
cout << answer;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> cost[200001];
int main() {
cin.sync_with_stdio(false);
int n, k;
cin >> n >> k;
int res = 1e9;
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
cost[x].push_back(0);
int cst = 1;
while (x) {
x /= 2;
cost[x].push_back(cst);
++cst;
}
}
for (int i = 0; i <= 2e5; ++i) {
sort(cost[i].begin(), cost[i].end());
int an = 0;
if (cost[i].size() >= k) {
for (int j = 0; j < k; ++j) {
an += cost[i][j];
}
res = min(res, an);
}
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 2e5 + 5;
const long long inf = 0x3f3f3f3f;
int a[N];
int num[N];
int op[N];
int main() {
std::ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = inf;
sort(a, a + n);
for (int i = 0; i < n; i++) {
int t = a[i];
num[t]++;
if (num[t] >= k) ans = min(op[t], ans);
int g = 1;
while (t != 0) {
t /= 2;
num[t]++;
op[t] += g;
g++;
if (num[t] >= k) ans = min(op[t], ans);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void error() { cerr << endl; }
template <typename Head, typename... Tail>
void error(Head H, Tail... T) {
cerr << ' ' << H;
error(T...);
}
void Solve();
int main() {
Solve();
return 0;
}
using LL = long long;
const int N = 2e6 + 5, INF = 0x3f3f3f3f;
int a[N];
LL sum[N];
LL ans = LONG_LONG_MAX;
void Solve() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = m; i <= n; i++)
if (a[i] == a[i - m + 1]) ans = 0;
if (ans == 0) return cout << 0 << endl, void();
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= n; i++) {
if (i >= m) ans = min(ans, (LL)i * a[i] - sum[i] - (i - m));
}
error(ans);
for (int i = n; i >= 1; i--) {
if (n - i + 1 >= m)
ans = min(ans, sum[n] - sum[i - 1] - (LL)(n - i + 1) * a[i] -
((n - i + 1) - m));
}
for (int i = 1; i <= n; i++) {
ans = min(ans, (LL)i * a[i] - sum[i] + sum[n] - sum[i - 1] -
(LL)(n - i + 1) * a[i] - (n - m));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
long long n, k;
vector<long long> vect, pre, suf;
long long ans = 1000000000000000007LL;
void play(long long u) {
long long x = vect[u];
long long ct = upper_bound(vect.begin(), vect.end(), x) -
lower_bound(vect.begin(), vect.end(), x);
long long lp =
lower_bound(vect.begin(), vect.end(), x - 1) - vect.begin() - 1;
long long lreq = 0;
if (lp >= 0) {
lreq = (lp + 1) * (x - 1) - pre[lp];
}
long long rp = upper_bound(vect.begin(), vect.end(), x + 1) - vect.begin();
long long rreq = 0;
if (rp < n) {
rreq = suf[rp] - (n - rp) * (x + 1);
}
long long ls = lower_bound(vect.begin(), vect.end(), x) - vect.begin();
long long rs = n - (upper_bound(vect.begin(), vect.end(), x) - vect.begin());
if (ls + ct >= k) {
ans = min(ans, lreq + (k - ct));
}
if (rs + ct >= k) {
ans = min(ans, rreq + (k - ct));
}
ans = min(ans, lreq + rreq + (k - ct));
}
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
vect.resize(n);
pre.resize(n);
suf.resize(n);
for (long long i = 0; i < n; i++) {
cin >> vect[i];
}
sort(vect.begin(), vect.end());
pre[0] = vect[0];
for (long long i = 1; i < n; i++) {
pre[i] = pre[i - 1] + vect[i];
}
suf[n - 1] = vect[n - 1];
for (long long i = n - 2; i >= 0; i--) {
suf[i] = suf[i + 1] + vect[i];
}
long long ct = 1;
long long mx = 1;
long long cur = vect[0];
for (long long i = 1; i < (long long)vect.size(); i++) {
if (vect[i] == cur) {
ct++;
mx = max(mx, ct);
} else {
cur = vect[i];
ct = 1;
}
}
mx = max(mx, ct);
if (mx >= k) {
cout << 0;
return 0;
}
for (long long i = 0; i < n; i++) {
play(i);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int t, n, i, j;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int k;
cin >> n >> k;
vector<long long int> a(n);
for (i = 0; i < n; i++) cin >> a[i];
long long int ans = 1e18;
long long int cnt[200005] = {0};
long long int cst[200005] = {0};
sort(a.begin(), a.end());
for (i = 0; i < n; i++) {
cnt[a[i]]++;
if (cnt[a[i]] == k) ans = min(ans, cst[a[i]]);
j = 0;
while (a[i] > 0) {
a[i] = a[i] / 2;
j++;
cnt[a[i]]++;
if (cnt[a[i]] <= k) cst[a[i]] += j;
if (cnt[a[i]] == k) ans = min(ans, cst[a[i]]);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, k;
int a[N];
int cnt[N];
int num[N];
long long pre[N], pcnt[N];
long long suf[N], scnt[N];
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
int ccnt = 0;
int m = 0;
for (int i = 1; i <= n; i++) {
ccnt++;
if (a[i] != a[i + 1]) {
num[++m] = a[i];
cnt[m] = ccnt;
ccnt = 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 + 10;
for (int i = 1; i <= m; i++) {
int res = k - cnt[i];
if (res <= 0) {
cout << "0\n";
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);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, k;
cin >> n >> k;
long long a[n];
unordered_map<long long, long long> um, c;
long long it = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
um[a[i]]++;
c[a[i]] += it;
if (um[a[i]] == k) {
cout << c[a[i]];
return 0;
}
}
long long ans = INT_MAX;
while (um[0] < n) {
it++;
for (long long i = 0; i < n; i++) {
if (a[i] == 0) continue;
a[i] = a[i] / 2;
um[a[i]]++;
c[a[i]] += it;
if (um[a[i]] == k) {
ans = min(c[a[i]], ans);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> arr(200005);
for (int i = 0; i < 200005; i++) {
arr[i] = 0;
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
arr[x]++;
}
int minop = 100000000;
for (int i = 1; i <= 200000; i++) {
int ops = 0;
int total = arr[i];
if (total >= k) {
cout << 0 << "\n";
return 0;
}
int power = 0;
bool hit = false;
bool flag = false;
while (!flag) {
power++;
int start = pow(2, power);
for (int j = i * start; j < i * start + start; j++) {
if (j > 200000) {
flag = true;
break;
}
ops += power * arr[j];
total += arr[j];
if (total >= k) {
int r = total - k;
ops -= power * r;
flag = true;
hit = true;
break;
}
}
if (flag) break;
}
if (!hit) continue;
minop = min(minop, ops);
}
cout << max(minop, 0) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int TESTS = 1;
while (TESTS--) {
int i, n, j, k;
cin >> n >> k;
vector<int> v(n);
vector<vector<int> > a(200005);
for (i = 0; i < n; i++) cin >> v[i];
int ans = INT_MAX;
for (i = 0; i < n; i++) {
int t = v[i], s = 0;
while (t) {
a[t].push_back(s);
s++;
t /= 2;
}
}
for (i = 0; i < 200005; i++) {
if (a[i].size() >= k) {
sort((a[i]).begin(), (a[i]).end());
int sum = 0;
for (j = 0; j < k; j++) sum += a[i][j];
ans = min(ans, sum);
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> a[maxn];
int main() {
int n, m, x, mx = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
mx = max(mx, x);
for (int j = 0;; j++) {
a[x].push_back(j);
if (x == 0) break;
x /= 2;
}
}
int ans = 1e9;
for (int i = 0; i <= mx; i++) {
if ((int)a[i].size() < m) continue;
sort(a[i].begin(), a[i].end());
int tmp = 0;
for (int j = 0; j < m; j++) {
tmp += a[i][j];
}
ans = min(ans, tmp);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200005;
long long tree[2][maxn];
void add(long long k, long long v, long long t) {
for (long long i = k; i < maxn; i += i & -i) tree[t][i] += v;
}
long long sum(long long k, long long t) {
long long res = 0;
for (long long i = k; i >= 1; i -= i & -i) res += tree[t][i];
return res;
}
long long a[maxn];
map<long long, long long> g;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
set<long long> s;
for (long long i = 0; i < n; i++) {
cin >> a[i];
s.insert(a[i]);
}
vector<long long> v(s.begin(), s.end());
for (long long i = 0; i < v.size(); i++) g[v[i]] = i + 1;
for (long long i = 0; i < n; i++) {
add(g[a[i]], a[i], 0);
add(g[a[i]], 1, 1);
}
long long best = 1e18;
for (long long i = 0; i < n; i++) {
long long cnt = sum(g[a[i]], 1) - sum(g[a[i]] - 1, 1);
if (cnt >= k) {
best = 0;
continue;
}
long long seek = k - cnt;
long long freqLeft = sum(g[a[i]] - 1, 1);
long long sumLeft = (a[i] - 1) * freqLeft - sum(g[a[i]] - 1, 0);
long long freqRight = sum(maxn - 1, 1) - sum(g[a[i]], 1);
long long sumRight =
sum(maxn - 1, 0) - sum(g[a[i]], 0) - (a[i] + 1) * freqRight;
if (freqLeft >= seek) best = min(best, sumLeft + seek);
if (freqRight >= seek) best = min(best, sumRight + seek);
best = min(best, sumLeft + sumRight + seek);
}
cout << best << '\n';
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long N = 1e6 + 10;
const long long inf = 1e18;
const long long mod = 1e9 + 7;
const long long eps = 1e-9;
const char spc = 29;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
using namespace std;
long long n, k;
long long a[N];
long long calc(long long first) {
long long grcnt = 0;
long long lscnt = 0;
long long grops = 0;
long long lsops = 0;
long long lft = k;
for (long long i = 0; i < n; ++i)
if (a[i] == first)
--lft;
else if (a[i] > first) {
++grcnt;
grops += a[i] - first - 1;
} else {
++lscnt;
lsops += first - a[i] - 1;
}
long long res = inf;
if (grcnt >= lft) res = min(res, grops + lft);
if (lscnt >= lft) res = min(res, lsops + lft);
res = min(res, lsops + grops + lft);
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
map<long long, long long> cnts;
long long sum = 0;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
++cnts[a[i]];
sum += a[i];
}
long long lscnt = 0;
long long lssum = 0;
long long res = inf;
for (auto &p : cnts) {
long long curcnt = p.second;
long long lft = k - curcnt;
long long grsum = sum - lssum - (curcnt * p.first);
long long grcnt = n - lscnt - curcnt;
if (lft <= 0) {
res = 0;
break;
}
if (grcnt >= lft) res = min(res, grsum - grcnt * (p.first + 1) + lft);
if (lscnt >= lft) res = min(res, lscnt * (p.first - 1) - lssum + lft);
res = min(res, -lssum + grsum + lscnt * (p.first - 1) -
grcnt * (p.first + 1) + lft);
lscnt += curcnt;
lssum += p.first * p.second;
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long int check(long long int n, long long int m) {
long long int ans = 0;
while (n > m) {
n = n / 2;
ans++;
}
if (n == m) {
return ans;
}
return -1;
}
int32_t main() {
long long int n, k;
scanf("%lld", &n);
scanf("%lld", &k);
vector<long long int> v(n);
long long int maxi = -1;
for (long long int i = 0; i < n; ++i) {
scanf("%lld", &v[i]);
maxi = max(maxi, v[i]);
}
long long int ans = 1e18;
sort(v.begin(), v.end());
for (long long int i = 0; i <= maxi; ++i) {
long long int ans1 = 0, k1 = 0;
for (long long int j = 0; j < n; ++j) {
long long int x = check(v[j], i);
if (x != -1) {
ans1 += x;
k1++;
if (k1 == k) {
ans = min(ans, ans1);
break;
}
}
}
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll oo = 0x3f3f3f3f3f3f3f3fLL;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, k;
cin >> n >> k;
vector<ll> a(n);
map<ll, ll> am;
for (ll i = 0; i < n; i++) cin >> a[i], am[a[i]]++;
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
map<ll, pair<ll, ll>> mx, mn;
mn[a[0]] = make_pair(0, am[a[0]]);
for (ll i = 1; i < (ll)a.size(); i++) {
mn[a[i]] =
make_pair(mn[a[i - 1]].first + mn[a[i - 1]].second * (a[i] - a[i - 1]),
mn[a[i - 1]].second + am[a[i]]);
}
mx[a.back()] = make_pair(0, am[a.back()]);
for (ll i = (ll)a.size() - 2; i >= 0; i--) {
mx[a[i]] =
make_pair(mx[a[i + 1]].first + mx[a[i + 1]].second * (a[i + 1] - a[i]),
mx[a[i + 1]].second + am[a[i]]);
}
ll res = oo;
if (am[a[0]] < k) {
res = min(res, mx[a[1]].first + (k - am[a[0]]) +
mx[a[1]].second * (a[1] - a[0] - 1));
} else {
res = 0;
}
if (am[a.back()] < k) {
res = min(res, mn[a[(ll)a.size() - 2]].first + (k - am[a.back()]) +
mn[a[(ll)a.size() - 2]].second *
(a.back() - a[(ll)a.size() - 2] - 1));
} else {
res = 0;
}
for (ll goal = 1; goal < (ll)a.size() - 1; goal++) {
ll mncost = mn[a[goal - 1]].first;
ll mxcost = mx[a[goal + 1]].first;
ll needed = max(k - am[a[goal]], 0LL);
ll curcost = 0;
if (needed > 0) {
curcost += min(needed, mn[a[goal - 1]].second) +
mn[a[goal - 1]].second * (a[goal] - a[goal - 1] - 1) + mncost;
needed -= min(needed, mn[a[goal - 1]].second);
}
if (needed > 0) {
curcost += min(needed, mx[a[goal + 1]].second) +
mx[a[goal + 1]].second * (a[goal + 1] - a[goal] - 1) + mxcost;
needed -= min(needed, mx[a[goal + 1]].second);
}
assert(needed == 0);
res = min(res, curcost);
needed = max(k - am[a[goal]], 0LL);
curcost = 0;
if (needed > 0) {
curcost += min(needed, mx[a[goal + 1]].second) +
mx[a[goal + 1]].second * (a[goal + 1] - a[goal] - 1) + mxcost;
needed -= min(needed, mx[a[goal + 1]].second);
}
if (needed > 0) {
curcost += min(needed, mn[a[goal - 1]].second) +
mn[a[goal - 1]].second * (a[goal] - a[goal - 1] - 1) + mncost;
needed -= min(needed, mn[a[goal - 1]].second);
}
assert(needed == 0);
res = min(res, curcost);
}
cout << res << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> v[N];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
;
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int now = a[i], cur = 0;
while (now) {
v[now].push_back(cur);
now /= 2;
cur++;
}
}
int ans = 2e9, cur;
for (int i = 1; i <= 2e5 + 1; i++) {
if (v[i].size() >= k) {
cur = 0;
sort(v[i].begin(), v[i].end());
for (int j = 0; j < k; j++) cur += v[i][j];
}
ans = min(ans, cur);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
void solve() {
long long int n, k;
cin >> n >> k;
long long int arr[n];
for (long long int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
vector<pair<long long int, long long int>> segs;
for (long long int i = 0; i < n;) {
long long int size = 1;
long long int j = i + 1;
while (j < n && arr[j] == arr[i]) {
size++;
j++;
}
segs.push_back({arr[i], size});
if (size >= k) {
cout << 0;
return;
}
i = j;
}
long long int size = segs.size();
long long int pref[size], suff[size];
long long int cost_left[size + 1], cost_right[size + 1];
long long int curr_size = 0;
for (long long int i = 0; i < size; i++) {
curr_size += segs[i].second;
pref[i] = curr_size;
}
curr_size = 0;
for (long long int i = size - 1; i >= 0; i--) {
curr_size += segs[i].second;
suff[i] = curr_size;
}
long long int cost = 0;
for (long long int i = 0; i < size - 1; i++) {
cost += pref[i] * (segs[i + 1].first - segs[i].first);
cost_left[i] = cost;
}
cost = 0;
for (long long int i = size - 2; i >= 0; i--) {
cost += suff[i + 1] * (segs[i + 1].first - segs[i].first);
cost_right[i + 1] = cost;
}
long long int ans = 1e15;
for (long long int i = 0; i < size; i++) {
if (i == 0) {
cost = cost_right[1] - suff[1];
long long int have = segs[i].second;
long long int need = max(0LL, k - have);
cost = cost + need;
ans = min(ans, cost);
} else if (i == size - 1) {
cost = cost_left[size - 2] - pref[size - 2];
long long int have = segs[i].second;
long long int need = max(0LL, k - have);
cost = cost + need;
ans = min(ans, cost);
} else {
long long int cost1 = cost_left[i - 1] - pref[i - 1];
long long int cost2 = cost_right[i + 1] - suff[i + 1];
long long int have = segs[i].second;
long long int need = max(0LL, k - have);
long long int ans1 = 1e15, ans2 = 1e15;
long long int temp1 = cost1, temp2 = cost2;
temp1 += min(need, pref[i - 1]);
need = max(0LL, need - pref[i - 1]);
if (need > 0) {
temp1 += temp2 + need;
}
ans1 = temp1;
need = max(0LL, k - have);
cost2 += min(need, suff[i + 1]);
need = max(0LL, need - suff[i + 1]);
if (need > 0) cost2 += cost1 + need;
ans2 = cost2;
ans = min({ans, ans1, ans2});
}
}
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>
using namespace std;
vector<vector<int>> vb(200050);
int main(int argc, const char* argv[]) {
int n, k, tem;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &tem);
int cnt = 0;
vb[tem].push_back(0);
while (tem > 0) {
cnt++;
tem /= 2;
vb[tem].push_back(cnt);
}
}
int ans = 0x3f3f3f;
for (int i = 0; i < 200050; i++) {
if (vb[i].size() >= k) {
int tem = 0;
sort(vb[i].begin(), vb[i].end());
for (int j = 0; j < k; j++) {
tem += vb[i][j];
}
ans = min(ans, tem);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char _buf[100000], *_op(_buf), *_ed(_buf);
inline int getint() {
int _s = 0, _f = 1;
char _ch = (_op == _ed && (_ed = (_op = _buf) + fread(_buf, 1, 100000, stdin),
_op == _ed)
? EOF
: *_op++);
while (!('0' <= _ch && _ch <= '9'))
(_ch == '-') && (_f = -1),
_ch =
(_op == _ed && (_ed = (_op = _buf) + fread(_buf, 1, 100000, stdin),
_op == _ed)
? EOF
: *_op++);
while (('0' <= _ch && _ch <= '9'))
_s = _s * 10 + _ch - 48,
_ch = (_op == _ed && (_ed = (_op = _buf) + fread(_buf, 1, 100000, stdin),
_op == _ed)
? EOF
: *_op++);
return _s * _f;
}
const int N = 2e5 + 2;
int n, k, a[N];
long long int pre[N], suf[N], ans = 1ll << 62;
inline void input() {
n = getint(), k = getint();
for (int i = 1; i <= n; i++) a[i] = getint();
}
inline void init() { sort(a + 1, a + 1 + n); }
inline void work() {
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + a[i];
for (int i = n; i >= 1; i--) suf[i] = suf[i + 1] + a[i];
for (int l = 1, r; l <= n; l = r + 1) {
for (r = l; a[r + 1] == a[l]; r++)
;
if (r - l + 1 >= k) return void(cout << 0);
long long int tmp = 0;
tmp += 1ll * (a[l] - 1) * (l - 1) - pre[l - 1];
tmp += suf[r + 1] - 1ll * (a[r] + 1) * (n - r);
tmp += k - (r - l + 1);
if (ans > tmp) ans = tmp;
if (r >= k) {
tmp = 1ll * (a[l] - 1) * (l - 1) - pre[l - 1] + k - (r - l + 1);
if (ans > tmp) ans = tmp;
}
if (n - l + 1 >= k) {
tmp = suf[r + 1] - 1ll * (a[r] + 1) * (n - r) + k - (r - l + 1);
if (ans > tmp) ans = tmp;
}
}
cout << ans;
}
int main() {
input();
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
long long a[n];
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
long long sum[n + 1];
sum[0] = 0;
sort(a, a + n);
for (int i = 1; i < n + 1; i++) sum[i] = sum[i - 1] + a[i - 1];
long long mini, x = 1;
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1]) {
x = 0;
}
x++;
if (x >= k) {
cout << 0;
return 0;
}
}
int ind1, ind2;
ind1 = lower_bound(a, a + n, a[k - 1]) - a - 1;
ind2 = upper_bound(a, a + n, a[k - 1]) - a - 1;
x = (a[k - 1] - 1) * (ind1 + 1) - sum[ind1 + 1] + k - ind2 + ind1;
mini = x;
ind1 = upper_bound(a, a + n, a[n - k]) - a;
ind2 = lower_bound(a, a + n, a[n - k]) - a;
x = sum[n] - sum[ind1] - (a[n - k] + 1) * (n - ind1) + k - ind1 + ind2;
mini = min(x, mini);
if (k > n / 2) {
ind1 = lower_bound(a, a + n, a[n / 2]) - a;
ind2 = upper_bound(a, a + n, a[n / 2]) - a;
x = a[n / 2] * ind1 - sum[ind1] + sum[n] - sum[ind2] -
(a[n / 2] + 1) * (n - ind2);
if (k > ind2) x += k - ind2;
mini = min(x, mini);
}
cout << mini;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int main() {
long long int n, m, i, j;
cin >> n >> m;
long long int arr[n];
for (i = 0; i < n; i++) {
cin >> arr[i];
}
long long int mx = *max_element(arr, arr + n);
vector<long long int> adj[mx + 1];
for (i = 0; i < n; i++) {
long long int x = arr[i];
long long int i = 0;
while (x != 0) {
adj[x].push_back(i);
x /= 2;
i++;
}
}
long long int ans = 100000000;
for (i = 1; i <= mx; i++) {
if (adj[i].size() != 0) {
sort(adj[i].begin(), adj[i].end());
}
}
for (i = 1; i <= mx; i++) {
if (adj[i].size() >= m) {
long long int x = 0;
for (j = 0; j < m; j++) {
x += adj[i][j];
}
ans = min(ans, x);
}
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
const int K = 441;
long long n, k;
long long a[N];
long long cnt;
inline long long solve_up() {
long long x = a[k];
long long cnt = 0;
for (int i = 1; i <= n; ++i)
if (a[i] == x) ++cnt;
long long left = k - cnt;
long long at_least = x - 1;
long long ans = 0;
for (long long i = 1; i < k; ++i) {
if (a[i] <= at_least) ans += at_least - a[i];
}
ans += left;
return ans;
}
inline long long solve_down() {
long long x = a[n - k + 1];
long long cnt = 0;
for (int i = 1; i <= n; ++i)
if (a[i] == x) ++cnt;
long long left = k - cnt;
long long at_least = x + 1;
long long ans = 0;
for (long long i = n - k + 1; i <= n; ++i) {
if (a[i] >= at_least) ans += a[i] - at_least;
}
ans += left;
return ans;
}
long long r[N];
map<long long, long long> c, res;
inline long long solve_up_and_down() {
long long s = 0;
long long ans = 1e18;
for (long long i = 1; i <= n; ++i) {
if (a[i] == a[i - 1]) {
s += a[i];
continue;
}
long long at_least = a[i] - 1;
long long cur_ans = at_least * (i - 1) - s;
res[a[i]] = cur_ans;
s += a[i];
}
s = 0;
for (long long i = n; i >= 1; --i) {
if (a[i] == a[i + 1]) {
s += a[i];
continue;
}
long long at_least = a[i] + 1;
long long cur_ans = s - at_least * (n - i);
res[a[i]] += cur_ans;
s += a[i];
}
for (auto &x : res) {
long long key = x.first, value = x.second;
long long cnt = c[key];
long long left = k - cnt;
ans = min(ans, value + left);
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> a[i], c[a[i]]++;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) {
if (a[i] == a[i - 1])
++cnt;
else
cnt = 1;
if (cnt == k) return cout << 0, 0;
}
long long ans = solve_up();
ans = min(ans, solve_down());
ans = min(ans, solve_up_and_down());
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sol0(vector<long long> &a, int k) {
int n = (int)a.size();
long long res = 1LL << 55;
long long psum = 0;
for (int i = 0; i < n; i++) {
if (i >= (k - 1)) {
long long sum = a[i] * i - psum;
long long v = sum - (i + 1 - k);
res = min(res, v);
}
psum += a[i];
}
return res;
}
long long sol1(vector<long long> &a, int k) {
int n = (int)a.size();
long long res = 1LL << 55;
long long psum = 0;
long long ssum = 0;
for (int i = 0; i < n; i++) ssum += a[i];
for (int i = 0; i < n; i++) {
ssum -= a[i];
long long sum = (a[i] * i - psum) + (ssum - a[i] * (n - 1 - i));
long long v = sum - (n - k);
res = min(res, v);
psum += a[i];
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
int j = i;
while (j < n && a[j] == a[i]) j++;
int len = j - i;
j--;
if (len >= k) {
cout << 0 << "\n";
return 0;
}
i = j;
}
long long res = sol0(a, k);
reverse(a.begin(), a.end());
for (int i = 0; i < n; i++) a[i] *= -1;
res = min(res, sol0(a, k));
res = min(res, sol1(a, k));
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LLINF = 1e18;
const int maxN = 2e5 + 5;
int arr[51];
priority_queue<int> pq[maxN];
int main() {
int n, k;
scanf("%d %d", &n, &k);
;
for (int i = 0; i < n; ++i) {
scanf("%d", &arr[i]);
;
int count = 0;
pq[arr[i]].push(0);
while (arr[i] > 0) {
count++;
arr[i] = arr[i] / 2;
pq[arr[i]].push(-count);
}
}
int mn = INF;
int moves = 0;
for (int i = 0; i < maxN; ++i) {
if (pq[i].size() < k) continue;
moves = 0;
for (int j = 0; j < k; ++j) {
moves += -pq[i].top();
pq[i].pop();
}
mn = min(moves, mn);
}
printf("%d\n", mn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_SIZE = 200005;
int count1[MAX_SIZE], count2[MAX_SIZE];
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n, 0);
int ans = INT_MAX;
for (int x, i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (int x : v) {
int shift = 0;
while (x > 0) {
count2[x]++;
count1[x] += shift++;
if (count2[x] == k) ans = min(ans, count1[x]);
x = x >> 1;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int t = 1;
vector<long long int> a, b;
int main() {
long long int k, n;
cin >> n >> k;
vector<long long int> adj[200001];
for (int i = 0; i < n; i++) {
int v;
cin >> v;
int cost = 0;
while (v > 0) {
adj[v].push_back(cost);
cost++;
v /= 2;
}
}
long long int ans = INT_MAX;
for (int i = 0; i <= 1e5 * 2; i++) {
if (adj[i].size() >= k) {
sort(adj[i].begin(), adj[i].end());
long long int sum = 0;
for (long long int j = 0; j < k; j++) {
sum += adj[i][j];
}
ans = min(ans, sum);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[200005], b[200005];
int main() {
long long int i, j, c = 0, t, l, r, mid, z, k;
scanf("%lld", &n);
scanf("%lld", &m);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
sort(a + 1, a + n + 1);
for (i = 1; i <= n; i++) {
b[i - 1] = a[i];
a[i] += a[i - 1];
}
long long ans = 1e18;
for (i = 1; i <= n; i++) {
c = a[i] - a[i - 1];
long long same = upper_bound(b, b + n, c) - lower_bound(b, b + n, c);
long long chuto = upper_bound(b, b + n, c - 1) - b;
long long boro = n - (upper_bound(b, b + n, c) - b);
if (same >= m) {
printf("0");
return 0;
}
k = m - same;
long long chutoMove = chuto * (c - 1) - a[chuto];
long long boroMove = a[n] - a[n - boro] - boro * (c + 1);
if (chuto >= k) {
ans = min(ans, chutoMove + k);
}
if (boro >= k) {
ans = min(ans, boroMove + k);
}
ans = min(ans, boroMove + chutoMove + k);
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int binary_exp(long long int a, long long int n) {
long long int i = 1;
while (n > 0) {
if (n % 2 == 1) i = (i * a) % 998244353;
a = (a * a) % 998244353;
n /= 2;
}
return i;
}
long long int IsPrime(long long int n) {
if (n == 0 || n == 1) return n;
if (n % 2 == 0) return (long long int)2;
if (n % 3 == 0)
return (long long int)3;
else {
for (long long int i = 5; i * i <= n; i += 6) {
if (n % i == 0) return i;
if (n % (i + 2) == 0) return (i + 2);
}
return n;
}
}
void solve() {
long long int n, i, j, k, a, b, pre = 0, tot = 0, ans = LLONG_MAX, req,
pre_sum = 0, temp1, temp2;
cin >> n >> k;
map<long long int, long long int> freq;
for (i = 0; i < n; i++) {
cin >> a;
tot += a;
freq[a]++;
}
map<long long int, long long int>::iterator itr, itr1, itr2;
for (itr = freq.begin(); itr != freq.end(); itr++) {
a = b = 1e10;
tot -= (itr->first * itr->second);
if (itr->second >= k) {
cout << 0;
return;
}
req = k - itr->second;
if (pre > 0) a = pre * (itr->first - 1) - pre_sum;
if (n - pre - itr->second > 0)
b = tot - (n - pre - itr->second) * (itr->first + 1);
temp1 = min(pre, req) + a;
req -= min(pre, req);
if (req > 0) temp1 += (min(req, n - pre - itr->second) + b);
req = k - itr->second;
temp2 = min(n - pre - itr->second, req) + b;
req -= min(n - pre - itr->second, req);
if (req > 0) temp2 += (min(req, pre) + a);
ans = min(ans, min(temp1, temp2));
pre += itr->second;
pre_sum += (itr->first * itr->second);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand(time(NULL));
;
int t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 998244353;
long long nop = 100;
vector<int> primes(nop, 1);
void sieve() {
primes[1] = primes[0] = 0;
for (long long i = 2; i * i <= nop; i++) {
if (primes[i]) {
for (long long j = i * i; j <= nop; j += i) {
primes[j] = 0;
}
}
}
}
long long gcd(long long a, long long b) {
if (b > a) swap(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
void extgcd(long long a, long long b, long long& x, long long& y) {
if (a == 0) {
x = a;
y = b;
return;
}
extgcd(b % a, a, x, y);
long long y1 = y, x1 = x;
x = y1 - (b / a) * x1;
y = x1;
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long bexp(long long num, long long e) {
long long ans = 1;
while (e > 0) {
if (e & 1) {
ans *= num;
}
num *= num;
e >>= 1;
}
return ans;
}
long long mexp(long long num, long long e) {
long long ans = 1;
while (e > 0) {
if (e & 1) {
ans = (ans * num) % mod;
}
num = (num * num) % mod;
e >>= 1;
}
return ans % mod;
}
long long modinv(long long a) { return bexp(a, mod - 2); }
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(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<pair<long long, long long> > info(200001,
pair<long long, long long>(0, 0));
for (long long i = 0; i < n; i++) {
info[a[i]].first++;
long long cnt = 1;
while (a[i]) {
a[i] >>= 1;
info[a[i]].first++;
if (info[a[i]].first <= k) info[a[i]].second += (cnt++);
}
}
long long ans = 0x3f3f3f3f;
for (long long i = 0; i < 200001; i++) {
if (info[i].first >= k) {
ans = min(ans, info[i].second);
}
}
cout << ans << endl;
return 0;
}
|
#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 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;
auto pushDownCost = [&](long long m) -> long long {
int c = 0;
long long res = k - hist[m];
for (int i = 0; i < (int)(n); ++i) {
c += (a[i] >= m);
res += max(a[i] - (m + 1), 0LL);
}
return c >= k ? res : INF + m;
};
auto pushUpCost = [&](long long m) -> long long {
int c = 0;
long long res = k - hist[m];
for (int i = 0; i < (int)(n); ++i) {
c += (a[i] <= m);
res += max(m - 1 - a[i], 0LL);
}
return c >= k ? res : INF - m;
};
auto sandCost = [&](long long m) -> long long {
long long res = k - hist[m];
for (int i = 0; i < (int)(n); ++i) {
res += max(a[i] - (m + 1), 0LL);
res += max(m - 1 - a[i], 0LL);
}
return res;
};
long long ans = 1e18;
chmin(ans, minimal<long long>(pushDownCost, 0, 1e9 + 1));
chmin(ans, minimal<long long>(pushUpCost, 0, 1e9 + 1));
chmin(ans, minimal<long long>(sandCost, 0, 1e9 + 1));
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);
long long n, k;
cin >> n >> k;
map<long long, long long> freq;
map<long long, long long> m;
vector<long long> v(n, 0);
long long ans = 1000000007;
for (int i = 0; i < n; i++) cin >> v[i];
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
freq[v[i]]++;
if (freq[v[i]] >= k) ans = min(ans, m[v[i]]);
long long x = v[i];
if (x == 0) continue;
long long cnt = 0;
while (1) {
x = x / 2;
freq[x]++;
cnt++;
m[x] += cnt;
if (freq[x] >= k) ans = min(ans, m[x]);
if (x == 0) break;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b % 2 != 0) {
ans = (ans * a) % 1000000007;
}
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
long long n, k;
cin >> n >> k;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1 || k == 1) {
cout << 0;
return 0;
}
sort(a, a + n);
map<long long, long long> m;
for (int i = 0; i < n; i++) {
m[a[i]]++;
}
long long mi = 1e18;
vector<pair<long long, long long>> v;
for (auto i : m) v.push_back(i);
long long b1[v.size()], b2[v.size()];
long long count1[v.size()], count2[v.size()];
b1[0] = 0;
long long cnt = 0;
for (int i = 0; i < v.size(); i++) {
if (i == 0)
b1[i] = 0;
else
b1[i] = cnt * (v[i].first - v[i - 1].first) + b1[i - 1];
cnt += v[i].second;
count1[i] = cnt;
}
b2[v.size() - 1] = 0;
cnt = 0;
for (int i = v.size() - 1; i >= 0; i--) {
if (i == v.size() - 1)
b2[i] = 0;
else
b2[i] = cnt * (v[i + 1].first - v[i].first) + b2[i + 1];
cnt += v[i].second;
count2[i] = cnt;
}
for (int i = 1; i < v.size() - 1; i++) {
long long val = v[i].first;
cnt = k - v[i].second;
if (cnt <= 0) {
mi = 0;
break;
}
long long left = val - 1, right = val + 1;
left = left - v[i - 1].first;
right = v[i + 1].first - right;
long long p = left * count1[i - 1] + b1[i - 1],
q = right * count2[i + 1] + b2[i + 1];
long long ha = cnt + p;
long long o = min(count1[i - 1], cnt);
if (cnt - o != 0) ha += q;
mi = min(mi, ha);
ha = cnt + q;
o = min(count2[i + 1], cnt);
if (cnt - o != 0) ha += p;
mi = min(mi, ha);
}
long long val = v[0].first;
cnt = k - v[0].second;
if (cnt <= 0) {
mi = 0;
} else {
long long right = val + 1;
right = v[1].first - right;
long long q = right * count2[1] + b2[1];
mi = min(mi, cnt + q);
}
val = v[v.size() - 1].first;
cnt = k - v[v.size() - 1].second;
if (cnt <= 0) {
mi = 0;
} else {
long long left = val - 1;
left = left - v[v.size() - 2].first;
long long q = left * count1[v.size() - 2] + b1[v.size() - 2];
mi = min(mi, cnt + q);
}
cout << mi;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
bool mod(long double a, long double b) { return a / b - floor(a / b); }
long long power(long long first, long long n) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = result * first;
first = first * first;
n = n / 2;
}
return result;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
unordered_map<long long, long long> m;
long long count[200002] = {0};
vector<long long> v(n);
for (long long &first : v) cin >> first;
long long mn = INT_MAX;
sort((v).begin(), (v).end());
for (long long i = 0; i < n; i++) {
long long flag = 0;
long long first = v[i];
m[first]++;
if (m[first] == k) mn = 0;
while (first > 1) {
first /= 2;
flag++;
m[first]++;
count[first] += flag;
if (m[first] == k) mn = min(mn, count[first]);
}
}
cout << mn;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[200010];
int num[200010];
int a[60];
int main() {
int n, k;
while (~scanf("%d%d", &n, &k)) {
memset(a, 0, sizeof(a));
memset(num, 0, sizeof(num));
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int ans = 0x3f3f3f3f;
for (int i = 0; i < n; i++) {
int x = a[i];
int d = 0;
while (x) {
num[x]++;
cnt[x] += d;
if (num[x] == k) {
ans = min(ans, cnt[x]);
}
x /= 2;
d++;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const int N = 1e6 + 7;
long long a[N], spre[N], ssuf[N], npre[N], nsuf[N];
map<int, int> num;
int k, n;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i], num[a[i]]++;
sort(a + 1, a + n + 1);
n = unique(a + 1, a + n + 1) - a - 1;
for (int i = 1; i <= n; i++)
npre[i] = npre[i - 1] + num[a[i]], spre[i] = spre[i - 1] + a[i] * num[a[i]];
for (int i = n; i >= 1; i--)
nsuf[i] = nsuf[i + 1] + num[a[i]], ssuf[i] = ssuf[i + 1] + a[i] * num[a[i]];
long long ans = 1e18 + 7;
for (int i = 1; i <= n; i++) {
int m = k - npre[i] + npre[i - 1];
if (m <= 0) {
ans = 0;
continue;
}
long long tmp1 = npre[i - 1] * (a[i] - 1) - spre[i - 1];
long long tmp2 = ssuf[i + 1] - nsuf[i + 1] * (a[i] + 1);
if (npre[i - 1] >= m) {
ans = min(tmp1 + m, ans);
}
if (nsuf[i + 1] >= m) {
ans = min(tmp2 + m, ans);
}
ans = min(tmp1 + tmp2 + m, ans);
}
cout << max(ans, 0ll) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LL_INF = (long long)2e18 + 5;
int main() {
int n, k;
cin >> n >> k;
vector<long long int> a;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<long long int> pre(n + 1, 0), suf(n + 1, 0);
for (int i = 0; i < n; i++) pre[i + 1] = pre[i] + a[i];
for (int i = n - 1; i >= 0; i--) suf[i] = suf[i + 1] + a[i];
long long int ans = LL_INF;
for (int i = 0, j = 0; i < n; i = j) {
long long int val = a[i];
while (j < n && a[j] == val) j++;
if (j - i >= k) {
ans = 0;
break;
}
int need = k - (j - i);
int before = i;
int after = n - j;
long long int bc = before * val - pre[i];
long long int ac = suf[j] - after * val;
if (before >= need) {
ans = min(ans, bc - (before - need));
}
if (after >= need) {
ans = min(ans, ac - (after - need));
}
ans = min(ans, ac + bc - (before + after - need));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, fans, ffans, ans, dd, zz, ans2;
cin >> n >> k;
long long int a[n + 5], s[n + 5], d[n + 5];
map<long long int, long long int> m;
for (i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a, a + n);
for (i = 0; i < n; i++) {
if (i == 0)
s[0] = a[0];
else
s[i] = s[i - 1] + a[i];
}
for (i = n - 1; i >= 0; i--) {
if (i == n - 1)
d[i] = a[i];
else
d[i] = d[i + 1] + a[i];
}
ffans = LLONG_MAX;
for (i = 0; i < n; i++) {
ans = LLONG_MAX;
ans2 = LLONG_MAX;
fans = LLONG_MAX;
if (i == n - 1 || a[i] != a[i + 1]) {
if (i >= k - 1) {
ans = k * a[i] + (i + 1 - k) * (a[i] - 1) - s[i];
}
if (n - 1 - i >= k - m[a[i]]) {
ans2 = d[i + 1] - (n - 1 - i) * (a[i] + 1);
ans2 += k - m[a[i]];
if (m[a[i]] >= k) {
ans2 = 0;
}
}
if (i != 0 && i != n - 1)
ans = min(ans, (i + 1 - m[a[i]]) * (a[i] - 1) -
(i - m[a[i]] >= 0) * s[i - m[a[i]]] + d[i + 1] -
(n - 1 - i) * (a[i] + 1) + k - m[a[i]]);
fans = min(ans, ans2);
ffans = min(ffans, fans);
}
}
cout << max(0LL, ffans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e18 + 5;
int main() {
int n, k;
cin >> n >> k;
map<int, int> f;
vector<pair<long long, long long> > v;
for (int x, i = 0; i < n; i++) {
cin >> x;
f[x]++;
}
for (auto x : f) v.emplace_back(x.first, x.second);
n = v.size();
vector<long long> leftSum(n);
vector<long long> rightSum(n);
vector<long long> amountL(n);
vector<long long> amountR(n);
amountR[n - 1] = v[n - 1].second;
amountL[0] = v[0].second;
rightSum[n - 1] = v[n - 1].first * v[n - 1].second;
leftSum[0] = v[0].first * v[0].second;
for (int i = 1; i < n; i++) {
leftSum[i] = leftSum[i - 1] + v[i].first * v[i].second;
amountL[i] = amountL[i - 1] + v[i].second;
}
for (int i = n - 2; i >= 0; i--) {
rightSum[i] = rightSum[i + 1] + v[i].first * v[i].second;
amountR[i] = amountR[i + 1] + v[i].second;
}
for (int i = 0; i < n; i++) {
amountR[i] -= v[i].second;
amountL[i] -= v[i].second;
leftSum[i] -= v[i].first * v[i].second;
rightSum[i] -= v[i].first * v[i].second;
}
long long ans = INF;
for (int i = 0; i < n; i++) {
long long need = k - v[i].second;
if (need <= 0LL) {
cout << "0\n";
return 0;
}
long long costL =
abs((v[i].first - 1) * amountL[i] - leftSum[i]) + min(amountL[i], need);
long long costR = abs((v[i].first + 1) * amountR[i] - rightSum[i]) +
min(amountR[i], need);
if (amountL[i] >= need) {
ans = min(ans, costL);
}
if (amountR[i] >= need) {
ans = min(ans, costR);
}
ans = min(ans, costL + abs((v[i].first + 1LL) * amountR[i] - rightSum[i]) +
max(need - amountL[i], 0LL));
ans = min(ans, costR + abs((v[i].first - 1LL) * amountL[i] - leftSum[i]) +
max(need - amountR[i], 0LL));
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int xd[4] = {0, 1, 0, -1}, yd[4] = {1, 0, -1, 0};
template <typename t>
bool ckmin(t& a, const t& b) {
return a > b ? a = b, true : false;
}
template <typename t>
bool ckmax(t& a, const t& b) {
return a < b ? a = b, true : false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
vector<int> a(n);
for (auto((i)) = (0); ((i)) < ((n)); ++((i))) cin >> a[i];
sort((a).begin(), (a).end());
for (int val = a[0], cnt = 1, i = 1; i < n; ++i) {
if (cnt == k) {
cout << 0 << '\n';
return 0;
}
if (a[i] == val)
cnt++;
else {
val = a[i];
cnt = 1;
}
}
vector<tuple<long long, long long, long long, long long>> prefix(n),
suffix(n);
prefix[0] = make_tuple(a[0], 1, 0, 0);
for (auto(i) = (1); (i) < (n); ++(i)) {
auto [val, amount, fr, cost] = prefix[i - 1];
prefix[i] = make_tuple(a[i], amount + 1, a[i] != val ? amount : fr,
cost + (a[i] - val) * amount);
}
suffix[n - 1] = make_tuple(a[n - 1], 1, 0, 0);
for (auto((i)) = ((n - 2)); ((i)) > (-1); --((i))) {
auto [val, amount, fr, cost] = suffix[i + 1];
suffix[i] = make_tuple(a[i], amount + 1, a[i] != val ? amount : fr,
cost + (val - a[i]) * amount);
}
long long best = numeric_limits<long long>::max();
for (int l = 0, r = 0; l < n; ++l) {
auto [val, amount, fr, cost] = prefix[l];
if (amount >= k) ckmin(best, cost - min(amount - k, fr));
while (r + 1 < n && get<0>(suffix[r + 1]) == val &&
get<1>(suffix[r + 1]) + amount >= k)
++r;
amount += get<1>(suffix[r]);
ckmin(amount, n);
fr += get<2>(suffix[r]);
cost += get<3>(suffix[r]);
ckmin(best, cost - min(fr, amount - k));
}
for (int r = n - 1, l = n - 1; ~r; --r) {
auto [val, amount, fr, cost] = suffix[r];
if (amount >= k) ckmin(best, cost - min(amount - k, fr));
while (l > 0 && get<0>(prefix[l - 1]) == val &&
get<1>(prefix[l - 1]) + amount >= k)
--l;
amount += get<1>(prefix[l]);
ckmin(amount, n);
fr += get<2>(prefix[l]);
cost += get<3>(prefix[l]);
ckmin(best, cost - min(fr, amount - k));
}
cout << best << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long dx[] = {0, 1, 0, -1};
const long long dy[] = {1, 0, -1, 0};
const long long inf = 0x3f3f3f3f3f3f3f;
const long long N = 2e5 + 11;
long long n, k, dp[N][2];
long long anss = inf;
map<long long, long long> di, insert;
void prec(map<long long, long long> s, long long turn) {
long long nr = 0;
long long mn = -1;
long long ans = 0;
long long i = (turn == 1 ? n : 1);
for (auto it : s) {
long long cur = it.first;
long long frec = it.second;
if (mn != -1) {
ans += nr * (cur - mn);
}
nr += frec;
mn = cur;
dp[i][turn] = ans;
if (turn)
i--;
else
i++;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 1, x; i <= n; i++) {
cin >> x;
di[x]++;
insert[-x]++;
if (di[x] >= k) {
anss = 0;
}
}
long long len = n;
n = (long long)((insert).size());
vector<pair<long long, long long> > v;
v.push_back(make_pair(0, 0));
for (auto it : di) {
v.push_back(make_pair(it.first, it.second));
}
prec(di, 0);
prec(insert, 1);
for (long long i = 1; i <= n; i++) {
anss = min(anss, dp[i][0] + dp[i][1] - (len - k));
}
long long nr = 0;
for (long long i = 1; i <= n; i++) {
if (nr + v[i].second >= k) {
anss = min(anss, dp[i][0] - (nr + v[i].second - k));
break;
}
nr += v[i].second;
}
nr = 0;
for (long long i = n; i > 0; i--) {
if (nr + v[i].second >= k) {
anss = min(anss, dp[i][1] - (nr + v[i].second - k));
break;
}
nr += v[i].second;
}
cout << max(0ll, anss) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const long long mod2 = 998244353;
long long spf[100005];
long long fpow(long long x, long long y) {
x = x % 1000000007;
long long res = 1;
while (y) {
if (y & 1) res = res * x;
res %= 1000000007;
y = y >> 1;
x = x * x;
x %= 1000000007;
}
return res;
}
long long inv(long long a, long long m = 1000000007) {
long long c = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += c;
return x;
}
long long cnt[200009];
long long res[200009];
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];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
long long x = a[i];
long long moves = 0;
while (x) {
if (cnt[x] < k) {
cnt[x]++;
res[x] += moves;
}
x /= 2;
moves++;
}
if (cnt[0] < k) {
cnt[0]++;
res[0] += moves;
}
}
long long result = LLONG_MAX;
for (int i = 0; i <= 200005; i++) {
if (cnt[i] >= k) result = min(result, res[i]);
}
cout << result;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200005];
int arr[200005];
pair<int, int> fr[200005];
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (int i = 0; i < n; i++) {
int x = arr[i];
while (x) {
v[i].push_back(x);
x /= 2;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < int((v[i]).size()); j++) {
if (fr[v[i][j]].first < k) {
fr[v[i][j]].first++;
fr[v[i][j]].second += j;
}
}
}
int ans = (1 << 30);
for (int i = 0; i < 200005; i++) {
if (fr[i].first == k) ans = min(ans, fr[i].second);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, h;
cin >> n >> k;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
sort(ar, ar + n);
int siz = (int)log2(ar[n - 1]) + 10;
unordered_map<int, int> freq[siz];
int grid[siz][n];
memset(grid, 0, sizeof(grid));
for (int i = 0; i < n; i++) {
grid[0][i] = ar[i];
freq[0][grid[0][i]]++;
}
for (int i = 1; i < siz; i++) {
for (int j = 0; j < n; j++) {
grid[i][j] = grid[i - 1][j] / 2;
freq[i][grid[i][j]]++;
}
}
long long int min_op = 9999999999;
for (int i = 1; i <= ar[n - 1]; i++) {
long long int op = 0;
long long int count = 0;
for (int j = 0; j < siz; j++) {
if (freq[j][i] >= k - count) {
op += (k - count) * j;
count = k;
} else {
op += freq[j][i] * j;
count += freq[j][i];
}
if (count >= k) {
break;
}
}
if (count >= k) {
if (op < min_op) min_op = op;
}
}
cout << min_op << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::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];
}
vector<long long> pod(2 * 1e5 + 2);
vector<vector<long long>> all(2 * 1e5 + 2);
for (long long i = 0; i < n; i++) {
long long x = a[i];
long long cnt = 0;
while (x >= 0) {
pod[x]++;
all[x].push_back(cnt);
if (x == x / 2) {
break;
}
x /= 2;
cnt++;
}
}
vector<long long> anses;
for (long long i = pod.size() - 1; i >= 0; i--) {
if (pod[i] >= k) {
anses.push_back(i);
}
}
long long result = 1e9;
for (long long j = 0; j < anses.size(); j++) {
long long ans = anses[j];
sort(all[ans].begin(), all[ans].end());
long long res = 0;
for (long long i = 0; i < k; i++) {
res += all[ans][i];
}
result = min(result, res);
}
cout << result;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 7;
const int modulo = 1e9 + 7;
template <typename T>
inline T sum(const T& a, const T& b) {
return T((a % modulo + b % modulo) % modulo);
}
template <typename T>
inline T mul(const T& a, const T& b) {
return T((1LL * (a % (1LL * modulo)) * (b % (1LL * modulo))) %
(1LL * modulo));
}
string to_string(string a) { return "\"" + a + "\""; }
const int N = 2e5 + 5;
int n, k, cnt[N];
vector<pair<int, int> > g[N];
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
memset(cnt, 0, sizeof cnt);
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
cnt[a]++;
}
int ans = oo;
for (int i = N - 1; i >= 0; --i) {
if (cnt[i]) {
int tmp = i, r = 0;
while (tmp) {
g[tmp].push_back(pair<int, int>(cnt[i], r));
tmp /= 2;
r++;
}
g[0].push_back(pair<int, int>(cnt[i], r));
}
}
for (int i = 0; i < N; ++i)
if (int(g[i].size()) != 0) {
int tmp = 0, sz = 0;
sort(g[i].begin(), g[i].end(), cmp);
for (pair<int, int> v : g[i]) {
int cmin = min(k - sz, v.first);
sz += cmin;
tmp += cmin * v.second;
}
if (sz == k) {
ans = min(ans, tmp);
}
}
if (ans == oo)
cout << n;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, k;
cin >> n >> k;
long long a[n];
long long i, j;
long long value = -10;
for (i = 0; i < n; i++) cin >> a[i];
long long counting[200001];
long long totalOperations[200001];
for (i = 0; i < 200001; i++) totalOperations[i] = 0;
long long count = 0;
sort(a, a + n);
for (i = 0; i < n; i++) {
if (a[i] == 0) {
counting[0]++;
} else {
counting[a[i]]++;
count = 0;
while (a[i] != 0) {
a[i] = a[i] / 2;
count++;
if (counting[a[i]] < k)
totalOperations[a[i]] = totalOperations[a[i]] + count;
counting[a[i]]++;
}
}
}
long long oper = INT_MAX;
for (i = 0; i < 200001; i++) {
if (counting[i] >= k) {
if (oper > totalOperations[i]) oper = totalOperations[i];
}
}
cout << oper << endl;
}
|
#include <bits/stdc++.h>
constexpr long long MAX_RES = 1LL << 62;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
int n, k;
std::cin >> n >> k;
std::vector<long long> a(n);
for (int i = 0; i < n; ++i) {
std::cin >> a[i];
}
std::sort(a.begin(), a.end());
std::vector<long long> b(n);
std::partial_sum(a.begin(), a.end(), b.begin());
long long res = MAX_RES;
for (int l = 0, r = 0; l < n;) {
while (r < n && a[r] == a[l]) {
++r;
}
int numCnt = r - l;
if (numCnt >= k) {
res = 0;
} else {
int numLeft = l;
long long costLeft = 0;
if (numLeft) {
costLeft = (1LL * numLeft * (a[l] - 1)) - b[l - 1];
}
int numRight = n - r;
long long costRight = 0;
if (numRight) {
costRight = (b[n - 1] - b[r - 1] - 1LL * numRight * (a[l] + 1));
}
if (numLeft + numCnt >= k || numRight + numCnt >= k) {
if (numLeft + numCnt >= k) {
res = std::min(res, costLeft + k - numCnt);
}
if (numRight + numCnt >= k) {
res = std::min(res, costRight + k - numCnt);
}
} else {
res = std::min(res, costLeft + costRight + k - numCnt);
}
}
l = r;
}
std::cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, t;
struct Stats {
long long int nBefore, nAfter, sLeft, sRight;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
map<int, int> num;
for (int i = 0; i < n; i++) {
cin >> t;
if (num[t]) {
num[t]++;
} else
num[t] = 1;
}
t = num.size();
for (auto a : num) {
if (a.second >= k) {
cout << 0 << '\n';
return 0;
}
}
vector<pair<int, int>> v(num.begin(), num.end());
vector<Stats> s(t);
long long int rsum = v[t - 1].second, lsum = v[0].second, rsteps = 0,
lsteps = 0;
s[0].nBefore = lsum;
s[0].sLeft = 0;
s[t - 1].nAfter = rsum;
s[t - 1].sRight = 0;
for (int i = 1, j = t - 2; i < t; ++i, --j) {
lsteps += (v[i].first - v[i - 1].first) * lsum;
lsum += v[i].second;
rsteps += (v[j + 1].first - v[j].first) * rsum;
rsum += v[j].second;
s[i].nBefore = lsum;
s[i].sLeft = lsteps;
s[j].nAfter = rsum;
s[j].sRight = rsteps;
}
long long int min_moves = LONG_LONG_MAX;
for (auto it = s.begin(); it != s.end(); ++it) {
long long int m;
bool cond1 = it->nBefore >= k, cond2 = it->nAfter >= k;
if (cond1 && cond2) {
m = min(it->sLeft - it->nBefore, it->sRight - it->nAfter) + k;
} else if (cond1) {
m = it->sLeft - it->nBefore + k;
} else if (cond2) {
m = it->sRight - it->nAfter + k;
} else {
m = it->sLeft + it->sRight - n + k;
}
min_moves = min(min_moves, m);
}
cout << min_moves << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[200050];
long long pre[200050];
long long suf[200050];
map<long long, long long> cnt;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
pre[i] = pre[i - 1] + a[i];
}
for (int i = n; i >= 1; i--) {
suf[i] = suf[i + 1] + a[i];
}
long long mi = 1e18;
for (int i = 1; i <= n; i++) {
if (cnt[a[i]] >= k) {
cout << 0 << endl;
return 0;
}
long long need = k - cnt[a[i]];
long long cost1 = (a[i] - 1) * (i - 1) - pre[i - 1];
long long cost2 = suf[i + cnt[a[i]]] - (a[i] + 1) * (n - i - cnt[a[i]] + 1);
long long L = i - 1;
long long R = n - i - cnt[a[i]] + 1;
if (L >= need && R >= need)
mi = min(mi, min(cost1, cost2) + need);
else if (L >= need && R < need)
mi = min(mi, cost1 + need);
else if (L < need && R >= need)
mi = min(mi, cost2 + need);
else {
mi = min(cost1 + cost2 + need, mi);
}
i += cnt[a[i]] - 1;
}
cout << mi << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, l;
int t[200002];
long long e, v, m;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> t[i];
sort(t + 1, t + n + 1);
for (int i = 1; i <= n; i++) {
if (t[i] != t[i - 1]) l = i - 1;
if (i - l >= k) {
cout << 0 << "\n";
return 0;
}
}
for (int i = 1; i < k; i++) e += t[k] - t[i];
for (int i = k + 1; i <= n; i++)
if (t[i] == t[k]) e--;
for (int i = n; i > n - k + 1; i--) v += t[i] - t[n - k + 1];
for (int i = n - k; i >= 1; i--)
if (t[i] == t[n - k + 1]) v--;
for (int i = 1; i <= n; i++) m += abs(t[i] - t[(n + 1) / 2]);
m -= n - k;
cout << min({e, v, m}) << "\n";
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.