text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long linf = (long long)1e18;
template <class TAT>
inline void read(TAT &res) {
char c;
res = 0;
bool neg = false;
while (c = getchar(), c != '-' && (c < '0' || c > '9'))
;
if (c == '-') neg = true, c = getchar();
do res = (res * 10) + (c ^ 48);
while (c = getchar(), c >= '0' && c <= '9');
if (neg) res = -res;
}
template <class TAT>
inline void print(TAT first) {
if (first == 0) {
putchar('0');
return;
}
if (first < 0) {
putchar('-');
first = -first;
}
static char stk[30];
int top = 0;
while (first) stk[++top] = first % 10 ^ 48, first /= 10;
while (top) putchar(stk[top--]);
}
namespace Program {
const int N = (int)1e6;
const int M = (int)2e9;
const int V = (int)1e7;
int n, m;
int a[N + 5];
void input() {
scanf("%d %d", &n, &m);
for (int i = 0, i_END_ = n; i < i_END_; ++i) read(a[i]);
}
int b[V + 5], c[V + 5];
bool chk(int first) {
for (int i = 0, i_END_ = first; i < i_END_; ++i) b[i] = 0;
for (int i = first, i_END_ = min(first + first, V + 1); i < i_END_; ++i)
b[i] = 1;
for (int i = first + first, i_END_ = V + 1; i < i_END_; ++i)
b[i] = b[i >> 1] + b[(i >> 1) + (i & 1)];
long long cnt = 0;
for (int i = 0, i_END_ = n; i < i_END_; ++i) cnt += b[a[i]];
return cnt >= m;
}
void solve() {
int L = 1, R = V;
int ans = -1;
while (L <= R) {
int mid = L + R >> 1;
if (chk(mid))
ans = mid, L = mid + 1;
else
R = mid - 1;
}
printf("%d\n", ans);
}
void Main() {
input();
solve();
}
} // namespace Program
int main() {
srand(time(NULL));
Program::Main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (1e6) + 1, M = (1e7) + 1;
int n, k, a[N], dp[M];
bool check(int x) {
fill(dp + 1, dp + M, 0);
for (int i = x; i <= (1e7); i++) dp[i] = max(dp[i >> 1] + dp[i + 1 >> 1], 1);
long long sum = 0;
for (int i = 0; i < n; i++) sum += dp[a[i]];
return (sum >= k);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", a + i);
int l = 0, r = 1e7;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(mid))
l = mid;
else
r = mid - 1;
}
if (!l)
printf("-1");
else
printf("%d", l);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[2 * 10000000 + 9], p2 = 1e7, x, sum;
int main() {
scanf("%lld%lld", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &x);
a[x]++;
sum += x;
}
if (sum < k) {
puts("-1");
return 0;
}
sum = 0;
while (p2 >= 1) {
if (p2 == 1)
sum += a[1] + a[2] + 2 * a[3];
else
sum += a[p2] + a[p2 * 2] + a[p2 * 2 + 1];
a[p2 + 1] += a[p2 * 2 + 1];
a[p2] += 2 * a[p2 * 2] + a[p2 * 2 + 1];
if (sum >= k) {
printf("%lld\n", p2);
return 0;
}
p2--;
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e6 + 10;
const int inf = 1e7 + 10;
using namespace std;
int n;
long long k, a[maxn];
long long cnt[inf], vis[inf];
inline long long read() {
long long res = 0;
bool flag = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') flag = 0;
c = getchar();
}
while (c <= '9' && c >= '0')
res = (res << 3) + (res << 1) + c - '0', c = getchar();
return flag ? res : -res;
}
bool cmp(long long a, long long b) { return a > b; }
inline int dfs(int res, int mid) {
if (vis[res] != -1) return vis[res];
if (res == 1) {
vis[res] = 1;
return 1;
}
int ji = (res >> 1) + 1, ou = res >> 1;
if (res >= (mid << 1)) {
if (res & 1) {
return vis[res] = ((vis[ji] = dfs(ji, mid)) + (vis[ou] = dfs(ou, mid)));
} else {
return vis[res] = ((vis[ou] = dfs(ou, mid)) << 1);
}
} else if (res >= mid) {
vis[res] = 1;
return 1;
} else
return vis[res] = 0;
}
inline bool pd(long long mid) {
memset(vis, -1, sizeof(vis));
long long sum = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] >= mid) {
sum += dfs(a[i], int(mid));
} else
return 0;
if (sum >= k) return 1;
}
return 0;
}
int main() {
scanf("%d", &n);
k = read();
long long sum = 0;
for (int i = 1; i <= n; i++) a[i] = read(), sum += a[i];
if (sum < k) {
printf("-1");
return 0;
}
sort(a + 1, a + n + 1, cmp);
long long l = 1, r = inf;
long long mid, ans = -1;
while (l <= r) {
mid = (l + r) >> 1;
if (pd(mid))
l = mid + 1, ans = mid;
else
r = mid - 1;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18;
long long int exist[10000010];
long long int acum[10000010];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
long long int n, k, maxi = 0, aux;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> aux;
exist[aux]++;
maxi = max(aux, maxi);
acum[aux]++;
}
for (int i = maxi; i >= 1; i--) {
acum[i] += acum[i + 1];
if (acum[i] >= k) {
cout << i << "\n";
return 0;
} else if (exist[i]) {
long long int a = i / 2, b = 0;
b = (i & 1) ? (a + 1) : a;
exist[a] += exist[i];
exist[b] += exist[i];
acum[a] += exist[i];
}
}
cout << -1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1024000;
int N, K, Max;
int v[maxn], dp[maxn * 10];
int dfs(int x, int cur) {
if (dp[x] != -1) return dp[x];
int &ans = dp[x];
if (x < cur) return ans = 0;
if (x == cur) return ans = 1;
int a = x / 2, b = x - x / 2;
return ans = max(1, dfs(a, cur) + dfs(b, cur));
}
bool judge(int cur) {
memset(dp, -1, sizeof(dp));
long long sum = 0;
for (int i = 0; i < N; ++i) {
if (v[i] < cur) break;
sum += dfs(v[i], cur);
if (sum >= K) return true;
}
return sum >= K;
}
int main() {
scanf("%d%d", &N, &K);
long long sum = 0;
for (int i = 0; i < N; ++i) {
scanf("%d", v + i);
sum += v[i];
Max = max(Max, v[i]);
}
sort(v, v + N, greater<int>());
if (sum < K) {
puts("-1");
return 0;
}
int L = 1, R = Max + 1, ok = 1;
while (L < R) {
int mid = L + (R - L) / 2;
if (judge(mid)) {
ok = mid;
L = mid + 1;
} else {
R = mid;
}
}
printf("%d\n", ok);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int maxx = 1e7 + 5;
long long a[maxn], cnt[maxx];
int main() {
int n, k;
scanf("%d%d", &n, &k);
long long ans = 0;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]), cnt[a[i]]++, ans += a[i];
if (ans < k) {
return puts("-1\n"), 0;
}
ans = 0;
for (int i = maxx; i >= 1; i--) {
ans += cnt[i];
if (i * 2 <= maxx) ans -= cnt[i * 2];
if (i * 2 - 1 <= maxx && i != 1) ans -= cnt[i * 2 - 1];
if (ans >= k) {
printf("%d\n", i);
break;
}
cnt[i / 2] += cnt[i];
cnt[(i + 1) / 2] += cnt[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[10000005];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long L = 1, R = 1e7;
long long res = -1;
while (L <= R) {
long long mid = (L + R) / 2;
long long temp = 0;
memset(dp, 0, sizeof(dp));
for (long long i = mid; i <= 10000000; i++) {
long long half = i / 2;
if (half >= mid) {
dp[i] = dp[half] + dp[i - half];
} else {
dp[i] = 1;
}
}
for (long long i = 0; i < n; i++) {
temp += dp[a[i]];
}
if (temp >= k) {
res = max(res, mid);
L = (L + R) / 2 + 1;
} else {
R = (L + R) / 2 - 1;
}
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int A = 1e7 + 233;
const int maxn = 1e6 + 233;
long long f[A];
int a[maxn];
int main() {
int n, k;
cin >> n >> k;
long long sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
if (sum < k) {
cout << -1 << endl;
return 0;
}
int l = 1, r = 1e7;
while (l != r) {
int mid = (l + r) >> 1;
mid++;
long long cnt = 0;
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; i++) {
f[a[i]]++;
if (a[i] >= mid) cnt++;
}
for (register int i = 1e7; i; i--)
if ((i >> 1) >= mid) {
f[(i >> 1)] += f[i];
f[i - (i >> 1)] += f[i];
cnt += f[i];
if (cnt >= k) break;
}
if (cnt >= k)
l = mid;
else
r = mid - 1;
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000;
int a[maxn + 1], n, m, mx;
long long cnt[maxn * 10 + 1], cur;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), cur += a[i], cnt[a[i]]++, mx = max(mx, a[i]);
if (cur < m) return puts("-1"), 0;
cur = 0;
for (int i = mx; i; i--) {
cur += cnt[i];
if (i * 2 <= mx) cur -= cnt[i << 1];
if (i * 2 - 1 <= mx && i != 1) cur -= cnt[i * 2 - 1];
if (cur >= m) return printf("%d\n", i), 0;
cnt[i >> 1] += cnt[i];
cnt[i + 1 >> 1] += cnt[i];
}
}
|
#include <bits/stdc++.h>
using namespace std;
int g[1200000];
int i, j, m, n, v, l, r, mid;
long long t;
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &g[i]), t = t + g[i];
if (t < m) return printf("-1"), 0;
l = 1, r = 10000000;
while (l < r) {
mid = (l + r) / 2 + 1;
t = 0;
for (i = 1; i <= n; i++) {
if (g[i] < mid) continue;
for (j = 1; g[i] / (j * 2) >= mid; j = j * 2)
;
v = j;
if ((g[i] / (j * 2)) && (g[i] / (j * 2) + 1 == mid))
v = max(v, g[i] % (j * 2));
t = t + v;
}
if (t >= m)
l = mid;
else
r = mid - 1;
}
printf("%d", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename S>
ostream &operator<<(ostream &os, const pair<T, S> &v) {
os << "(";
os << v.first << "," << v.second << ")";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
long long sz = v.size();
for (long long i = 0; i < sz; ++i) {
os << v[i];
if (i != sz - 1) os << ",";
}
os << "]\n";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
T last = *v.rbegin();
os << "[";
for (auto it : v) {
os << it;
if (it != last) os << ",";
}
os << "]\n";
return os;
}
template <typename T, typename S>
ostream &operator<<(ostream &os, const map<T, S> &v) {
for (auto it : v) {
os << it.first << " : " << it.second << "\n";
}
return os;
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2) {
res = (res * a) % 1000000007;
}
b /= 2;
a = (a * a) % 1000000007;
}
return res;
}
const long long N = 1e6 + 6;
long long n, k, mx, a[N], dp[10 * N];
bool check(long long x) {
for (__typeof(mx) i = x; i <= mx; i++) {
long long hlf = i / 2;
if (hlf >= x)
dp[i] = dp[hlf] + dp[i - hlf];
else
dp[i] = 1;
}
long long pieces = 0;
for (__typeof(n) i = 1; i <= n; i++)
if (a[i] >= x) {
pieces += dp[a[i]];
if (pieces >= k) break;
}
return pieces >= k;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (__typeof(n) i = 1; i <= n; i++) {
cin >> a[i];
mx = max(mx, a[i]);
}
sort(a + 1, a + n + 1, greater<long long>());
long long lo = 1, hi = mx, mid, ans = -1;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (check(mid)) {
ans = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000010;
long long a[maxn];
int main() {
int n, k;
long long sum = 0;
scanf("%d%d", &n, &k);
for (int i = 0, x; i < n; ++i) {
scanf("%d", &x);
sum += x;
++a[x];
}
if (sum < k) {
puts("-1");
return 0;
}
sum = n;
int p1 = 0, p2 = maxn - 1;
while (sum < k) {
sum += a[p2];
a[p2 / 2] += a[p2];
a[(p2 + 1) / 2] += a[p2];
--p2;
}
while (sum - a[p1] >= k) {
sum -= a[p1];
++p1;
}
while (p1 < p2 / 2) {
sum += a[p2];
a[p2 / 2] += a[p2];
a[(p2 + 1) / 2] += a[p2];
--p2;
while (sum - a[p1] >= k) {
sum -= a[p1];
++p1;
}
}
printf("%d\n", p1);
return 0;
}
|
#include <bits/stdc++.h>
inline void in(int &MAGNUS) { scanf("%d", &MAGNUS); }
inline void out(int MAGNUS) { printf("%d\n", MAGNUS); }
inline void in(int &MAGNUS, int &CLAR) { scanf("%d%d", &MAGNUS, &CLAR); }
inline void out(int MAGNUS, int CLAR) { printf("%d %d\n", MAGNUS, CLAR); }
inline void inl(long long &LIV) { scanf("%lld", &LIV); }
inline void inl(long long &LIV, long long &MART) {
scanf("%lld%lld", &LIV, &MART);
}
inline void outl(long long LIV) { printf("%lld\n", LIV); }
inline void outl(long long LIV, long long MART) {
printf("%lld %lld\n", LIV, MART);
}
using namespace std;
long long x[1000005], N, K, best;
long long dp[10000005];
bool ok(long long cur) {
for (int i = cur; i <= best; i++)
dp[i] = i / 2 >= cur ? dp[i / 2] + dp[i - i / 2] : 1;
long long sum = 0;
for (int i = 1; i <= N; i++) sum += dp[x[i]] * (x[i] >= cur);
return sum >= K;
}
int main() {
inl(N, K);
long long sum = 0;
best = 0;
for (int i = 1; i <= N; i++) {
inl(x[i]);
sum += x[i];
best = max(best, x[i]);
}
if (sum < K) {
out(-1);
return 0;
}
long long lo = 1, hi = best, ans = 0;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (ok(mid)) {
ans = max(ans, mid);
lo = mid + 1;
} else
hi = mid - 1;
}
outl(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
int n;
long long int k;
int arr[10000005];
long long int memo[10000005];
long long int dfs(int mn, int num) {
if (num < mn) return 0;
if (memo[num] != -1) return memo[num];
long long int res = 1;
if (num != 1) {
if (num & 1) {
res = max(res, dfs(mn, num >> 1) + dfs(mn, (num + 1) >> 1));
} else {
res = max(res, dfs(mn, num >> 1) << 1);
}
}
return memo[num] = res;
}
bool check(int mn) {
long long int cur = 0;
memset(memo, -1, (arr[n - 1] + 1) * sizeof(long long int));
for (int i = n - 1; i >= 0; --i) {
cur += dfs(mn, arr[i]);
if (cur >= k) break;
}
if (cur >= k) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
while (cin >> n >> k) {
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
sort(arr, arr + n);
int lo = 1;
int hi = 10000001;
int mi;
while (lo <= hi) {
mi = (lo + hi) >> 1;
if (check(mi)) {
lo = mi + 1;
} else {
hi = mi - 1;
}
}
if (!hi)
cout << "-1\n";
else
cout << hi << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a(1000100);
vector<long long> dp;
int main() {
int n, k;
cin >> n >> k;
long long sum = 0;
int l = 1, r = 0, mx = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
sum += a[i];
r = max(r, a[i]);
}
mx = r;
if (sum < k) {
cout << -1;
return 0;
}
if (sum == k) {
cout << 1;
return 0;
}
bool f;
int x, st;
long long cur = 0, ans = 1;
while (l <= r) {
f = 0;
cur = 0;
int mid = l + (r - l + 1) / 2;
dp.assign(mx + 1, 0);
for (int i = mid; i <= mx; ++i)
dp[i] = max(1ll, dp[i / 2] + dp[i / 2 + (i & 1)]);
for (int i = 0; i < n; ++i) cur += dp[a[i]];
if (f || cur < k)
r = mid - 1;
else {
l = mid + 1;
ans = mid;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e7;
const int maxm = 1e6;
long long a[maxm], b[maxn], maxx, n, k;
int check(long long x) {
long long cnt = 0;
for (int i = 1; i <= 10000000; i++) b[i] = 0;
for (int i = 1; i <= n; i++) b[a[i]]++;
for (int i = 10000000; i >= x; i--) {
if (i / 2 >= x) {
if (i & 1) {
b[i / 2] += b[i];
b[i / 2 + 1] += b[i];
} else
b[i / 2] += 2 * b[i];
} else
cnt += b[i];
}
return cnt >= k;
}
int main() {
while (~scanf("%lld%lld", &n, &k)) {
maxx = -1;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
long long l = 1, r = 1e7, mid, ans = -1;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
if (ans == -1) {
puts("-1");
} else {
printf("%lld\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int radix_len = 1e7 + 5;
long long cnt[radix_len];
int main() {
int n, k, a;
ios_base::sync_with_stdio(false);
cin >> n >> k;
long long tot = 0;
for (int i = (0), i_end_ = (n); i < i_end_; ++i) {
cin >> a;
cnt[a]++;
tot += a;
}
if (tot < k) {
cout << -1 << endl;
return 0;
}
auto bound = 1;
auto sum = 0LL;
for (int i = radix_len - 1; i > 0; i--) {
sum += cnt[i];
if (sum >= k) {
bound = i;
break;
}
}
for (int i = radix_len - 1; i > 1; i--) {
if (i / 2 < bound) break;
cnt[i / 2] += cnt[i];
cnt[i - i / 2] += cnt[i];
sum += cnt[i];
cnt[i] = 0;
while (sum - cnt[bound] >= k) {
sum -= cnt[bound];
bound++;
}
}
cout << bound << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long double EPS = 0.000000001;
const long long INF64 = 1000000000000000000;
const long long INF32 = 2000000000;
bool iss_ll(long long &__1, long long &__2) { return INF64 / __1 >= __2; }
bool iss_sqr(long long &__1) {
long long __2 = sqrt((long double)__1);
return __2 * __2 == __1;
};
bool iss_prime(long long __1) {
for (long long i = 2; i * i <= __1; ++i)
if (!(__1 % i)) return 0;
return 1;
}
long long gcd(long long __1, long long __2) {
while (__1 && __2)
if (__1 > __2)
__1 = __1 % __2;
else
__2 = __2 % __1;
return __1 + __2;
}
long long lcm(long long &__1, long long &__2) {
return __1 * __2 / (gcd(__1, __2));
}
long long cnt[10000100];
set<pair<long long, long long> > countt;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
long long sum = 0;
long long x;
for (long long i = 0; i < n; ++i) {
cin >> x;
sum += x;
cnt[x]++;
}
if (sum < m) {
cout << -1 << "\n";
return 0;
}
long long CNT = 0;
for (long long i = 10000000; i > 0; --i) {
if (cnt[i]) {
CNT += cnt[i];
}
}
long long pos = 0;
for (pos = 0; pos < 10000001; ++pos)
if (cnt[pos]) break;
for (long long i = 10000000; i > 1; --i) {
if (cnt[i]) {
if (CNT < m) {
if (cnt[i] >= m - CNT) {
cnt[i] -= (m - CNT);
cnt[i / 2] += (m - CNT);
cnt[i / 2 + i % 2] += (m - CNT);
CNT += (m - CNT);
} else {
cnt[i / 2] += cnt[i];
cnt[i / 2 + i % 2] += cnt[i];
CNT += cnt[i];
cnt[i] = 0;
}
}
}
if (CNT >= m) break;
}
long long newcnt = 0;
for (pos = 10000000; pos > 0; --pos) {
newcnt += cnt[pos];
if (newcnt >= m) break;
}
cnt[pos] -= (newcnt - CNT);
for (long long i = 10000000; i > 1; --i) {
if (pos >= i / 2) break;
if (cnt[i]) {
if (i / 2 > pos) {
for (pos; pos < i / 2; ++pos) {
if (cnt[pos] > cnt[i]) {
cnt[pos] -= cnt[i];
cnt[i / 2] += cnt[pos];
cnt[i / 2 + i % 2] += cnt[pos];
cnt[i] = 0;
break;
} else {
cnt[i] -= cnt[pos];
cnt[i / 2] += cnt[pos];
cnt[i / 2 + i % 2] += cnt[pos];
cnt[pos] = 0;
}
}
while (pos <= 10000000 && cnt[pos] == 0) ++pos;
}
}
}
cout << pos << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SZ = 10000005;
int n, k;
long long cnt[SZ];
long long sum = 0;
int main() {
scanf("%d%d", &n, &k);
long long tot = 0;
for (int i = 0; i < (int)(n); ++i) {
int x;
scanf("%d", &x);
++cnt[x];
tot += x;
}
if (tot < k) {
cout << -1 << endl;
return 0;
}
int bound = 1;
for (int i = SZ - 1; i > 0; --i) {
sum += cnt[i];
if (sum >= k) {
bound = i;
break;
}
}
for (int i = SZ - 1; i > 1; --i) {
if (i / 2 < bound) {
break;
}
cnt[i / 2] += cnt[i];
cnt[i - i / 2] += cnt[i];
sum += cnt[i];
cnt[i] = 0;
while (sum - cnt[bound] >= k) {
sum -= cnt[bound];
++bound;
}
}
cout << bound << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
const long long MOD = 1000000007LL;
int ni() {
int x;
cin >> x;
return x;
}
long long nl() {
long long x;
cin >> x;
return x;
}
double nd() {
double x;
cin >> x;
return x;
}
string next() {
string x;
cin >> x;
return x;
}
long long calc(long long total, long long req) {
long long ans = 0;
long long val[2];
long long cnt[2];
if (total % 2 == 0) {
val[0] = total;
val[1] = 0;
cnt[0] = 1;
cnt[1] = 0;
} else {
val[0] = 0;
val[1] = total;
cnt[0] = 0;
cnt[1] = 1;
}
while (val[0] >= req || val[1] >= req) {
long long x = 0;
if (val[0] >= req) x += cnt[0];
if (val[1] >= req) x += cnt[1];
ans = max(ans, x);
long long E = 0;
long long Ec = 0;
long long O = 0;
long long Oc = 0;
if (cnt[0] > 0) {
if (val[0] % 4 == 0) {
E = val[0] / 2;
Ec += 2 * cnt[0];
} else {
O = val[0] / 2;
Oc += 2 * cnt[0];
}
}
if (cnt[1] > 0) {
int a = val[1] / 2;
int b = val[1] - a;
if (a % 2 == 1) swap(a, b);
E = a;
O = b;
Ec += cnt[1];
Oc += cnt[1];
}
val[0] = E;
val[1] = O;
cnt[0] = Ec;
cnt[1] = Oc;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N = ni();
long long K = nl();
vector<long long> A(N);
for (int i = 0; i < (N); i++) A[i] = nl();
long long slices = accumulate((A).begin(), (A).end(), 0LL);
if (slices < K) {
cout << -1;
return 0;
}
long long lo = 1LL;
long long hi = 10000000LL;
while (lo < hi) {
long long m = (lo + hi + 1) / 2;
long long p = 0;
for (long long s : A) {
p += calc(s, m);
}
if (p >= K) {
lo = m;
} else {
hi = m - 1;
}
}
cout << lo;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int a[2000000], k, n;
int dp[10000001];
int f(int x, int y) {
if (x <= 1e6) return dp[x];
if (y > x) return 0;
if (2 * y > x) return 1;
if (x % 2 == 1)
return f(x / 2, y) + f(x / 2 + 1, y);
else
return 2 * f(x / 2, y);
}
bool ok(int x) {
for (int i = 0; i < x; i++) dp[i] = 0;
for (int i = x; i < 2 * x && i <= 1e6; i++) dp[i] = 1;
for (int i = 2 * x; i <= 1e6; i++)
if (i % 2 == 0)
dp[i] = dp[i / 2] + dp[i / 2];
else
dp[i] = dp[i / 2] + dp[i / 2 + 1];
int s = 0;
for (int i = 0; i < n; i++) {
s += f(a[i], x);
if (s >= k) return 1;
}
return 0;
}
int main() {
cin >> n >> k;
long long second = 0;
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
second += a[i];
}
if (k > second) {
cout << -1;
return 0;
}
long long l = 0, r = 1e7 + 1;
while (r - l > 3) {
int mid = (r + l) / 2;
if (ok(mid))
l = mid;
else
r = mid - 1;
}
for (int i = r; i >= l; i--)
if (ok(i)) {
cout << i;
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a[1000010];
long long asum;
int p2[25];
long long test(int v) {
long long tot = 0;
for (int i = 0; i < n; i++) {
if (a[i] < v) continue;
int f = max(0, (int)log2(a[i] / v));
while (p2[f] * v <= a[i]) f++;
int add = p2[f] / 2 + max(0, a[i] - (p2[f] * v - p2[f] / 2));
tot += add;
}
return tot;
}
int main() {
p2[0] = 1;
for (int i = 1; i < 25; i++) p2[i] = p2[i - 1] * 2;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
asum += a[i];
}
if (asum < k) {
puts("-1");
return 0;
}
int lo = 1, hi = 1e7 + 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (test(mid) >= k)
lo = mid + 1;
else
hi = mid;
}
printf("%d\n", lo - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000006];
int n;
long long k;
int max_a;
int has[10101010];
bool judge(int num) {
long long cnt = 0;
for (int i = 0; i <= max_a; i++) {
if ((i >> 1) >= num)
has[i] = has[i / 2] + has[i - i / 2];
else if (i >= num)
has[i] = 1;
else
has[i] = 0;
}
for (int i = 0; i < n; i++) {
cnt += has[a[i]];
if (cnt >= k) {
return true;
}
}
return false;
}
int main() {
while (scanf("%d%I64d ", &n, &k) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
long long sum = 0;
max_a = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
if (a[i] > max_a) {
max_a = a[i];
}
}
if (sum < k) {
printf("-1\n");
} else {
int l = 1, r = max_a + 1;
while (l < r - 1) {
int m = (l + r) / 2;
if (judge(m)) {
l = m;
} else {
r = m;
}
}
cout << l << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long inf = (long long)(1e14);
vector<long long> a;
long long dp[10000005];
long long solve(int ele, int n) {
if (ele < n) return 0;
if (dp[ele] != -1) return dp[ele];
long long ans = 1;
ans = max(ans, solve(ele / 2, n) + solve((ele + 1) / 2, n));
return dp[ele] = ans;
}
bool check(long long n, long long k) {
long long ans = 0;
memset(dp, -1, sizeof dp);
for (auto ele : a) {
if (ele < n) break;
ans += solve((int)ele, (int)n);
if (ans >= k) return true;
}
return false;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
long long s = 0;
for (int i = 0; i < n; i++) {
int cur;
scanf("%d", &cur);
a.push_back(cur);
s += cur;
}
sort(a.rbegin(), a.rend());
if (s < k) {
puts("-1");
} else {
long long start = 1, end = inf;
while (end - start > 1) {
long long mid = (start + end) / 2;
if (check(mid, (long long)k)) {
start = mid;
} else {
end = mid;
}
}
cout << start;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
vector<long long> p;
for (int i = 0; i < 25; i++) {
p.push_back(1 << i);
}
long long ans = -1, lo = 1, hi = 1e7, mid;
while (lo <= hi) {
mid = (lo + hi) / 2;
vector<long long> vii;
vii.push_back(mid);
vii.push_back(mid);
vii.push_back(mid * 2);
vii.push_back(mid * 2);
int i = 2;
while (1) {
int t1 = mid * (1 << i);
int t2 = (1 << (i - 1)) - 1;
vii.push_back(t1 - t2);
vii.push_back(t1);
if (t1 > 10000000) break;
i++;
}
long long cnt = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < mid) continue;
auto it = upper_bound(vii.begin(), vii.end(), arr[i]) - vii.begin();
it--;
if (it % 2)
cnt += p[it / 2];
else {
cnt += p[it / 2] / 2 + 1 + arr[i] - vii[it];
}
}
if (cnt >= k) {
ans = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[1000005], bo[10000005], sum, ans;
set<long long> s;
int main() {
scanf("%lld%lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
++bo[a[i]];
s.insert(a[i]);
sum += a[i];
}
if (sum < k) {
puts("-1");
return 0;
}
if (n >= k) {
while (n > k) {
++k;
--bo[*(s.begin())];
if (!bo[*(s.begin())]) s.erase(s.begin());
}
ans = *(s.begin());
}
do {
long long j = *(--s.end());
if (j <= ans * 2) break;
if (!bo[j >> 1]) s.insert(j >> 1);
if (!bo[(j + 1) >> 1]) s.insert((j + 1) >> 1);
bo[(j + 1) >> 1] += bo[j];
bo[j >> 1] += bo[j];
s.erase(j);
n += bo[j];
if (n >= k) {
long long m = n;
set<long long>::iterator it = s.begin();
while (m - bo[*(it)] >= k) m -= bo[*(it)], ++it;
if (*(it) > ans) ans = *(it);
}
} while (*(s.begin()) != 1 || s.size() != 1);
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
cerr << "Completed in " << 1.0 * clock() / CLOCKS_PER_SEC << " seconds\n";
}
const long long N = 1e7 + 5;
const long double EPS = 1e-6;
long long n, k, x, f[N], tot, mn = INT_MAX;
void solve() {
cin >> n >> k;
for (long long i = 1; i <= n; i++) {
cin >> x;
f[x]++;
tot += x;
mn = min(mn, x);
}
if (tot < k) {
cout << -1;
return;
}
while (n > k) {
long long rmv = min(f[mn], n - k);
f[mn] -= rmv;
n -= rmv;
if (f[mn] == 0) mn++;
}
while (f[mn] == 0) mn++;
long long ans = (n == k) * mn;
for (long long i = 1e7; i > 1; i--) {
if (!f[i]) continue;
f[i >> 1] += f[i];
f[i - (i >> 1)] += f[i];
mn = min(mn, min(i >> 1, i - (i >> 1)));
n += f[i];
f[i] = 0;
while (n > k) {
long long rmv = min(f[mn], n - k);
f[mn] -= rmv;
n -= rmv;
if (f[mn] == 0) mn++;
}
while (f[mn] == 0) mn++;
ans = max((n == k) * mn, ans);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int M = 1e7 + 5;
int a[N];
int n, k;
int aMax;
long long dp[M];
bool check(int mid) {
memset(dp, 0, sizeof(dp));
for (int i = mid; i <= aMax; ++i) {
long long tmp = dp[i >> 1] + dp[(i >> 1) + (i & 1)];
dp[i] = (tmp > 1) ? tmp : 1;
}
long long cnt = 0;
for (int i = 0; i < n; ++i) {
cnt += dp[a[i]];
}
return cnt >= k;
}
void solve() {
cin >> n >> k;
long long total = 0;
aMax = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
total += a[i];
aMax = (aMax > a[i]) ? aMax : a[i];
}
if (total < k) {
cout << "-1" << endl;
return;
}
int l = 1, r = M;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
l = mid + 1;
else
r = mid - 1;
}
cout << l - 1 << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int a[maxn], n, k, d[10 * maxn];
int dp(int x, int u) {
if (x < u) return 0;
if (d[x] != 0) return d[x];
if (x / 2 < u) return d[x] = 1;
if (x & 1) {
d[x] = dp(x / 2, u);
return d[x] += dp(x / 2 + 1, u);
}
return d[x] = 2 * dp(x / 2, u);
}
bool check(int u) {
long long s = 0;
for (int i = n - 1; i >= 0; i--) {
int tem = dp(a[i], u);
if (tem)
s += tem;
else
break;
}
if (s >= k) return true;
return false;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
int ans = -1;
int l = 0, r = 1e7 + 1, mid;
while (l + 1 < r) {
mid = l + (r - l) / 2;
memset(d, 0, sizeof(d));
if (check(mid)) {
ans = max(ans, mid);
l = mid;
} else
r = mid;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, tans = 0, ans = -1, maxv = 0, tcnt = 0, cnt[10000010];
long long sum = 0;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
cnt[a]++;
maxv = max(maxv, a);
sum += a;
}
if (sum < k) return printf("-1\n"), 0;
for (tans = maxv + 1; tcnt < k && tans >= 2; tans--, tcnt += cnt[tans])
;
while (maxv / 2 > tans) {
cnt[maxv >> 1] += cnt[maxv];
cnt[(maxv >> 1) + (maxv & 1)] += cnt[maxv];
tcnt += cnt[maxv];
for (; tcnt >= k; tcnt -= cnt[tans], tans++)
;
tans > 1 ? tans--, tcnt += cnt[tans] : 0;
cnt[maxv] = 0;
while (!cnt[maxv]) maxv--;
}
return printf("%d\n", tans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int arr[10000050];
int prev(int cur) {
while (cur > 0 && arr[cur] == 0) {
cur--;
}
return cur;
}
int next(int cur, int skip) {
int start;
for (int i = cur; i < 10000050; i++) {
if (arr[i] > 0) {
if (arr[i] <= skip) {
skip -= arr[i];
start = i;
} else {
arr[i] -= skip;
start = i;
break;
}
}
}
return start;
}
int main() {
int n;
long long k;
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
arr[x]++;
}
int end;
long long int ctr = 0;
long long int possible = 0;
for (int i = 0; i < 10000050; i++) {
if (arr[i] > 0) {
end = i;
ctr += arr[i];
possible += arr[i] * 1LL * i;
}
}
int skip = ctr - k;
if (possible < k) {
cout << "-1\n";
} else {
while (skip < 0) {
int a = end / 2;
int b = a;
if (end % 2 != 0) a++;
int cnt = arr[end];
arr[a] += cnt;
arr[b] += cnt;
arr[end] = 0;
end = prev(end);
skip += cnt;
}
int start = next(0, skip);
while (1) {
if (end / 2 <= start) {
break;
}
int a = end / 2;
int b = a;
if (end % 2 != 0) a++;
int cnt = arr[end];
arr[a] += cnt;
arr[b] += cnt;
arr[end] = 0;
end = prev(end);
start = next(start, cnt);
}
cout << start << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[1000004];
long long int calc(long long int base, long long int val) {
if (base > val) return 0;
long long int temp = 1;
while (base * temp <= val) temp = temp * ((long long int)2);
temp = temp / 2;
if (temp * base <= val && temp * (2 * base - 1) >= val)
return temp;
else {
temp = temp + (val)-temp * (2 * base - 1);
return temp;
}
}
int main() {
long long int n, k, su = 0;
ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
su = su + a[i];
}
if (su < k)
cout << -1 << endl;
else {
long long int l = 1, r = 100000000, ans = 1;
while (l <= r) {
long long int mi = (l + r) / 2;
su = 0;
for (int i = 0; i < n; i++) su = su + calc(mi, a[i]);
if (su >= k) {
ans = mi;
l = mi + 1;
} else
r = mi - 1;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[1000010], ans, maxl, l, r, mid;
long long c[10000010];
bool check(long long x) {
long long tot = 0;
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; i++) c[a[i]]++;
for (long long i = maxl; i >= x; i--) {
if (i / 2 >= x) {
if (i % 2)
c[i / 2] += c[i], c[i / 2 + 1] += c[i];
else
c[i / 2] += c[i] * 2;
} else {
tot += c[i];
}
}
if (tot >= m)
return true;
else
return false;
}
int main(void) {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
r = max(r, a[i]);
}
l = 1, maxl = r;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
if (ans == 0) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int A = 1e7 + 233;
long long f[A];
int main() {
int n, k;
cin >> n >> k;
long long sum = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
f[x]++;
sum += x;
}
if (sum < k) {
cout << -1 << endl;
return 0;
}
int ans = 1e7, i = 1e7;
long long cnt = 0;
for (; ans; ans--) {
cnt += f[ans];
while ((i >> 1) >= ans) {
cnt += f[i];
f[i >> 1] += f[i];
f[i - (i >> 1)] += f[i];
i--;
}
if (cnt >= k) break;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, inp, i, sl[10000001], ct[10000001];
long long pu, M;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M;
for (i = 0; i < N; i++) {
cin >> inp;
sl[inp]++;
}
for (i = 10000000; i > 0; i--) {
pu += sl[i];
sl[i / 2] += sl[i] + ct[i];
ct[i - i / 2] += sl[i] + ct[i];
if (pu >= M) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
const int maxa = 1e7 + 100;
const long long inf = 2e18;
long long n, k;
vector<long long> a(maxn);
bool check(long long m) {
long long cnt = 0;
vector<long long> add(maxa, 0LL);
if (m >= maxa) {
return false;
}
add[m] = 1;
for (int i = m + 1; i < maxa - 50; ++i)
add[i] = max(1LL, add[i / 2] + add[(i + 1) / 2]);
for (int i = 0; i < n; ++i) {
long long cur = a[i];
cnt += add[cur];
if (cnt >= k) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
long long sum = 0;
long long r = -inf;
for (int i = 0; i < n; ++i) {
cin >> a[i];
r = max(r, a[i]);
sum += a[i];
}
if (sum < k) {
cout << "-1";
return 0;
}
long long l = 0;
r++;
while (l + 1 < r) {
long long m = (l + r) / 2;
if (check(m))
l = m;
else
r = m;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long d[10000005];
long long ara[10000005 / 10];
void precalc() {
for (int i = 0; i <= 24; i++) {
for (int j = (1 << i); j <= min((1 << (i + 1)) - 1, 10000000); j++)
d[j] = i;
}
}
bool okay(long long mid) {
if (mid == 1) return 1;
long long temp = 0;
for (int i = 0; i < n; i++) {
if (ara[i] < mid) continue;
long long vag = ara[i] / mid;
if ((1 << d[vag]) == vag)
temp += vag;
else {
temp += max((1LL << d[vag]), ara[i] - (mid - 1) * (1LL << (d[vag] + 1)));
}
}
return (temp >= k);
}
int main() {
precalc();
scanf("%d %d", &n, &k);
long long sum = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &ara[i]);
sum += ara[i];
}
if (sum < k) {
printf("-1\n");
return 0;
}
int lo = 1, hi = 10000000;
while (lo < hi) {
int mid = (lo + hi + 1) / 2;
if (okay(mid))
lo = mid;
else
hi = mid - 1;
}
printf("%d\n", lo);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const double eps = 1e-4;
const int maxn = 1e6 + 500;
const int base = 1073741789;
const long long basell = 1e18 + 3;
string itosm(long long x) {
string ans = "";
while (x > 0) {
ans += ((x % 10) + '0');
x /= 10;
}
reverse(ans.begin(), ans.end());
return ans;
}
long long stoim(string str) {
long long ans = 0;
long long k = 1;
for (int i = str.length() - 1; i >= 0; i--) {
ans += (str[i] - '0') * k;
k *= 10;
}
return ans;
}
int a[maxn];
int n, k;
int dp[10000005];
bool check(int x) {
long long cnt = 0;
for (int i = 0; i < x; i++) dp[i] = 0;
for (int i = x; i < 2 * x && i < 10000005; i++) dp[i] = 1;
for (int i = x * 2; i < 10000005; i++) dp[i] = dp[i / 2] + dp[(i + 1) / 2];
for (int i = 0; i < n; i++) {
cnt += dp[a[i]];
}
if (cnt >= k) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
;
cin >> n >> k;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum < k) {
cout << -1;
return 0;
}
int l = 0, r = 1000 * 1000 * 10, m;
while (l < r) {
m = (l + r) / 2;
if (check(m)) {
l = m;
if (l == r - 1) {
if (check(r))
l = r;
else
r = l;
}
} else
r = m - 1;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long x, y, z, arr[100 * 100005], rearr[100 * 100005];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> x >> y;
for (int i = 0; i < x; i++) {
cin >> z;
arr[z]++;
}
z = 0;
for (int i = 1e7; i >= 1; i--) {
z += arr[i];
arr[i / 2] += arr[i] + rearr[i];
rearr[i / 2 + i % 2] += arr[i] + rearr[i];
if (z >= y) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000006];
int n, k;
int max_a;
int has[20000007];
bool judge(int num) {
if (num == 1) return true;
int cnt = 0;
for (int i = 0; i < num * 2; i++) {
has[i] = i / num;
}
for (int i = num * 2; i <= max_a; i++) {
has[i] = has[i / 2] + has[i - i / 2];
}
for (int i = 0; i < n; i++) {
cnt += has[a[i]];
if (cnt >= k) {
return true;
}
}
return false;
}
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
long long sum = 0;
max_a = 0;
for (int i = 0; i < n; i++) {
sum += a[i];
if (a[i] > max_a) {
max_a = a[i];
}
}
if (sum < k) {
printf("-1\n");
} else {
int l = 1, r = max_a + 1;
while (l < r - 1) {
int m = (l + r) / 2;
if (judge(m)) {
l = m;
} else {
r = m;
}
}
while (judge(l)) {
l++;
}
cout << l - 1 << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int tange[1000000];
int n, k;
int dp[10000001];
int a;
int get(int b) {
int &r = dp[b];
if (r != -1) return r;
if (b < a) return r = 0;
r = 1;
if ((b >> 1) + (b & 1) < a) return r;
r = get((b >> 1)) + get((b >> 1) + (b & 1));
return r;
}
bool check() {
memset(dp, -1, sizeof dp);
int nbr = 0;
for (int i = n - 1; i >= 0; i--) {
nbr += get(tange[i]);
if (nbr >= k) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", tange + i);
int l = 1, r = 10000000;
int ans = -1;
sort(tange, tange + n);
while (l <= r) {
int m = (l + r) >> 1;
a = m;
if (check())
ans = m, l = m + 1;
else
r = m - 1;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int prevcnt[10000005], cnt[10000005];
int main() {
int n, k, i;
long long int s = 0;
cin >> n >> k;
int A[1000005];
for (i = 0; i < n; i++) {
cin >> A[i];
s += A[i];
cnt[A[i]]++;
}
int b, e, mid;
b = 1;
e = 10000000;
for (i = e; i >= 1; i--) {
mid += cnt[i] - prevcnt[i];
if (mid >= k) {
b = i;
break;
}
prevcnt[(i + 1) / 2] += cnt[i];
cnt[(i + 1) / 2] += cnt[i];
cnt[(i) / 2] += cnt[i];
}
if (s >= k)
cout << b;
else
cout << "-1";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int INF = 1e9 + 10;
int a[maxn];
int n, k, kase;
int vis[maxn * 5], dp[maxn * 5];
int dfs(int num, int v) {
if (num < v) return 0;
if ((v << 1) > num) return 1;
if (num < maxn) {
if (vis[num] == kase) return dp[num];
vis[num] = kase;
}
int sum = 0;
if (num & 1) {
sum += dfs(num / 2, v) + dfs(num / 2 + 1, v);
} else
sum += 2 * dfs(num / 2, v);
if (num < maxn) dp[num] = sum;
return sum;
}
bool judge(int mid) {
long long sum = 0;
for (int i = 0; i < n; i++) {
long long sum1 = dfs(a[i], mid);
sum += sum1;
if (sum >= k) return true;
}
return false;
}
int main() {
while (scanf("%d%d", &n, &k) == 2) {
int Max = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n, greater<int>());
int L = 1, R = a[0], ans = -1;
while (L <= R) {
++kase;
int mid = (L + R) >> 1;
if (judge(mid)) {
ans = mid;
L = mid + 1;
} else
R = mid - 1;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int v[1000000];
for (int i = 0; i < n; i++) cin >> v[i];
int l = 1, r = 10000000;
int best = -1;
while (l <= r) {
long long tot = 0;
int m = l + (r - l) / 2;
for (int i = 0; i < n; i++) {
int x = 1, j;
for (j = m; j <= v[i]; j *= 2) {
x *= 2;
}
tot += max(x / 2, x - (j - v[i]));
}
if (tot >= k) {
l = m + 1;
best = m;
} else
r = m - 1;
}
cout << best;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1e6;
using namespace std;
int num[maxn + 10];
int n, k;
bool cmp(int x, int y) { return x > y; }
int q[10 * maxn + 100];
int MAX;
bool check(int m) {
for (int i = 0; i < m; i++) q[i] = 0;
q[m] = 1;
for (int i = m; i <= MAX; i++)
q[i] = max(1, q[i >> 1] + q[(i >> 1) + (i & 1)]);
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += q[num[i]];
if (sum >= k) break;
}
if (sum >= k)
return 1;
else
return 0;
}
int binarysearch(int L, int R) {
int ret = R;
while (L <= R) {
int mid = (R - L) / 2 + L;
if (check(mid)) {
L = mid + 1;
ret = mid;
} else
R = mid - 1;
}
return ret;
}
int main() {
MAX = 0;
scanf("%d%d", &n, &k);
long long ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
ans += num[i];
MAX = max(MAX, num[i]);
}
sort(num, num + n, cmp);
if (ans < k)
printf("-1\n");
else {
ans = binarysearch(1, MAX);
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char i = getchar();
long long f = 1, res = 0;
while (i < '0' || i > '9') {
if (i == '-') f = -1;
i = getchar();
}
while (i >= '0' && i <= '9') {
res = res * 10 + i - '0';
i = getchar();
}
return res * f;
}
const int N = 1e6 + 50;
int n, a[N], vis[N * 10];
long long k;
inline int dfs(int res, int mid) {
if (vis[res] != -1) return vis[res];
if (res == 1) {
vis[res] = 1;
return 1;
}
int ji = (res >> 1) + 1, ou = res >> 1;
if (res >= (mid << 1)) {
if (res & 1) {
return vis[res] = ((vis[ji] = dfs(ji, mid)) + (vis[ou] = dfs(ou, mid)));
} else {
return vis[res] = ((vis[ou] = dfs(ou, mid)) << 1);
}
} else if (res >= mid) {
vis[res] = 1;
return 1;
} else
return vis[res] = 0;
}
inline bool pd(long long mid) {
memset(vis, -1, sizeof(vis));
long long sum = 0;
for (register int i = 1; i <= n; ++i) {
if (a[i] >= mid) {
sum += dfs(a[i], int(mid));
} else
return 0;
if (sum >= k) return 1;
}
return 0;
}
int main() {
n = read();
k = read();
long long sum = 0;
for (register int i = 1; i <= n; ++i) {
a[i] = read();
sum += a[i];
}
if (sum < k) {
puts("-1");
return 0;
}
sort(a + 1, a + 1 + n, greater<int>());
long long l = 1, r = 1e7, mid, ans = -1;
while (l <= r) {
mid = (l + r) >> 1;
if (pd(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, x, y, sum, ans, a[10000005], cnt[10000005];
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
a[x]++;
cnt[x]++;
}
for (int i = 10000000; i > 0; i--) {
ans += cnt[i];
if (ans >= k) {
printf("%d\n", i);
return 0;
}
cnt[i / 2] += a[i];
a[i / 2] += a[i];
a[(i + 1) / 2] += a[i];
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
const long long MAXN = 1e6 + 10;
using namespace std;
long long n, k, a[MAXN], vis[MAXN * 10];
inline long long R() {
char c;
long long res, sign = 1;
while ((c = getchar()) > '9' || c < '0')
if (c == '-') sign = -1;
res = c - '0';
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
return res * sign;
}
long long dfs(long long x, long long t) {
if (vis[x] != -1) return vis[x];
if (x == 1) return vis[x] = 1;
if (x >= 2 * t) {
if (x & 1)
return vis[x] = ((vis[x / 2 + 1] = dfs(x / 2 + 1, t)) +
(vis[x / 2] = dfs(x / 2, t)));
else
return vis[x] = (vis[x / 2] = dfs(x / 2, t)) * 2;
} else if (x >= t)
return vis[x] = 1;
}
bool judge(long long x) {
memset(vis, -1, sizeof vis);
long long cnt = 0;
for (long long i = 0; i < n; ++i) {
if (a[i] >= x)
cnt += dfs(a[i], x);
else
return 0;
if (cnt >= k) return 1;
}
return 0;
}
long long solve() {
long long l = 1, r = 1e7;
while (l <= r)
if (judge((l + r >> 1)))
l = (l + r >> 1) + 1;
else
r = (l + r >> 1) - 1;
return l - 1;
}
signed main() {
n = R();
k = R();
long long sum = 0;
for (long long i = 0; i < n; ++i) sum += (a[i] = R());
if (sum < k) return 0 * puts("-1");
sort(a, a + n, greater<long long>());
printf("%lld\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long lim = 1e7;
long long a[2 * lim + 2];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
while (n--) {
long long t;
cin >> t;
a[t]++;
}
for (long long i = lim; i >= 1; i--) {
if (i == 1)
k -= a[1] + a[2] + 2ll * a[3];
else
k -= a[i] + a[2 * i] + a[2 * i + 1];
a[i + 1] += a[2 * i + 1];
a[i] += 2ll * a[2 * i] + a[2 * i + 1];
if (k <= 0) cout << i, exit(0);
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream in;
ofstream out;
const long long lINF = 9223372036854775807;
const int INF = 2147483647;
int main() {
int n, k;
scanf("%d %d", &n, &k);
long long* m = new long long[10000002];
memset(m, 0, 10000002 * 8);
long long maxc = 0, minc = 0;
for (long long i = 0; i < n; i++) {
int x;
scanf("%d", &x);
m[x]++;
if (x > maxc) maxc = x;
}
long long all = n;
while (all < k) {
if (maxc <= 1) {
cout << -1;
return 0;
}
m[maxc / 2] += m[maxc];
m[(maxc - 1) / 2 + 1] += m[maxc];
all += m[maxc];
maxc--;
}
while (true) {
while (all - m[minc] >= k) {
all -= m[minc];
minc++;
}
if (minc >= (maxc + 1) / 2) break;
m[maxc / 2] += m[maxc];
m[(maxc - 1) / 2 + 1] += m[maxc];
if (maxc / 2 >= minc) all += m[maxc];
maxc--;
}
cout << minc;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2000000];
long long b[10000002], c[10000002];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
long long int coun = 0, lol = 0, mlol = 0;
for (int i = 1; i <= n; i++) b[a[i]] += 1;
for (int i = 10000000; i >= 1; i--) {
lol += b[i];
lol -= c[i];
b[i - i / 2] += b[i];
b[i / 2] += b[i];
c[i - i / 2] += b[i];
if (lol >= k) {
printf("%d\n", i);
return 0;
}
}
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, arr[1000005], sums, mx, dp[10000005];
bool memenuhi(long long mn) {
for (int i = mn; i <= mx; ++i) {
int tengah = i / 2;
if (tengah >= mn) {
dp[i] = dp[tengah] + dp[i - tengah];
} else {
dp[i] = 1;
}
}
long long sums = 0;
for (int i = 1; i <= n; ++i) {
if (arr[i] >= mn) {
sums += dp[arr[i]];
}
}
return (sums >= k);
}
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 >> arr[i];
mx = max(mx, arr[i]);
sums += arr[i];
}
if (sums < k) {
cout << -1 << '\n';
return 0;
}
long long l = 1, r = 1e7, pos = -1;
while (l <= r) {
long long mid = (l + r) / 2;
if (memenuhi(mid)) {
pos = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << pos << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long cnt[1 << 24];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int L = 0, R = (int)(1E7);
long long items = n;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
cnt[x] += 1;
}
int ans = -1;
while (L <= R) {
while (items >= k) {
if (items - cnt[L] >= k) {
items -= cnt[L];
L++;
} else
break;
}
if (items >= k) ans = max(ans, L);
int a1 = R / 2;
int a2 = R - a1;
if (a1 >= L) items += cnt[R];
if (a2 >= L) items += cnt[R];
cnt[a1] += cnt[R];
cnt[a2] += cnt[R];
items -= cnt[R];
R--;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 5;
long long dp[N], org[N];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int x;
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
++org[x];
}
for (int i = N - 1; i >= 1; --i) {
dp[i] += org[i] + dp[i + 1];
if (dp[i] >= k) {
printf("%d\n", i);
return 0;
}
int u = i / 2, v = i - u;
org[u] += org[i];
org[v] += org[i];
dp[v] -= org[i];
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long int LOG[31];
long long int a[1000009];
long long int k;
int get(long long int x, long long int y) {
int l = 0, r = 29, res = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (y * LOG[mid] <= x) {
res = LOG[mid];
l = mid + 1;
} else
r = mid - 1;
}
int t = x / (res * 2);
if (t + 1 >= y) res = max(1LL * res, x - t * (res * 2));
return res;
}
long long int solve(long long int x) {
long long int cnt = 0;
for (int i = n; i >= 1; i--) {
if (a[i] < x) break;
int t = get(a[i], x);
cnt += t;
if (cnt >= k) return cnt;
}
return cnt;
}
int main() {
scanf("%d %lld", &n, &k);
for (int i = 0; i < 30; i++) LOG[i] = 1 << i;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
int ctr = 0;
long long int low = 0;
long long int high = a[n] + 1;
long long int mid;
while (ctr < 30) {
mid = (low + high) / 2;
long long int x = solve(mid);
if (x < k)
high = mid - 1;
else
low = mid + 1;
ctr++;
}
if (mid == 0) mid = -1;
printf("%lld\n", mid);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e9;
const long double eps = 0.000001;
const long long mod = 1e9 + 7;
const long double PI = 3.14159265359;
template <class T>
struct MyVector : vector<T> {
MyVector() : vector<T>() {}
MyVector(long long n) : vector<T>(n) {}
T &operator[](size_t i) { return vector<T>::at(i); }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n, k;
cin >> n >> k;
vector<long long> a(1e7 + 10, 0);
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
a[x]++;
}
long long q = 0, idx = 1e7 + 9;
while (q < k && idx >= 0) {
q += a[idx];
idx--;
}
idx++;
for (long long i = 1e7 + 9; i > 64; i--) {
if (a[i] <= 0) continue;
long long r = i / 2 + (i % 2);
long long l = i / 2;
if (l < idx && r < idx) {
break;
}
if (l >= idx) a[l] += a[i];
if (r >= idx) a[r] += a[i];
if (l >= idx && r >= idx) q += a[i];
a[i] = 0;
q -= a[idx];
while (q >= k && idx < 1e7 + 9) {
idx++;
q -= a[idx];
}
q += a[idx];
}
for (long long i = 64; i > 1; i--) {
if (a[i] <= 0) continue;
long long r = i / 2 + (i % 2);
long long l = i / 2;
if (l < idx && r < idx) {
break;
}
if (l >= idx) a[l] += a[i];
if (r >= idx) a[r] += a[i];
if (l >= idx && r >= idx) q += a[i];
a[i] = 0;
q -= a[idx];
while (q >= k && idx < 1e7 + 9) {
idx++;
q -= a[idx];
}
q += a[idx];
}
if (idx == 0 || q < k) {
cout << -1;
} else {
cout << idx;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long num[1000010];
int cnt[10 * 1000010];
int main() {
cin.sync_with_stdio(false);
int n, ans;
long long m, sum, mmax;
while (cin >> n >> m) {
sum = 0;
mmax = 0;
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n; i++) {
cin >> num[i];
sum += num[i];
cnt[num[i]]++;
mmax = max(mmax, num[i]);
}
if (sum < m) {
cout << -1 << endl;
} else {
ans = 0;
int flag = 1;
for (int i = mmax; i > 0; i--) {
ans += cnt[i];
if (i * 2 <= mmax) {
ans -= cnt[i << 1];
}
if (i * 2 - 1 <= mmax && i != 1) {
ans -= cnt[(i << 1) - 1];
}
if (ans >= m) {
cout << i << endl;
flag = 0;
break;
}
cnt[i >> 1] += cnt[i];
cnt[(i + 1) >> 1] += cnt[i];
}
if (flag) {
cout << 1 << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
using ll = long long;
const ll mod = 1e9 + 7;
const int maxn = 1e6 + 5;
const int N = 1e7 + 10;
ll n, k;
ll mx;
ll a[maxn];
ll dp[N];
bool test(ll x) {
for (int i = 0; i <= x; i++) {
dp[i] = 0;
}
for (int i = x; i <= mx; i++) {
dp[i] = max(1ll, dp[i / 2] + dp[(i + 1) / 2]);
}
ll need = k;
for (int i = 0; i < n; i++) {
int x = a[i];
need -= dp[x];
if (need <= 0) return true;
}
return need <= 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
ll sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
mx = max(mx, 1ll * a[i]);
}
if (k > sum) out(-1);
ll lo = 1;
ll hi = mx + 1;
while (hi - lo > 1) {
ll mid = (lo + hi) / 2;
if (test(mid)) {
lo = mid;
} else {
hi = mid;
}
}
cout << lo << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000005], n, k, dp[10000005], mas;
bool check(long long t) {
long long ans = 0, i;
for (i = t; i <= mas; i++) dp[i] = 0;
for (i = 1; i <= n; i++) dp[a[i]]++;
for (i = mas; i >= t; i--) {
if (i / 2 >= t) {
if (i % 2) {
dp[i / 2] += dp[i];
dp[i / 2 + 1] += dp[i];
} else
dp[i / 2] += 2 * dp[i];
} else {
ans += dp[i];
}
}
return ans >= k;
}
int main() {
long long i;
scanf("%lld%lld", &n, &k);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]), mas = max(mas, a[i]);
long long l = 1, r = mas;
sort(a + 1, a + 1 + n);
while (l + 1 < r) {
long long mid = l + r >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
if (check(r))
printf("%lld\n", r);
else if (check(l))
printf("%lld\n", l);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
int a[10000005], dp[10000005];
bool ck(int mid) {
if (mid == 0) return 1;
long long cnt = 0;
for (int(i) = 0; (i) < (int)(10000005); (i)++) {
if (i < mid)
dp[i] = 0;
else if (i < mid + mid)
dp[i] = 1;
else {
int z = i >> 1;
dp[i] = dp[z] + dp[i - z];
}
}
for (int(i) = 1; (i) <= (int)(n); (i)++) {
cnt += dp[a[i]];
if (cnt >= k) return 1;
}
return cnt >= k;
}
void fmain() {
scanf("%d%d", &n, &k);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", a + i);
int l = 0, r = 1e7;
while (l + 1 < r) {
int mid = (l + r) / 2;
if (ck(mid))
l = mid;
else
r = mid - 1;
}
int ans = ck(r) ? r : l;
if (l == 0) et();
printf("%d\n", ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain();
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 1000010, M = 10000010;
int n, m, a[N], dp[M];
void getData() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
}
bool check(int x) {
for (int i = 0; i < M; ++i) {
if (i < x)
dp[i] = 0;
else if (x <= i && i < x + x)
dp[i] = 1;
else
dp[i] = dp[i / 2] + dp[i - i / 2];
}
int sum = 0;
for (int i = 0; i < n; ++i) {
sum += dp[a[i]];
if (sum >= m) return true;
}
return false;
}
void solve() {
int lo, hi, mid, ans = -1;
lo = 1;
hi = a[0];
for (int i = 0; i < n; ++i) hi = std::max(hi, a[i]);
while (lo <= hi) {
mid = (lo + hi) >> 1;
if (check(mid)) {
lo = mid + 1;
ans = std::max(ans, mid);
} else
hi = mid - 1;
}
printf("%d\n", ans);
}
int main() {
getData();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k;
cin >> n >> k;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
vector<long long> p;
for (int i = 0; i < 25; i++) {
p.push_back(1 << i);
}
long long ans = -1, lo = 1, hi = 1e7, mid;
while (lo <= hi) {
mid = (lo + hi) / 2;
vector<long long> vii;
vii.push_back(mid);
vii.push_back(mid);
vii.push_back(mid * 2);
vii.push_back(mid * 2);
int i = 2;
while (1) {
int t1 = mid * (1 << i);
int t2 = (1 << (i - 1)) - 1;
vii.push_back(t1 - t2);
vii.push_back(t1);
if (t1 > 10000000) break;
i++;
}
long long cnt = 0;
for (int i = 0; i < n; i++) {
if (arr[i] < mid) continue;
auto it = upper_bound(vii.begin(), vii.end(), arr[i]) - vii.begin();
it--;
if (it % 2)
cnt += p[it / 2];
else {
cnt += p[it / 2] / 2 + 1 + arr[i] - vii[it];
}
}
if (cnt >= k) {
ans = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
inline void read(long long &x) {
x = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 3) + (x << 1) + (c - '0');
}
inline void write(long long x) {
register char buffor[35];
register long long i = 0;
do {
buffor[i++] = (x % 10) + '0';
x /= 10;
} while (x);
i--;
while (i >= 0) putchar(buffor[i--]);
putchar('\n');
}
inline long long in() {
long long x;
read(x);
return x;
}
void solve();
long long dbg = 1;
using namespace std;
int main() {
long long t = 1;
for (long long i = 0; i < t; i++) {
solve();
}
return 0;
}
long long a[1000005];
void solve() {
long long ans, n, k, l, r, sum = 0, maxr = 0;
read(n), read(k);
for (long long i = 0; i < n; i++) {
read(a[i]);
sum += a[i];
maxr = max(maxr, a[i]);
}
if (sum < k) {
cout << -1 << endl;
return;
}
l = 1;
r = maxr;
while (l < r) {
ans = 0;
long long mi = (l + r) / 2 + 1;
for (long long i = 0; i < n; i++) {
long long q = a[i], br = 1;
if (q < mi) continue;
while (q >= mi) {
q /= 2;
br *= 2;
}
long long v = br / 2;
if (q == mi - 1) v = max(v, a[i] % br);
ans += v;
if (ans >= k) break;
}
if (ans < k)
r = mi - 1;
else
l = mi;
}
cout << l << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int maxn = 1e6 + 5;
const int MAXN = 1e7 + 5;
long long a[maxn];
long long b[MAXN];
long long betta;
long long me;
bool cnt(long long mid) {
for (int i = 0; i < mid; i++) {
b[i] = 0;
}
b[mid] = 1;
for (int i = mid; i <= me; i++) {
b[i] = max((long long)1, b[i / 2] + b[i / 2 + i % 2]);
}
long long cur = 0;
for (int i = 0; i < n; i++) {
cur += b[a[i]];
if (cur >= k) {
return true;
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
betta += a[i];
me = max(me, a[i]);
}
if (betta < k) {
cout << -1;
return 0;
}
long long mid = 1;
long long r = me;
long long l = 1;
while (r - l > 1) {
mid = (l + r) / 2;
if (cnt(mid) == 1) {
l = mid;
} else {
r = mid;
}
}
if (cnt(r) == 1) {
cout << r;
return 0;
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long N = 1e7 + 1;
const long long mod = 1e9 + 7;
const long double eps = 1E-7;
long long n, k, x;
long long now, a[N], b[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k;
while (n--) cin >> x, a[x]++;
for (int i = N - 1; i >= 1; i--) {
now += a[i] + b[i];
if (now >= k) {
cout << i;
return 0;
}
a[i / 2] += a[i];
a[(i + 1) / 2] += a[i];
b[(i + 1) / 2] -= a[i];
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int M = 1e7 + 5;
int a[N];
int n, k;
int aMax;
long long dp[M];
bool check(int mid) {
memset(dp, 0, sizeof(dp));
for (int i = mid; i <= aMax; ++i) {
long long tmp = dp[i >> 1] + dp[(i >> 1) + (i & 1)];
dp[i] = (tmp > 1) ? tmp : 1;
}
long long cnt = 0;
for (int i = 0; i < n; ++i) {
cnt += dp[a[i]];
}
return cnt >= k;
}
void solve() {
cin >> n >> k;
long long total = 0;
aMax = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
total += a[i];
aMax = (aMax > a[i]) ? aMax : a[i];
}
if (total < k) {
cout << "-1" << endl;
return;
}
int l = 1, r = M;
int ans = 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
ans = mid, l = mid + 1;
else
r = mid - 1;
}
cout << ans << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e6 + 42, inf = 1e7 + 42;
int n, k, a[nmax];
unsigned dp[inf];
bool can(int most) {
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) dp[a[i]]++;
unsigned sum = 0;
for (int i = inf - 1; i >= most; i--) {
if (i % 2 == 0) {
if (i / 2 >= most) {
dp[i / 2] = dp[i / 2] + dp[i] * 2;
if (sum >= k - dp[i / 2]) return 1;
continue;
} else
sum = sum + dp[i];
} else {
if (i / 2 >= most) {
dp[i / 2] = dp[i / 2] + dp[i];
dp[i / 2 + 1] = dp[i / 2 + 1] + dp[i];
if (sum + dp[i / 2] >= k - dp[i / 2 + 1]) return 1;
} else
sum = sum + dp[i];
}
if (sum >= k) return 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int ok = 0, not_ok = inf;
while (not_ok - ok > 1) {
int av = (ok + not_ok) / 2;
if (can(av))
ok = av;
else
not_ok = av;
}
if (ok == 0)
cout << -1 << endl;
else
cout << ok << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000000 + 10;
long long n, k;
long long a[maxn];
long long cal(long long b) {
long long sum = 0;
for (int i = 1; i <= n; ++i) {
long long tmp = a[i], cnt = 1;
if (tmp < b) continue;
bool ok = false;
do {
if (tmp == b || ((tmp - 1) == b && ok)) {
long long tot1 = a[i] - (cnt * (tmp - 1));
if (tmp == b) {
cnt = max(cnt >> 1, tot1);
}
break;
}
if (tmp & 1)
ok = true;
else
ok = false;
tmp = max(tmp >> 1, tmp - (tmp >> 1));
if (tmp < b) break;
cnt <<= 1;
} while (tmp >= b);
sum += cnt;
}
return sum;
}
long long solve() {
long long sum = 0;
for (int i = 1; i <= n; ++i) {
sum += a[i];
}
if (sum < k) return -1;
long long x = 1, y = -1;
for (int i = 1; i <= n; ++i) {
y = max(y, a[i] + 1);
}
while (x < y) {
long long m = x + (y - x) / 2;
long long res = cal(m);
if (res >= k) {
x = m + 1;
} else if (res < k) {
y = m;
}
}
return max(1LL, x - 1);
}
int main(int argc, char const *argv[]) {
while (scanf("%I64d %I64d", &n, &k) == 2) {
for (int i = 1; i <= n; ++i) scanf("%I64d", &a[i]);
printf("%I64d\n", solve());
}
return 0;
}
|
#include <bits/stdc++.h>
#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 int n, k;
long long int freq[10000001] = {0};
long long int neg[10000001] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int i;
cin >> n >> k;
for (i = 0; i < n; i++) {
long long int kk;
cin >> kk;
freq[kk]++;
}
long long int cnt = 0;
long long int ans = -1;
for (i = 10000000; i >= 1; i--) {
cnt += freq[i];
cnt -= neg[i];
if (cnt >= k) {
ans = i;
break;
}
neg[(i + 1) / 2] += freq[i];
freq[(i + 1) / 2] += freq[i];
freq[(i) / 2] += freq[i];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[10000005], b[10000005], n, k;
long long check(long long x) {
memset(a, 0, sizeof a);
long long i, j, sum = 0;
for (i = 1; i <= n; i++) a[b[i]]++;
for (i = 10000005; i >= x; i--) {
if ((i >> 1) >= x) {
a[(i >> 1)] += a[i];
a[i - (i >> 1)] += a[i];
} else {
sum += a[i];
}
}
return sum >= k;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long i, j, mx = 0, sum = 0;
cin >> n >> k;
for (i = 1; i <= n; i++) {
cin >> b[i];
sum += b[i];
}
if (sum < k) {
cout << "-1";
return 0;
}
long long hi = 10000000, lo = 0, mid;
while (hi - lo > 1) {
mid = (hi + lo) / 2;
if (check(mid))
lo = mid;
else
hi = mid;
}
if (check(hi))
cout << hi;
else if (check(mid))
cout << mid;
else
cout << lo;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 2, M = 1e7 + 2;
int n, k, ar[N], mp[M];
inline bool check(int md) {
memset(mp, 0, sizeof(mp));
for (int i = md; i <= 1e7; i++) {
if (i < md + md)
mp[i] = 1;
else
mp[i] = mp[(i >> 1)] + mp[((i + 1) >> 1)];
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += mp[ar[i]];
if (ans >= k) return true;
}
return false;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) scanf("%I64d", &ar[i]);
int l = 0, r = 1e9 + 7;
while (r - l > 1) {
int md = (l + r) >> 1;
if (check(md))
l = md;
else
r = md;
}
if (l == 0)
cout << -1;
else
cout << l;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[10000001];
int main() {
long long n, k, a, b;
cin >> n >> k;
long long tot = 0;
for (int i = 0; i < n; i++) {
cin >> a;
f[a]++;
tot += a;
}
if (tot < k) {
cout << -1;
return 0;
}
long long cnt = 0;
int j = 1;
for (int i = 1e7; i >= 1; i--) {
cnt += f[i];
if (cnt >= k) {
j = i;
break;
}
}
for (int i = 1e7; i >= 2; i--) {
a = i / 2;
b = i - i / 2;
if (a >= j and b >= j) {
cnt += f[i];
f[a] += f[i];
f[b] += f[i];
f[i] = 0;
while (cnt - f[j] >= k) {
cnt -= f[j];
j++;
}
} else
break;
}
cout << j;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = (int)1e9 + 7;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int oo = (int)1e9;
const int MAX = 10000009;
int n;
long long m;
int a[MAX];
long long dp[MAX];
long long fun(int x, long long mid) {
long long& r = dp[x];
if (r != -1) return dp[x];
if (x < mid) return r = 0;
if (x / 2 < mid) return r = 1;
return r = fun(x / 2, mid) + fun(x - x / 2, mid);
}
int calc(int x, long long mid) {
int r = x / mid;
if (r == 0) return 0;
r = (int)log2(r);
return (1 << r);
}
bool check(long long mid) {
memset(dp, -1, sizeof dp);
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += fun(a[i], mid);
if (sum >= m) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + n);
reverse(a, a + n);
long long l = 1, r = sum / m, ans = -1;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int n, k, a[1000000 + 10];
bool ok(int x) {
LL sum = 0;
for (int i = 0; i < int(n); ++i) {
if (x > a[i]) break;
LL t = 0;
for (LL j = 1; a[i] / j + 1 >= x; j += j) {
LL r = a[i] % j;
LL tmp = a[i] / j >= x ? j : r;
t = max(t, tmp);
if (a[i] / j == 0) break;
}
if (sum + (n - i) * t < k) break;
sum += t;
if (sum >= k) break;
}
return sum >= k;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < int(n); ++i) scanf("%d", &a[i]);
sort(a, a + n, greater<int>());
int l = 1, r = 1e7 + 1, ans = -1;
while (l <= r) {
int m = (l + r) >> 1;
if (ok(m)) {
ans = m;
l = m + 1;
} else
r = m - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[1000005];
long long n, k, mx = 0, a, cnt, put, cnt1, rest;
long long s = 0;
bool ok(int val) {
cnt = 0;
rest = k;
for (int i = 0; i < n; i++) {
if (v[i] < val) continue;
a = v[i];
put = 1;
while (a / 2 >= val) {
a /= 2;
put *= 2;
}
cnt1 = v[i] - a * put;
put -= cnt1;
if (a + 1 >= val * 2)
cnt += put + cnt1 * 2;
else
cnt += (put + cnt1);
}
if (cnt >= k)
return 1;
else
return 0;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> v[i];
s += v[i];
if (v[i] > mx) mx = v[i];
}
sort(v, v + n);
if (s < k) {
cout << "-1";
return 0;
}
if (s == k)
cout << 1;
else {
long long st = 1, dr = mx, ans = 1;
long long md;
while (st <= dr) {
md = (st + dr) / 2;
if (ok(md) == 1) {
st = md + 1;
ans = md;
} else
dr = md - 1;
}
while (ok(ans + 1) == 1) ans++;
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
int a[1000000];
inline int slices(int A, int num) {
int res = 0;
int bp = 1;
while ((A / bp) + 1 >= num) {
int q = A / bp;
int mod = A % bp;
if (q >= num)
res = max(res, bp);
else
res = max(res, mod);
bp *= 2;
}
return res;
}
bool can(int num) {
long long M = 0;
for (int i = 0; i < N; i++) M += (long long)(slices(a[i], num));
return (M >= (long long)(K));
}
int binary_search(int OK, int NO) {
if (NO - OK == 1) return OK;
int mid = (OK + NO) / 2;
if (can(mid)) return binary_search(mid, NO);
return binary_search(OK, mid);
}
int main() {
cin >> N >> K;
long long sum = 0;
for (int i = 0; i < N; i++) scanf("%d", &a[i]), sum += (long long)(a[i]);
if (sum < (long long)(K)) {
cout << "-1";
return 0;
}
cout << binary_search(1, *max_element(a, a + N) + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
const int dx[9] = {0, 1, -1, 0, 0, -1, -1, 1, 1};
const int dy[9] = {0, 0, 0, -1, 1, -1, 1, -1, 1};
const double pi = acos(-1.0);
int n;
long long k, l, r, tjoy;
int a[MAXN];
long long bo[10000009];
bool ok(long long joy) {
for (int i = 1; i <= 10000000; i++) bo[i] = 0;
for (int i = 1; i <= n; i++) bo[a[i]]++;
long long num = 0;
for (int i = 10000000; i >= joy; i--) {
if (i / 2 >= joy) {
if (i & 1) {
bo[i / 2] += bo[i];
bo[i / 2 + 1] += bo[i];
} else
bo[i / 2] += 2 * bo[i];
} else
num += bo[i];
}
if (num >= k)
return true;
else
return false;
}
int main() {
scanf("%d", &n);
scanf("%I64d", &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
l = 1, r = 1e7;
long long ans = -1;
while (l <= r) {
long long m = (l + r) >> 1;
if (ok(m)) {
ans = m;
l = m + 1;
} else
r = m - 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
int n, t[10000001];
long long x[1000001], ave, m, max, k, sum, f[20000002];
int main() {
scanf("%d%I64d", &n, &m);
for (int i = 0; i <= 10000000; i++) t[i] = 0;
ave = 0;
max = 0;
for (int i = 1; i <= n; i++) {
scanf("%I64d", &x[i]), t[x[i]]++, ave += x[i];
if (x[i] > max) max = x[i];
}
ave = ave / m;
if (ave == 0) {
printf("-1");
return 0;
}
sum = 0;
if (ave == 1) {
printf("1");
return 0;
}
for (int i = 0; i <= max; i++) f[i] = t[i];
for (int i = max; i >= 1; i--) {
f[i] += f[i << 1] * 2 + f[(i << 1) + 1] + f[(i << 1) - 1];
if (f[i] - f[i << 1] - f[(i << 1) - 1] + sum >= m) {
printf("%d", i);
return 0;
}
sum += f[i] - f[i << 1] - f[(i << 1) - 1];
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sum[10000001];
int main() {
int n, k;
int maxi = 0;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
sum[x]++;
maxi = max(maxi, x);
}
priority_queue<pair<long long, long long> > q;
long long sumQ = 0;
for (int i = maxi; i > 0; i--) {
long long summ = sum[i];
while (!q.empty()) {
int frontt = q.top().first;
if (frontt >= i) {
sumQ -= q.top().second;
q.pop();
} else {
break;
}
}
summ += sumQ;
if (summ >= k) {
printf("%d", i);
return 0;
} else {
if (i % 2) {
if (sum[i]) {
q.push(make_pair((i / 2 + 1), sum[i]));
sum[i / 2 + 1] += sum[i];
sum[i / 2] += sum[i];
sumQ += sum[i];
}
} else {
if (sum[i]) {
sum[i / 2] += sum[i] * 2;
q.push(make_pair((i / 2), sum[i]));
sumQ += sum[i];
}
}
}
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
const int MAXN(20000000 + 1000);
int n, k, x[MAXN / 10], MAX;
ll d[MAXN];
bool Gyul(int target) {
ll cnt = 0;
for (int j = 0; j < target; j++) d[j] = 0;
for (int j = target; j < target + target; j++) d[j] = 1;
for (int j = target + target; j <= MAX; j++) d[j] = d[j / 2] + d[(j + 1) / 2];
for (int i = 0; i < n; i++) cnt += d[x[i]];
return cnt >= k;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", x + i), MAX = MAX < x[i] ? x[i] : MAX;
int le = 1, ri = MAX, ans = -1;
while (le <= ri) {
int mid = (le + ri) >> 1;
if (Gyul(mid))
le = mid + 1, ans = mid;
else
ri = mid - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
long long find_p(long long mid, long long kol) {
if (kol < mid) return 0LL;
long long ct = 1LL;
while (mid * 2LL <= kol) mid *= 2LL, ct *= 2LL;
return ct;
}
int dp[10000001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (int(i) = 0; (i) < (int)(n); ++(i)) cin >> a[i];
;
long long l = 0, r = 10000001LL;
while (l < r - 1) {
long long total = 0LL;
long long mid = (l + r) / 2;
for (int i = 0; i < mid; i++) dp[i] = 0;
for (int i = mid; i <= 10000001; i++) {
dp[i] = max(1, dp[i / 2] + dp[(i + 1) / 2]);
}
for (int(i) = 0; (i) < (int)(n); ++(i)) total += dp[a[i]];
if (total >= k)
l = mid;
else
r = mid;
}
if (l == 0)
cout << -1;
else
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1000000;
const int MAX_A = 10000000;
long long cs[MAX_A + 1];
int main() {
int n, k;
scanf("%d%d", &n, &k);
long long asum = 0;
int maxa = 0;
for (int i = 0; i < n; i++) {
int ai;
scanf("%d", &ai);
asum += ai;
maxa = max(maxa, ai);
cs[ai]++;
}
if (asum < k) {
puts("-1");
return 0;
}
long long s = 0;
for (int i = maxa, j = maxa; i > 0; i--) {
s += cs[i];
while (j > 0 && j / 2 >= i) {
if (j & 1)
cs[j / 2] += cs[j], cs[(j + 1) / 2] += cs[j];
else
cs[j / 2] += cs[j] * 2;
s += cs[j];
cs[j] = 0;
j--;
}
if (s >= k) {
printf("%d\n", i);
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, ma = 1e7, a[1000069], fq[10000069], inf = 1e18;
long long val(long long x) {
if (x <= 0) {
return -1;
} else if (x > n) {
return inf;
} else {
return a[x];
}
}
int main() {
long long i, p, z;
scanf("%lld%lld", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%lld", a + i);
fq[a[i]]++;
}
sort(a + 1, a + n + 1);
p = n - m + 1;
z = val(p);
for (i = ma; i; i--) {
p += fq[i];
fq[i / 2] += fq[i];
fq[(i + 1) / 2] += fq[i];
z = max(z, min(val(p), i / 2));
}
z -= !z;
printf("%lld\n", z);
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
template <typename first, typename second>
ostream& operator<<(ostream& os, const pair<first, second>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ",";
os << *it;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream& operator<<(ostream& os, const map<first, second>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello&... rest) {
cerr << arg << ' ';
faltu(rest...);
}
const int mx = 1e7 + 5;
int n, k;
long long b[mx], c[mx];
int lim = 1e7 + 3;
bool check(int key) {
for (int i = key; i <= lim; ++i) c[i] = b[i];
long long cnt = 0;
for (int i = lim; i >= key; --i) {
int x = i / 2, y = i - x;
if (cnt >= k) return 1;
if ((x < key && y < key) || i == 1) {
cnt += c[i];
continue;
}
c[x] += c[i];
c[y] += c[i];
}
return (cnt >= k);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k;
long long sum = 0;
int hmm = -1;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
sum += x;
++b[x];
hmm = max(hmm, x);
}
if (sum < k) {
cout << -1 << '\n';
return 0;
}
int lo = 1, hi = hmm, mid;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (check(mid))
lo = mid + 1;
else
hi = mid - 1;
}
if (hi == 0) hi = -1;
cout << hi << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000002], b[10000002];
int main() {
int n, k, mx = 0;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
mx = max(mx, a[i]);
}
int l = 0, r = mx + 1, tm, i;
long long sm;
while (l < r - 1) {
tm = (l + r) / 2;
for (i = 0; i < tm; i++) b[i] = 0;
for (i = tm; i < min(tm * 2 - 1, mx + 1); i++) b[i] = 1;
if (tm == 1) b[1] = 1;
for (i = tm * 2 - 1; i <= mx; i++) b[i] = b[(i + 1) / 2] + b[i / 2];
sm = 1ll * 0;
for (i = 0; i < n; i++) sm += 1ll * b[a[i]];
if (sm >= k)
l = tm;
else
r = tm;
}
if (l == 0)
printf("-1\n");
else
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
int main() {
int n;
int k;
while (~scanf("%d%d", &n, &k)) {
vector<int> a(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a.begin(), a.end());
int A = *max_element(a.begin(), a.end());
vector<int> dp;
int lo = -1, up = A;
while (up - lo > 0) {
int mid = (lo + up + 1) / 2;
dp.assign(A + 1, 0);
for (int(i) = (int)(mid); (i) <= (int)(A); ++(i)) {
dp[i] = dp[i / 2] + dp[(i + 1) / 2];
amax(dp[i], 1);
}
long long cnt = 0;
for (int(i) = 0; (i) < (int)(n); ++(i)) cnt += dp[a[i]];
if (cnt >= k)
lo = mid;
else
up = mid - 1;
}
printf("%d\n", lo);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
long long maxa = -(1e7 + 100);
const long long inf = 2e18;
long long n, k;
vector<long long> a(maxn);
int main() {
scanf("%I64d %I64d", &n, &k);
long long sum = 0;
long long r = -inf;
for (int i = 0; i < n; ++i) {
scanf("%I64d", &a[i]);
r = max(r, a[i]);
maxa = max(maxa, a[i]);
sum += a[i];
}
if (sum < k) {
printf("-1");
return 0;
}
long long l = 0;
r++;
maxa++;
while (l + 1 < r) {
long long m = (l + r) / 2;
long long cnt = 0;
bool is = false;
vector<long long> add(maxa, 0LL);
if (m >= maxa) {
is = false;
} else {
add[m] = 1;
for (int i = m + 1; i < maxa; ++i)
add[i] = max(1LL, add[i / 2] + add[(i + 1) / 2]);
for (int i = 0; i < n; ++i) {
long long cur = a[i];
cnt += add[cur];
if (cnt >= k) {
is = true;
break;
}
}
}
if (is)
l = m;
else
r = m;
}
printf("%I64d", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int N = 1e5 + 9;
const int shift = 1e3 + 9;
const double Eps = 1e-7;
int cnum[20000009];
int n, k, d;
int main(void) {
if (fopen("in", "r") != NULL) {
freopen("in", "r", stdin);
freopen("out", "w", stdout);
}
while (cin >> n >> k) {
for (int i = 0; i < n; i++) {
scanf("%d", &d);
cnum[d]++;
}
long long csum = 0;
for (int ans = 10000001 - 1; ans >= 1; ans--) {
csum += cnum[ans];
for (int i = 2 * ans + 1; i >= 2 * ans; i--) {
cnum[i / 2] += cnum[i];
cnum[(i + 1) / 2] += cnum[i];
csum -= cnum[i];
if (i / 2 >= ans) csum += cnum[i];
if ((i + 1) / 2 >= ans) csum += cnum[i];
}
if (csum >= k) {
printf("%d\n", ans);
return 0;
}
}
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
const long long dxx[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
dyy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long mod = 1000000007;
const long long base = 311;
const long long N = 1e7 + 5;
long long n, k, a[N], b[N];
long long calc(long long mid) {
for (int i = 1; i <= 1e7; ++i) {
b[i] = a[i];
}
long long ans = 0;
for (int i = 1e7; i >= mid; --i) {
if (i >= 2 * mid) {
b[i / 2] += b[i];
b[i / 2 + i % 2] += b[i];
} else {
ans += b[i];
}
}
return ans;
}
void gogo() {
cin >> n >> k;
for (long long i = 1; i <= n; ++i) {
int x;
cin >> x;
a[x]++;
}
long long l = 1, r = 1e7, ans = -1;
while (l <= r) {
long long mid = (l + r) >> 1;
if (calc(mid) >= k) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (fopen("sol"
".inp",
"r")) {
freopen(
"sol"
".inp",
"r", stdin);
freopen(
"sol"
".out",
"w", stdout);
}
gogo();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
const int inf = 2e9 + 100;
int n;
int k;
long long sum;
int a[maxn];
int q[maxn * 10];
int maxa;
bool check(int m) {
for (int i = 0; i < m; i++) q[i] = 0;
q[m] = 1;
for (int i = m + 1; i <= maxa; i++)
q[i] = max(1, q[i >> 1] + q[(i >> 1) + (i & 1)]);
long long ret = 0;
for (int i = 0; i < n && ret < k; i++) ret += q[a[i]];
return ret >= k;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k;
int l = 1, r = 0;
for (int i = 0; i < n; i++)
cin >> a[i], sum = sum + a[i], r = max(r, a[i]), maxa = max(maxa, a[i]);
if (sum < k) {
cout << -1;
return 0;
}
r++;
while (r - l > 1) {
int m = (l + r) / 2;
if (check(m))
l = m;
else
r = m;
}
cout << l;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long posinf = 9223372036854775807;
const long long neginf = 9223372036854775808;
const unsigned long long ullinf = 18446744073709551615;
const unsigned long long bigprime = 2305843009213693951;
const unsigned long long smallprime = 2147483647;
const int prime = 3571;
const long long modbase = 1000000007;
const long long inv2mod = 500000004;
int dls[10000000];
int main() {
int n, k;
scanf("%d %d", &n, &k);
int mn = 10000001, mx = 0;
long long ds = 0;
int dlc = 0;
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
ds += t;
dls[t]++;
dlc++;
if (t > mx) mx = t;
if (t < mn) mn = t;
}
while (dlc > k) {
dls[mn]--;
while (!dls[mn]) mn++;
dlc--;
}
if (ds < k)
printf("-1 \n");
else {
while (dlc < k) {
int rmd = k - dlc;
int l = mx / 2;
int r = mx - l;
if (dls[mx] >= rmd) {
dls[l] += rmd;
dls[r] += rmd;
dls[mx] -= rmd;
while (!dls[mx]) mx--;
dlc += rmd;
mn = min(min(l, r), mn);
} else {
dls[l] += dls[mx];
dls[r] += dls[mx];
dlc += dls[mx];
dls[mx] = 0;
while (!dls[mx]) mx--;
mn = min(min(l, r), mn);
}
}
while (true) {
int l = mx / 2;
int r = mx - l;
if (l < mn || r < mn) break;
if (dls[mx] >= dls[mn]) {
int st = dls[mn];
dls[mn] = 0;
dls[l] += st;
dls[r] += st;
dls[mx] -= st;
while (!dls[mx]) mx--;
while (!dls[mn]) mn++;
} else {
int st = dls[mx];
dls[mx] = 0;
dls[l] += st;
dls[r] += st;
dls[mn] -= st;
while (!dls[mx]) mx--;
while (!dls[mn]) mn++;
}
}
printf("%d \n", mn);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000003, INF = 0x3f3f3f3f;
int n, m, a[maxn];
bool check(int x) {
int rest = m;
for (int i = 1; i <= n; i++) {
if (a[i] < x) continue;
int v = a[i], cnt0 = 1, cnt1;
while (v / 2 >= x) v /= 2, cnt0 <<= 1;
cnt1 = a[i] - v * cnt0;
cnt0 -= cnt1;
if (v + 1 >= x * 2)
rest -= (cnt0 + cnt1 * 2);
else
rest -= (cnt0 + cnt1);
if (rest <= 0) return 1;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
int l = 1, r = 10000000, mid, ans = -1;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
ans = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MX = 1e6 + 7;
int n, k;
long long b[10 * MX];
int a[MX];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[a[i]]++;
}
long long st = 1, en = 1e7, ans = -1;
while (st <= en) {
long long mid = (st + en) / 2;
long long sx = 0, flag = 0;
memset(b, 0, sizeof b);
for (int i = 0; i < n; i++) b[a[i]]++;
for (long long i = 1e7; i >= mid; i--) {
if (!b[i]) continue;
sx += b[i];
if (sx >= k) {
flag = 1;
break;
}
if (i / 2 < mid) continue;
sx -= b[i];
long long so = b[i];
b[i / 2] += so;
b[i / 2 + (i & 1)] += so;
}
if (flag) {
st = mid + 1;
ans = max(ans, mid);
} else
en = mid - 1;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
long long A[N];
int n;
long long k;
long long f(long long w, long long p) {
if (p == 1) return w;
int i = 0;
while ((w >> (i + 1)) + 1 >= p) i++;
int n = (1 << i) * ((w >> i) + 1) - w;
if (p == (w >> i) + 1) {
if (n == (1 << i))
return (1 << (i - 1));
else
return max((1 << (i - 1)), (1 << i) - n);
} else {
return (1 << i);
}
}
bool valid(long long x) {
long long v = 0;
for (int i = 0; i < int(n); i++) {
if (x > A[i]) continue;
v += f(A[i], x);
}
return v >= k;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < int(n); i++) cin >> A[i];
long long lo = 1, hi = 1e7;
while (lo < hi - 1) {
long long mid = (lo + hi) / 2;
valid(mid) ? lo = mid : hi = mid - 1;
}
if (valid(hi))
cout << hi << '\n';
else if (valid(lo))
cout << lo << '\n';
else
cout << -1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
long long count1[10000000 + 1];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
long long n;
long long k;
cin >> n >> k;
int x = 0, y;
int a[n];
for (int i = 0; i < 10000000 + 1; i++) {
count1[i] = 0;
}
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > x) {
x = a[i];
}
count1[a[i]]++;
sum += a[i];
}
if (sum < k) {
cout << -1 << flush;
return 0;
}
while (n < k) {
count1[x / 2] += count1[x];
count1[(x + 1) / 2] += count1[x];
n += count1[x];
count1[x] = 0;
while (count1[x] == 0) {
x--;
}
}
y = x;
sum = 0;
while (1) {
if (sum + count1[y] < k) {
sum += count1[y];
y--;
} else {
count1[y] = k - sum;
for (int i = 0; i < y; i++) {
count1[i] = 0;
}
break;
}
}
while ((x / 2) > y) {
count1[x / 2] += count1[x];
count1[(x + 1) / 2] += count1[x];
long long delta = count1[x];
count1[x] = 0;
while (count1[x] == 0) {
x--;
}
while (count1[y] < delta) {
delta -= count1[y];
count1[y] = 0;
while (count1[y] == 0) {
y++;
}
}
count1[y] -= delta;
while (count1[y] == 0) {
y++;
}
}
cout << y << flush;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long high, low, mid, MAX_B;
long long A[10000005], B[1000005], k, d;
int n;
int main() {
scanf("%d %lld", &n, &k);
for (int i = (0); i < (n); i++) {
scanf("%lld", &B[i]);
MAX_B = max(B[i], MAX_B);
}
high = 10000001ll;
low = 0ll;
while (high - low > 1) {
mid = (high + low) / 2;
for (int i = (1); i <= (MAX_B); i++) {
if (i < mid)
A[i] = 0;
else
A[i] = 1;
if ((i & 1) == 0)
A[i] = max(A[i], A[i / 2] + A[i / 2]);
else
A[i] = max(A[i], A[i / 2] + A[i / 2 + 1]);
}
d = 0;
for (int i = (0); i < (n); i++) d += A[B[i]];
if (d >= k)
low = mid;
else
high = mid;
}
if (low == 0ll) low = -1ll;
printf("%lld\n", low);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long sum = 0;
int a[10000005] = {};
int mx = 0;
int main() {
std::cin.sync_with_stdio(0);
cin >> n >> k;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
mx = max(mx, t);
a[t]++;
sum += t;
}
if (sum < k) {
cout << -1;
return 0;
}
int have = n;
for (int i = mx; i >= 2; i--) {
if (have >= k) break;
if (a[i] == 0) continue;
int t1, t2;
if (i % 2 == 0)
t1 = t2 = i >> 1;
else
t2 = i >> 1, t1 = t2 + 1;
int cur = a[i];
have += cur;
a[t1] += cur;
a[t2] += cur;
a[i] = 0;
}
set<int> q;
int tmp = 0;
for (int i = mx; i >= 1; i--) {
if (a[i] == 0) continue;
tmp += a[i];
q.insert(i);
if (tmp >= k) break;
}
int bestAns = *q.begin();
for (int i = mx; i >= 2; i--) {
if (a[i] == 0) continue;
int t1, t2;
if (i % 2 == 0)
t1 = t2 = i >> 1;
else
t2 = i >> 1, t1 = t2 + 1;
if (t1 > bestAns) {
int cur = a[i];
a[t1] += cur;
a[t2] += cur;
q.insert(t1);
q.insert(t2);
q.erase(i);
a[i] = 0;
while (cur > 0) {
if (cur >= a[bestAns]) {
cur -= a[bestAns];
a[bestAns] = 0;
q.erase(bestAns);
bestAns = *q.begin();
} else {
a[bestAns] -= cur;
cur = 0;
}
}
}
}
cout << bestAns;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1e6 + 1;
const int maxn = 1e6;
int n, k, x, mx;
int a[N], b[N];
char c;
string s, s2;
long long sum;
long long cnt[maxn * 10 + 2];
vector<int> G[N];
map<string, int> mp1;
map<int, string> mp2;
priority_queue<int> q[N];
void init() {
memset(a, 0, sizeof a);
memset(b, 0, sizeof b);
memset(cnt, 0, sizeof cnt);
sum = 0;
mx = -23;
}
int main() {
scanf("%d%d", &n, &k);
init();
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
cnt[a[i]]++;
sum += (long long)a[i];
mx = ((mx > a[i]) ? mx : a[i]);
}
if (sum < k) {
puts("-1");
return 0;
}
sum = 0;
int ans;
for (int i = mx; i; i--) {
sum += cnt[i];
if (i * 2 <= mx) sum -= cnt[i << 1];
if (i * 2 - 1 <= mx && i != 1) sum -= cnt[(i * 2) - 1];
if (sum >= k) {
ans = i;
printf("%d\n", ans);
break;
}
cnt[i >> 1] += cnt[i];
cnt[i + 1 >> 1] += cnt[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, x;
int ans = -1;
long long s[10000005], cnt;
int main() {
scanf("%d %d", &n, &k);
for (int i = (1); i <= (n); i++) {
scanf("%d", &x);
s[x]++;
}
cnt = n;
int r = 10000000;
for (int i = (1); i <= (10000000); i++) {
while (cnt < k && r > i) {
int a = r / 2, b = (r + 1) / 2;
if (s[r] + cnt > k && a >= i) {
s[a] += k - cnt;
s[b] += k - cnt;
s[r] -= k - cnt;
cnt += k - cnt;
break;
} else {
s[a] += s[r];
if (a >= i) cnt += s[r];
s[b] += s[r];
if (b >= i) cnt += s[r];
cnt -= s[r];
s[r] = 0;
}
r--;
}
if (cnt >= k) ans = max(ans, i);
cnt -= s[i];
}
printf("%d\n", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.