text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:300000000")
using namespace std;
const double pi = 3.1415926535897932384626433832795;
template <class T>
T abs(T &a) {
return a >= 0 ? a : -a;
};
template <class T>
T sqr(T &x) {
return x * x;
}
long long h, w;
long long bestW = 0, bestH = 0;
void dotry(long long curW, long long curH) {
if (curW * curH > bestW * bestH ||
curW * curH == bestW * bestH && curH > bestH) {
bestH = curH;
bestW = curW;
}
}
void checkWidth(long long curW) {
long long curH = min(h, curW * 5 / 4);
if (curH < curW * 4 / 5.0) return;
dotry(curW, curH);
}
void checkHeight(long long curH) {
long long curW = min(w, curH * 5 / 4);
if (curW < curH * 4 / 5.0) return;
dotry(curW, curH);
}
int main() {
cin >> h >> w;
for (long long p = 1; p <= w; p <<= 1) checkWidth(p);
for (long long p = 1; p <= h; p <<= 1) checkHeight(p);
cout << bestH << ' ' << bestW;
}
|
#include <bits/stdc++.h>
using namespace std;
int w, h;
long long resw, resh;
void upd(long long curw, long long curh) {
if (curh * curw < resh * resw) return;
if (curh * curw > resh * resw) {
resh = curh;
resw = curw;
return;
}
if (curh > resh) {
resh = curh;
resw = curw;
}
}
int main() {
cin >> h >> w;
for (long long l = 1; l <= w; l *= 2) {
long long curw = l;
long long curh = (curw * 5) / 4;
if (curh > h) curh = h;
if ((curw * 4 + 4) / 5 <= curh && (curh * 4 + 4) / 5 <= curw) {
upd(curw, curh);
}
}
for (long long l = 1; l <= h; l *= 2) {
long long curh = l;
long long curw = (curh * 5) / 4;
if (curw > w) curw = w;
if ((curw * 4 + 4) / 5 <= curh && (curh * 4 + 4) / 5 <= curw) {
upd(curw, curh);
}
}
cout << resh << " " << resw;
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> solve(long long a, long long b) {
vector<long long> val;
for (long long i = 2; i <= 2; i++) {
long long cur = 1;
while (cur <= a) {
val.push_back(cur);
cur = cur * 2;
}
}
long long other = -1;
long long ca = 1;
for (long long i = val.size() - 1; i >= 0; i--) {
long long mi = val[i];
long long l = mi * 4 / 5 + (mi * 4 % 5 && 1);
long long r = mi * 5 / 4;
if (b < l) continue;
long long choose = min(b, r);
if (choose > other) {
other = choose;
ca = mi;
}
}
return make_pair(ca, other);
}
long long area(pair<long long, long long> hcn) {
return hcn.first * hcn.second;
}
int main() {
long long w, h;
cin >> w >> h;
pair<long long, long long> u1 = solve(w, h);
pair<long long, long long> u2 = solve(h, w);
if (area(u1) > area(u2)) {
cout << u1.first << " " << u1.second;
} else {
cout << u2.second << " " << u2.first << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long h, w;
long long cut(long long x, long long y) {
h = x;
w = y;
if (x > ((y * 5) / 4)) return -1;
w = min(y, ((x * 5) / 4));
return h * w;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long a, b, area = 0, c;
pair<long long, long long> ans = make_pair(-1, -1);
cin >> a >> b;
for (long long i = 0; i < 31; i++) {
if ((1 << i) <= a) {
c = cut((1 << i), b);
if (c > area) {
area = c;
ans = make_pair(h, w);
} else if (c == area)
ans = max(ans, make_pair(h, w));
}
if ((1 << i) <= b) {
c = cut((1 << i), a);
if (c > area) {
area = c;
ans = make_pair(w, h);
} else if (c == area)
ans = max(ans, make_pair(w, h));
}
}
cout << ans.first << ' ' << ans.second;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s, h, w, s1, s2, x1, x2, y1, y2;
cin >> h >> w;
s1 = 1;
s2 = 1;
while (s1 * 2 <= h) s1 *= 2;
while (s1 > 1.25 * w) s1 = s1 / 2;
x1 = s1;
y1 = w;
y1 = min(w, (long long)trunc(1.25 * x1));
s = x1 * y1;
s2 = 1;
while (s2 * 2 <= w) s2 *= 2;
while (s2 > 1.25 * h) s2 = s2 / 2;
y2 = s2;
x2 = min(h, (long long)trunc(1.25 * y2));
if (x2 * y2 >= s)
cout << x2 << " " << y2;
else
cout << x1 << " " << y1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, w;
scanf("%d %d", &h, &w);
long long mxW = 0, mxH = 0;
for (long long hh = 1; hh <= h; hh <<= 1) {
long long ww = min((long long)w, (hh * 5) >> 2);
if (ww * 5 < hh * 4) continue;
if (ww * hh > mxW * mxH || (ww * hh == mxW * mxH && hh > mxH)) {
mxH = hh;
mxW = ww;
}
}
for (long long ww = 1; ww <= w; ww <<= 1) {
long long hh = min((long long)h, (ww * 5) >> 2);
if (hh * 5 < ww * 4) continue;
if (ww * hh > mxW * mxH || (ww * hh == mxW * mxH && hh > mxH)) {
mxH = hh;
mxW = ww;
}
}
printf("%I64d %I64d\n", mxH, mxW);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897932384626433832795029L;
bool solve(int testNumber) {
long long h, w;
if (scanf("%lld %lld", &h, &w) == EOF) return false;
long long H = 0, W = 0;
for (long long i = 1; i <= h; i *= 2) {
long long from = (4 * i + 4) / 5, to = min(5 * i / 4, w);
if (to >= from and (i * to > H * W or (i * to == H * W and i > H))) {
H = i;
W = to;
}
}
for (long long i = 1; i <= w; i *= 2) {
long long from = (4 * i + 4) / 5, to = min(5 * i / 4, h);
if (to >= from and (i * to > H * W or (i * to == H * W and to > H))) {
W = i;
H = to;
}
}
printf("%lld %lld\n", H, W);
return true;
}
int main() {
for (int i = 1; solve(i); i++)
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long h, w;
cin >> h >> w;
unsigned long long x = 1;
unsigned long long y = 1;
while (w >= x && w >= y) {
x *= 2;
y *= 2;
}
x /= 2;
y /= 2;
x = min(x, w);
y = min(y, h);
w = min(w, (unsigned long long)(y * 1.25));
h = min(h, (unsigned long long)(x * 1.25));
if (h * x >= y * w) {
cout << h << " " << x;
} else {
cout << y << " " << w;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long w, h, answ, ansh;
cin >> h >> w;
long long ans = 0;
for (int i = 0;; ++i) {
long long cut = 1ll << i;
if (cut > w) break;
long long t = 1.0 * cut / 0.8 + 0.5;
long long tt = 1.0 * cut / 1.25 + 0.5;
if (t <= h) {
if (ans < t * cut || (ans == t * cut && ansh < t)) {
ans = t * cut;
answ = cut;
ansh = t;
}
} else if (tt <= h) {
if (ans < h * cut || (ans == h * cut && ansh < h)) {
ans = h * cut;
answ = cut;
ansh = h;
}
}
}
for (int i = 0;; ++i) {
long long cut = 1ll << i;
if (cut > h) break;
long long t = 1.0 * cut / 0.8 + 0.5;
long long tt = 1.0 * cut / 1.25 + 0.5;
if (t <= w) {
if (ans < t * cut || (ans == t * cut && ansh < cut)) {
ans = t * cut;
ansh = cut;
answ = t;
}
} else if (tt <= w) {
if (ans < w * cut || (ans == t * cut && ansh < cut)) {
ans = w * cut;
ansh = cut;
answ = w;
}
}
}
cout << ansh << ' ' << answ << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int UI;
typedef long int LI;
typedef unsigned long int ULI;
typedef long long int LL;
typedef unsigned long long int ULL;
LL mod = 1e9 + 7;
inline int scanInt() {
int n = 0;
char ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = (n << 1) + (n << 3) + (int)(ch - '0');
ch = getchar();
}
return n * sign;
}
inline LL scanLong() {
LL n = 0;
char ch = getchar();
LL sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = (n << 1) + (n << 3) + (LL)(ch - '0');
ch = getchar();
}
return n * sign;
}
int main() {
LL h = scanLong();
;
LL w = scanLong();
;
pair<LL, LL> ans(-1, 0);
LL ch = 1;
while (ch <= h) ch <<= 1;
ch >>= 1;
while (ch > 0) {
LL lw = ceil(ch / 1.25), hw = floor(ch / 0.8);
if ((lw <= w && w <= hw) || w > hw) {
ans = make_pair(ch, min(w, hw));
break;
}
ch >>= 1;
}
LL cw = 1;
while (cw <= w) cw <<= 1;
cw >>= 1;
while (cw > 0) {
LL lh = ceil(0.8 * cw), hh = floor(1.25 * cw);
if ((lh <= h && h <= hh) || h > hh) {
if (min(h, hh) * cw >= ans.first * ans.second) {
ans = make_pair(min(h, hh), cw);
break;
}
}
cw <<= 1;
}
printf("%lld ", ans.first);
printf("%lld ", ans.second);
printf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int area;
ostream& operator<<(ostream& ostr, const pair<long long, long long>& p) {
ostr << p.first << " " << p.second;
return ostr;
}
vector<int> power_of_twos(int limit) {
vector<int> result(1, 1);
while (result.back() * 2 < limit) {
result.push_back(result.back() * 2);
}
return result;
}
inline bool okay_ratio(long long a, long long b) {
return 4 * b <= a * 5 && a * 4 <= 5 * b;
}
long long solve_width(long long e, long long h) {
long long s = 1;
long long result = -1;
while (s <= e) {
long long width = (s + e) / 2;
if (okay_ratio(h, width)) {
s = width + 1;
if (h * width > area) {
area = h * width;
result = width;
}
} else if (h * 4 > 5 * width) {
s = width + 1;
} else if (h * 5 < 4 * width) {
e = width - 1;
}
}
return result;
}
long long solve_height(long long e, long long w, long long cur_h) {
long long s = 1;
long long result = -1;
while (s <= e) {
long long height = (s + e) / 2;
if (okay_ratio(height, w)) {
s = height + 1;
if (height * w > area || (height * w == area && height > cur_h)) {
area = height * w;
result = height;
}
} else if (height * 4 > 5 * w) {
e = height - 1;
} else if (height * 5 < 4 * w) {
s = height + 1;
}
}
return result;
}
int main() {
vector<int> twos = power_of_twos(1e9);
int h, w;
cin >> h >> w;
int wi = -1;
int hi = -1;
for (int i = 0; i < (int)twos.size(); i++) {
if (twos[i] <= w) {
wi = i;
}
if (twos[i] <= h) {
hi = i;
}
}
area = -1;
pair<long long, long long> result1 = {twos[hi], solve_width(w, twos[hi])};
pair<long long, long long> result2 = {
solve_height(h, twos[wi], result1.first), twos[wi]};
if (result1.first == -1 || result1.second == -1) {
cout << result2 << endl;
} else if (result2.first == -1 || result2.second == -1) {
cout << result1 << endl;
} else {
if (result1.first * result1.second > result2.first * result2.second) {
cout << result1 << endl;
} else if (result1.first * result1.second <
result2.first * result2.second) {
cout << result2 << endl;
} else {
if (result1.first > result2.first) {
cout << result1 << endl;
} else {
cout << result2 << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long h, w;
cin >> h >> w;
vector<tuple<long long, long long, long long> > v;
for (long long i = 1; i <= w; i <<= 1) {
long long up = floor(((long double)1.25) * (i));
long long low = ceil(((long double)0.8) * (i));
long long ans = 0;
if (low <= h && h <= up) {
ans = h;
} else if (h > up) {
ans = up;
}
v.push_back({-1 * i * ans, -1 * ans, -1 * i});
}
for (long long i = 1; i <= h; i <<= 1) {
long long up = floor(((long double)1.25) * (i));
long long low = ceil(((long double)0.8) * (i));
long long ans = 0;
if (low <= w && w <= up) {
ans = w;
} else if (w > up) {
ans = up;
}
v.push_back({-1 * i * ans, -1 * i, -1 * ans});
}
sort(v.begin(), v.end());
cout << -1 * get<1>(v[0]) << " " << -1 * get<2>(v[0]) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tostr(const T& t) {
ostringstream os;
os << t;
return os.str();
}
const double EPS = 1e-10;
int main(int argc, char* argv[]) {
long long H, W, ah, aw, besta;
cin >> H >> W;
ah = aw = 1;
besta = 0;
for (long long h = 1LL; h <= H; h <<= 1LL) {
long long w = W;
long long wlo = ceil(h / 1.25 - EPS);
long long whi = floor(h / 0.8 + EPS);
if (w >= wlo)
w = min(w, whi);
else
continue;
if (h * w > besta) {
besta = h * w;
ah = h;
aw = w;
} else if (h * w == besta && h > ah) {
ah = h;
aw = w;
}
}
for (long long w = 1LL; w <= W; w <<= 1LL) {
long long h = H;
long long hlo = ceil(w * 0.8 - EPS);
long long hhi = floor(w * 1.25 + EPS);
if (h >= hlo)
h = min(h, hhi);
else
continue;
if (h * w > besta) {
besta = h * w;
ah = h;
aw = w;
} else if (h * w == besta && h > ah) {
ah = h;
aw = w;
}
}
cout << ah << " " << aw << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int h, w;
cin >> h >> w;
vector<int> p2;
p2.push_back(1);
for (int i = 0; i < 30; i++) p2.push_back(p2[i] * 2);
pair<int, int> anw = make_pair(1, 1);
for (int i = 0; i < p2.size(); i++) {
if (p2[i] > w) break;
int th = min(p2[i] + (p2[i] / 4), h);
if (double(p2[i]) > 1.25 * double(th)) break;
if (1LL * anw.first * anw.second < 1LL * p2[i] * th ||
(anw.first < th && 1LL * anw.first * anw.second == 1LL * p2[i] * th))
anw = make_pair(th, p2[i]);
}
for (int i = 0; i < p2.size(); i++) {
if (p2[i] > h) break;
int tw = min(p2[i] + (p2[i] / 4), w);
if (double(p2[i]) > 1.25 * double(tw)) break;
if (1LL * anw.first * anw.second < 1LL * p2[i] * tw ||
(anw.first < p2[i] && 1LL * anw.first * anw.second == 1LL * p2[i] * tw))
anw = make_pair(p2[i], tw);
}
cout << anw.first << " " << anw.second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long h, w;
cin >> h >> w;
long long p = 1;
long long ch = -1, cw = -1;
for (p = p; p <= h || p <= w; p *= 2) {
if (p == 2) int x = 0;
int t;
if (p <= h) {
t = min((p * 10 / 8), max(((p * 100 + 124) / 125), w));
if (t <= w &&
(ch == -1 || ch * cw < t * p || (ch * cw == t * p && ch < p)))
ch = p, cw = t;
}
if (p <= w) {
t = max(((p * 8 + 9) / 10), min((p * 125 / 100), h));
if (t <= h &&
(ch == -1 || ch * cw < t * p || (ch * cw == t * p && ch < t)))
ch = t, cw = p;
}
}
cout << ch << " " << cw << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long a[33];
long long h, w, h1, w1, h2, w2;
long long s = 0;
h2 = 0;
w2 = 0;
cin >> h >> w;
a[0] = 1;
int i;
int tt = 0;
for (i = 1; i < 32; i++) a[i] = a[i - 1] * 2;
i = 31;
while (h < a[i]) i--;
while (i != -1) {
h1 = a[i];
w1 = w;
if (h1 / 0.8 < w1) w1 = h1 / 0.8;
while (w1 != 0 && (double)(h1 / w1) <= 1.25) {
if (h1 * w1 < s) break;
if ((double)h1 / w1 >= 0.8) {
s = h1 * w1;
tt = 1;
if (h1 > h2) {
h2 = h1;
w2 = w1;
};
break;
}
w1--;
}
i--;
}
i = 31;
while (w < a[i]) i--;
tt = 0;
while (i != -1) {
w1 = a[i];
h1 = h;
if (w1 * 1.25 < h) h1 = w1 * 1.25;
while ((double)(h1 / w1) >= 0.8) {
if (h1 * w1 < s) break;
if ((double)h1 / w1 <= 1.25) {
s = h1 * w1;
tt = 1;
if (h1 > h2) {
h2 = h1;
w2 = w1;
};
break;
}
h1--;
}
i--;
}
cout << h2 << " " << w2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long h, w;
cin >> h >> w;
long long b = 1;
while (b * 2 <= h && b * 2 <= w) b *= 2;
long long m1 = min(h, (long long)(b * 1.25));
long long m2 = min(w, (long long)(b * 1.25));
if (m1 >= m2)
cout << m1 << ' ' << b;
else
cout << b << ' ' << m2;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void remax(T& A, T B) {
if (A < B) A = B;
}
template <class T>
inline void remin(T& A, T B) {
if (A > B) A = B;
}
string ToString(long long num) {
string ret;
bool neg = false;
if (num < 0) num *= ~0, neg = true;
do {
ret += ((num % 10) + '0');
num /= 10;
} while (num);
if (neg) ret += '-';
reverse(ret.begin(), ret.end());
return ret;
}
long long ToNumber(string s) {
long long r = 0, p = 1;
int e = (s[0] == '-');
for (int i = (int)s.size() - 1; i >= e; --i) r += (s[i] - '0') * p, p *= 10;
if (e) r *= ~0;
return r;
}
long long Gcd(long long a, long long b) {
while (a %= b ^= a ^= b ^= a)
;
return b;
}
long long Power(long long base, unsigned long long power) {
long long ret = 1;
while (power) {
if (power & 1) ret *= base;
power >>= 1;
base *= base;
}
return ret;
}
long long PowerMod(long long base, unsigned long long power, long long mod) {
if (!power) return 1 % mod;
if (power & 1) return (base * PowerMod(base, power - 1, mod)) % mod;
return PowerMod((base * base) % mod, power >> 1, mod);
}
int Log(long long num, long long base) {
int ret = 0;
while (num) {
++ret;
num /= base;
}
return ret;
}
inline void run() {
long long h, w;
long long a = 0, b = 0;
scanf("%I64d%I64d", &h, &w);
for (long long i = 1; i <= h; i <<= 1) {
long long j = i * 5 / 4;
remin(j, w);
if (i * 4 <= j * 5 && (i * j > a * b || (i * j == a * b && i > a))) {
a = i;
b = j;
}
}
for (long long i = 1; i <= w; i <<= 1) {
long long j = i * 5 / 4;
remin(j, h);
if (i * 4 <= j * 5 && (i * j > a * b || (i * j == a * b && j > a))) {
a = j;
b = i;
}
}
printf("%I64d %I64d\n", a, b);
}
int main() {
FILE* inut = stdin;
FILE* outut = stdout;
while (!feof(inut)) {
run();
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t N>
int SIZE(const T (&t)[N]) {
return N;
}
template <typename T>
int SIZE(const T &t) {
return t.size();
}
string to_string(const string s, int x1 = 0, int x2 = 1e9) {
return '"' + ((x1 < s.size()) ? s.substr(x1, x2 - x1 + 1) : "") + '"';
}
string to_string(const char *s) { return to_string((string)s); }
string to_string(const bool b) { return (b ? "true" : "false"); }
string to_string(const char c) { return string({c}); }
template <size_t N>
string to_string(const bitset<N> &b, int x1 = 0, int x2 = 1e9) {
string t = "";
for (int __iii__ = min(x1, SIZE(b)), __jjj__ = min(x2, SIZE(b) - 1);
__iii__ <= __jjj__; ++__iii__) {
t += b[__iii__] + '0';
}
return '"' + t + '"';
}
template <typename A, typename... C>
string to_string(const A(&v), int x1 = 0, int x2 = 1e9, C... coords);
int l_v_l_v_l = 0, t_a_b_s = 0;
template <typename A, typename B>
string to_string(const pair<A, B> &p) {
l_v_l_v_l++;
string res = "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
l_v_l_v_l--;
return res;
}
template <typename A, typename... C>
string to_string(const A(&v), int x1, int x2, C... coords) {
int rnk = rank<A>::value;
string tab(t_a_b_s, ' ');
string res = "";
bool first = true;
if (l_v_l_v_l == 0) res += '\n';
res += tab + "[";
x1 = min(x1, SIZE(v)), x2 = min(x2, SIZE(v));
auto l = begin(v);
advance(l, x1);
auto r = l;
advance(r, (x2 - x1) + (x2 < SIZE(v)));
for (auto e = l; e != r; e = next(e)) {
if (!first) {
res += ", ";
}
first = false;
l_v_l_v_l++;
if (e != l) {
if (rnk > 1) {
res += '\n';
t_a_b_s = l_v_l_v_l;
};
} else {
t_a_b_s = 0;
}
res += to_string(*e, coords...);
l_v_l_v_l--;
}
res += "]";
if (l_v_l_v_l == 0) res += '\n';
return res;
}
void dbgm() { ; }
template <typename Heads, typename... Tails>
void dbgm(Heads H, Tails... T) {
cout << to_string(H) << " | ";
dbgm(T...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
long long a = log2(n);
if (pow(2, a + 1) == n) a++;
vector<long long> b(3);
for (;;) {
long long x = pow(2, a--);
long long y = min(5 * x / 4, m);
if (5 * y >= (4 * x)) {
b[0] = x * y;
b[1] = x;
b[2] = y;
break;
}
}
a = log2(m);
if (pow(2, a + 1) == m) a++;
vector<long long> c(3);
for (;;) {
long long x = pow(2, a--);
long long y = min(5 * x / 4, n);
if (5 * y >= (4 * x)) {
c[0] = x * y;
c[1] = y;
c[2] = x;
break;
}
}
if (b[0] > c[0]) {
cout << b[1] << " " << b[2];
} else if (c[0] > b[0]) {
cout << c[1] << " " << c[2];
} else {
if (b[1] > c[1])
cout << b[1] << " " << b[2];
else {
cout << c[1] << " " << c[2];
}
}
return 0;
}
|
#include <bits/stdc++.h>
long long maxx, maxy;
void judge(long long x, long long y) {
if (x * y > maxx * maxy) {
maxx = x;
maxy = y;
return;
}
if ((x * y == maxx * maxy) && (x > maxx)) {
maxx = x;
maxy = y;
return;
}
}
int main() {
long long s;
long long i;
long long x, y;
long long left, right;
long long m, n;
double f;
maxx = maxy = 1;
scanf("%I64d %I64d", &m, &n);
s = 1;
while (s <= m) {
f = 0.8 * s;
left = f;
if (f != left) left++;
right = 1.25 * s;
if (left > n) break;
if (right <= n) {
x = s;
y = right;
judge(x, y);
} else {
x = s;
y = n;
judge(x, y);
}
s *= 2;
}
s = 1;
while (s <= n) {
f = 0.8 * s;
left = f;
if (f != left) left++;
right = 1.25 * s;
if (left > m) break;
if (right <= m) {
x = right;
y = s;
judge(x, y);
} else {
x = m;
y = s;
judge(x, y);
}
s *= 2;
}
printf("%I64d %I64d\n", maxx, maxy);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int static_init = []() {
ios_base::sync_with_stdio(false), cin.tie(0), cout << fixed;
return 0;
}();
struct Cut {
int64_t h, w;
bool operator<(Cut other) const {
return make_tuple(h * w, h) < make_tuple(other.h * other.w, other.h);
}
};
int main() {
int h, w;
cin >> h >> w;
Cut ans{};
for (int64_t d = 1; d <= h; d *= 2) {
Cut c{d, min<int64_t>(d * 5 / 4, w)};
if (5 * c.w >= 4 * c.h && ans < c) ans = c;
}
for (int64_t d = 1; d <= w; d *= 2) {
Cut c{min<int64_t>(d * 5 / 4, h), d};
if (5 * c.h >= 4 * c.w && ans < c) ans = c;
}
cout << ans.h << ' ' << ans.w << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
long long h, w;
int g(long long a, long long b) {
if (5 * a < 4 * b) return -1;
if (4 * a <= 5 * b) return 0;
return 1;
}
int main() {
cin >> h >> w;
long long a = 1;
while (a * 2 <= h) a *= 2;
long long ansa = -inf, ansb = inf;
while (a) {
long long l = 1, r = inf * 1ll;
long long b = -1;
while (l <= r) {
long long mid = (l + r) / 2;
int p = g(a, mid);
if (p == -1) {
r = mid - 1;
} else if (p == 0) {
if (ansa * ansb < a * mid) {
if (mid <= w) {
ansa = a;
ansb = mid;
}
} else if (ansa * ansb == a * mid) {
if (mid > ansb && mid <= w) {
ansa = a;
ansb = mid;
}
}
if (mid <= w)
l = mid + 1;
else
r = mid - 1;
} else
l = mid + 1;
}
a /= 2;
}
long long b = 1;
while (b * 2 <= w) b *= 2;
while (b) {
long long l = 1, r = inf * 1ll;
long long a = -1;
while (l <= r) {
long long mid = (l + r) / 2;
int p = g(mid, b);
if (p == -1) {
l = mid + 1;
} else if (p == 0) {
if (ansa * ansb < mid * b) {
if (mid <= h) {
ansa = mid;
ansb = b;
}
} else if (ansa * ansb == mid * b) {
if (mid > ansa) {
if (mid <= h) {
ansa = mid;
ansb = b;
}
}
}
if (mid <= h) {
l = mid + 1;
} else
r = mid - 1;
} else
r = mid - 1;
}
b /= 2;
}
cout << ansa << " " << ansb << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, i, j, k, l, mn = 0, mx = 0, m, a, b;
cin >> a >> b;
m = 1;
while (m * 2 <= a && m * 2 <= b) m *= 2;
long long h = min(a, (long long)(1.25 * m));
long long w = min(b, (long long)(1.25 * m));
if (h >= w)
cout << h << " " << m << "\n";
else
cout << m << " " << w << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
void check(long long h, long long w, long long &hmax, long long &wmax, bool b) {
long long hnew = 1, wnew = 0;
while (hnew <= h) {
wnew = 0;
double w1 = hnew * 0.8, w2 = hnew * 1.25;
if (w >= w2)
wnew = w2;
else if (w <= w2 && w >= w1)
wnew = w;
if (hmax * wmax < hnew * wnew) {
hmax = hnew;
wmax = wnew;
} else if (hmax * wmax == hnew * wnew && hmax < hnew && b) {
hmax = hnew;
wmax = wnew;
} else if (hmax * wmax == hnew * wnew && wmax < wnew && !b) {
hmax = hnew;
wmax = wnew;
}
hnew *= 2;
}
}
int main() {
long long h, w;
cin >> h >> w;
long long hmax = 0, wmax = 0;
check(h, w, hmax, wmax, 1);
check(w, h, wmax, hmax, 0);
cout << hmax << " " << wmax << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int inf = 1 << 30;
const int INF = 0x3f3f3f3f;
long long h, w;
long long ah, aw;
long long high, wide;
int main() {
cin >> high >> wide;
int flag = 1;
for (int i = 0; 1 << i <= wide; ++i) {
w = 1 << i;
h = 1.25 * w;
if (h <= high) {
ah = h;
aw = w;
} else {
if (high * 4 <= 5 * w && 5 * high >= 4 * w) {
ah = high;
aw = w;
}
}
}
int nw, nh;
for (int i = 0; 1 << i <= high; ++i) {
h = 1 << i;
w = 1.25 * h;
if (w <= wide) {
nw = w;
nh = h;
} else {
if (4 * h <= 5 * wide && 5 * h >= 4 * wide) {
nw = wide;
nh = h;
}
}
}
if (1LL * nh * nw > 1LL * ah * aw)
cout << nh << ' ' << nw << endl;
else
cout << ah << ' ' << aw << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long f(int x) {
long long ans = 1;
while (ans <= x) {
ans *= 2;
}
return ans / 2;
}
int main() {
long long n, m;
while (~scanf("%lld%lld", &m, &n)) {
long long k = f(m);
long long t = k;
int flag = 0;
while (t > n * 1.25) {
t /= 2;
if (t < n * 0.8) {
flag = 1;
}
}
if (t < n * 0.8) flag = 1;
if (flag == 1) {
n = t * 1.25;
}
long long c = t * n;
long long q = f(n);
long long s = q * 5 / 4;
if (s > m) s = m;
long long d = q * s;
if (c > d)
printf("%lld %lld\n", t, n);
else if (c == d) {
if (t >= s)
printf("%lld %lld\n", t, n);
else
printf("%lld %lld\n", s, q);
} else
printf("%lld %lld\n", s, q);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mul(long long int a, long long int b) {
return ((a % int(1e9 + 7)) * (b % int(1e9 + 7))) % int(1e9 + 7);
}
long long int add(long long int a, long long int b) {
return ((a % int(1e9 + 7)) + (b % int(1e9 + 7))) % int(1e9 + 7);
}
long long int sub(long long int a, long long int b) {
long long int ans = ((a % int(1e9 + 7)) - (b % int(1e9 + 7))) % int(1e9 + 7);
ans %= int(1e9 + 7);
ans = (ans + int(1e9 + 7)) % int(1e9 + 7);
return ans;
}
long long int mpow(long long int a, long long int b) {
long long int ans = 1;
long long int po = a;
while (b != 0) {
if (b % 2) {
ans = ((ans % int(1e9 + 7)) * (po % int(1e9 + 7))) % int(1e9 + 7);
}
po = ((po % int(1e9 + 7)) * (po % int(1e9 + 7))) % int(1e9 + 7);
b /= 2;
}
return ans;
}
void solve() {
long long int h, w;
cin >> h >> w;
long long int ans = 0, ffh, ffw;
for (int i = 0; i < 2; i++) {
if (!i) swap(w, h);
if (!i) swap(ffw, ffh);
long long int fh = 1LL << (long long int)floor(log2(h) + 1e-6);
while (w < fh / 1.25) {
fh /= 2;
}
long long int fw = min(w, (long long int)(fh / .8 + 1e-6));
if (ans < fh * fw) {
ans = fh * fw;
ffh = fh;
ffw = fw;
} else if (ans == fh * fw) {
if (i == 1 and fh > ffh) {
ffh = fh;
ffw = fw;
} else if (i == 0 and fw > ffw) {
ffh = fh;
ffw = fw;
}
}
if (!i) {
swap(w, h);
swap(ffw, ffh);
}
}
cout << ffh << ' ' << ffw << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long w, h, cur = 2147483648;
bool f(string s) {
string a, b;
a.substr(0, s.size() / 2);
b.substr(s.size() / 2, s.size() / 2);
if (a == b) {
return 1;
} else
return 0;
}
int main() {
cin >> h >> w;
double wid = min(h, w);
while (wid < cur) {
cur *= 0.5;
}
wid = cur;
double hei = wid;
int mx = max(h, w);
while (((hei + 1) / wid) <= 1.25 && ((hei + 1) <= mx)) {
hei++;
}
if (wid > w || hei > h) {
int ad = wid;
wid = hei;
hei = ad;
}
cout << (int)hei << " " << (int)wid;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b;
long long ax = 0, ay = 0;
int main(void) {
scanf("%I64d%I64d", &a, &b);
for (long long i = 1; i <= a; i *= 2) {
long long j1 = (i * 4 + 4) / 5, j2 = (i * 5) / 4;
j2 = min(b, j2);
if (j2 < j1) continue;
if (ax * ay < i * j2 || (ax * ay == i * j2 && ax < i)) {
ax = i;
ay = j2;
}
}
for (long long j = 1; j <= b; j *= 2) {
long long i1 = (j * 4 + 4) / 5, i2 = (j * 5) / 4;
i2 = min(a, i2);
if (i2 < i1) continue;
if (ax * ay < i2 * j || (ax * ay == i2 * j && ax < i2)) {
ax = i2;
ay = j;
}
}
printf("%I64d %I64d\n", ax, ay);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1.0);
map<string, int> m;
set<string> s1[1501];
int max_size = -1000000007;
void DJ() {
int ho, wo, h, w, h1, w1, h2, w2, o = 0;
cin >> ho >> wo;
int x = 1;
while (x <= wo) {
if (x * 1.25 <= ho) {
h = floor(1.25 * x);
} else if (x * 0.8 <= ho)
h = ho;
else
break;
x *= 2;
}
h1 = h;
w1 = x / 2;
x = 1;
while (x <= ho) {
if (x * 1.25 <= wo)
w = floor(x * 1.25);
else if (x * 0.8 <= wo)
w = wo;
else
break;
x *= 2;
}
h2 = x / 2;
w2 = w;
if ((long long)h1 * w1 > (long long)h2 * w2) {
cout << h1 << " " << w1;
} else if ((long long)h1 * w1 < (long long)h2 * w2) {
cout << h2 << " " << w2;
} else {
if (h1 > h2)
cout << h1 << " " << w1;
else
cout << h2 << " " << w2;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) DJ();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int maxn = 1e6 + 10;
const int maxv = 1e3 + 10;
const double eps = 1e-9;
int main() {
long long h, w;
while (scanf("%lld%lld", &h, &w) != EOF) {
long long ans = 0;
long long ansl = 0;
for (long long ww = 1; ww <= w; ww <<= 1) {
long long hdi = ww * 4LL / 5LL + 1LL;
long long hgao = ww * 5LL / 4LL;
if (hdi > h || hgao < hdi) continue;
long long hh = min(h, hgao);
if (hh * ww >= ans) {
if (hh * ww == ans) {
ansl = max(ansl, hh);
} else {
ans = hh * ww;
ansl = hh;
}
}
}
for (long long hh = 1; hh <= h; hh <<= 1) {
long long wdi = hh * 4LL / 5LL + 1LL;
long long wgao = hh * 5LL / 4LL;
if (wdi > w || wdi > wgao) continue;
long long ww = min(w, wgao);
if (hh * ww >= ans) {
if (hh * ww == ans) {
ansl = max(ansl, hh);
} else {
ans = hh * ww;
ansl = hh;
}
}
}
printf("%lld %lld\n", ansl, ans / ansl);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<long long> st;
long long ans1 = 0, ans2 = 0;
void prepro() {
st.insert(0);
for (int i = 0; i <= 35; i++) {
st.insert(1ll << i);
}
}
void solve(long long a, long long b, bool fg) {
long long c, d, ta = a;
set<long long>::iterator it = st.lower_bound(a);
if (*it > a) ta = *(--it);
while (it != st.begin()) {
c = ceil(ta * 1.0 / 1.25);
d = floor(ta * 1.0 / 0.8);
for (long long i = min(b, d); i >= c; i--) {
if (i * ta < ans1 * ans2) break;
if (i >= 1.0 * ta / 1.25) {
if (!fg) {
if ((ta > ans1 && ans1 * ans2 == i * ta) || (ans1 * ans2 < i * ta)) {
ans1 = ta;
ans2 = i;
break;
}
} else {
if ((i > ans1 && ans1 * ans2 == i * ta) || (ans1 * ans2 < i * ta)) {
ans2 = ta, ans1 = i;
break;
}
}
}
}
it--;
ta = *it;
}
}
int main() {
long long h, w;
prepro();
cin >> h >> w;
solve(h, w, 0);
solve(w, h, 1);
cout << ans1 << ' ' << ans2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void solve(ll h, ll w, ll& best_area, ll& best_i, ll& best_j) {
for (ll i = 1; i <= h; i *= 2) {
ll j = min(w, 5 * i / 4);
if ((4 * i + 4) / 5 <= j and j <= 5 * i / 4 and i * j > best_area) {
best_area = i * j;
best_i = i;
best_j = j;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll h, w;
cin >> h >> w;
ll best_area = 0;
ll best_i = 0;
ll best_j = 0;
solve(w, h, best_area, best_j, best_i);
solve(h, w, best_area, best_i, best_j);
cout << best_i << " " << best_j << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mul(long long int a, long long int b) {
return ((a % int(1e9 + 7)) * (b % int(1e9 + 7))) % int(1e9 + 7);
}
long long int add(long long int a, long long int b) {
return ((a % int(1e9 + 7)) + (b % int(1e9 + 7))) % int(1e9 + 7);
}
long long int sub(long long int a, long long int b) {
long long int ans = ((a % int(1e9 + 7)) - (b % int(1e9 + 7))) % int(1e9 + 7);
ans %= int(1e9 + 7);
ans = (ans + int(1e9 + 7)) % int(1e9 + 7);
return ans;
}
long long int mpow(long long int a, long long int b) {
long long int ans = 1;
long long int po = a;
while (b != 0) {
if (b % 2) {
ans = ((ans % int(1e9 + 7)) * (po % int(1e9 + 7))) % int(1e9 + 7);
}
po = ((po % int(1e9 + 7)) * (po % int(1e9 + 7))) % int(1e9 + 7);
b /= 2;
}
return ans;
}
void solve() {
long long int h, w;
cin >> h >> w;
long long int ans = 0, ffh, ffw;
for (int i = 0; i < 2; i++) {
if (!i) swap(w, h);
if (!i) swap(ffw, ffh);
long long int ch, cw;
ch = 1;
while (ch <= h) {
if (1.25 * w < ch) {
break;
}
cw = min(w, (long long int)(ch / 0.8 + 1e-5));
if (ans < cw * ch) {
ans = cw * ch;
ffw = cw;
ffh = ch;
} else if (ans == cw * ch) {
if (i) {
if (ch > ffh) {
ffh = ch;
ffw = cw;
}
} else {
if (cw > ffw) {
ffh = ch;
ffw = cw;
}
}
}
ch *= 2;
}
if (!i) {
swap(w, h);
swap(ffw, ffh);
}
}
cout << ffh << ' ' << ffw << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
solve();
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
long long bw, bh;
void check(long long nw, long long nh) {
if (nw * nh > bw * bh || nw * nh == bw * bh && nw > bw) {
bw = nw;
bh = nh;
}
}
int main() {
long long w, h;
cin >> w >> h;
for (long long d = 1; d <= max(w, h); d *= 2) {
if (d <= w) {
if (d * 4 <= 5 * h) check(d, min((long long)(d * 1.25 + .1), h));
}
if (d <= h) {
if (d * 4 <= 5 * w) check(min((long long)(d * 1.25 + .1), w), d);
}
}
cout << bw << ' ' << bh << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long x, y;
cin >> x >> y;
vector<long long> v;
v.push_back(1);
for (long long i = 0; i < 31; i++) {
v.push_back(v[v.size() - 1] * 2);
}
long long a, b;
long long clx, cly;
a = lower_bound(v.begin(), v.end(), x) - v.begin();
b = lower_bound(v.begin(), v.end(), y) - v.begin();
for (long long i = a;; i--) {
if (v[i] <= x) {
clx = v[i];
break;
}
}
for (long long i = b;; i--) {
if (v[i] <= y) {
cly = v[i];
break;
}
}
long long h = -1, w = -1;
if (y >= clx) w = min(float(y), float(clx * 1.25));
if (x >= cly) h = min(float(x), float(cly * 1.25));
if ((h * cly) >= (clx * w))
cout << h << " " << cly << '\n';
else
cout << clx << " " << w << '\n';
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:36777216")
using namespace std;
void solve();
int main() {
ios::sync_with_stdio(0);
solve();
return 0;
}
const double KEps = 1.0E-8;
void solve() {
long long h, w;
cin >> h >> w;
long long bh = 0, bw = 0, bs = 0;
for (int pw = 0;; pw++) {
long long h2 = 1LL << pw;
if (h2 > h) break;
long long w2 = 0;
double c = (double)h2 / (double)w;
if (c > 0.8 - KEps && c < 1.25 + KEps) {
w2 = w;
} else if (c < 0.8 + KEps) {
w2 = (long long)((double)h2 / 0.8);
}
long long s2 = w2 * h2;
if (bs < s2) {
bh = h2;
bw = w2;
bs = s2;
} else if (bs == s2 && h2 > bh) {
bh = h2;
bw = w2;
bs = s2;
}
}
for (int pw = 0;; pw++) {
long long w2 = 1LL << pw;
if (w2 > w) break;
long long h2 = 0;
double c = (double)h / (double)w2;
if (c > 0.8 - KEps && c < 1.25 + KEps) {
h2 = h;
} else if (c > 1.25 - KEps) {
h2 = (long long)((double)w2 * 1.25);
}
long long s2 = w2 * h2;
if (bs < s2) {
bh = h2;
bw = w2;
bs = s2;
} else if (bs == s2 && h2 > bh) {
bh = h2;
bw = w2;
bs = s2;
}
}
cout << bh << ' ' << bw << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1005;
long long po[33], ansh, answ, ans;
void init() {
po[0] = 1;
for (int i = 1; i <= 30; i++) po[i] = po[i - 1] * 2;
}
void work(long long h, long long w) {
for (int i = 0; i <= 30; i++) {
if (po[i] > h) return;
if (po[i] * 8 > w * 10) return;
long long tempw = floor(po[i] * 1.25);
tempw = min(tempw, w);
long long rans = tempw * po[i];
if (rans > ans) {
ans = rans;
ansh = po[i];
answ = tempw;
} else if (rans == ans && po[i] >= ansh) {
ansh = po[i];
answ = tempw;
}
}
}
void exwork(long long h, long long w) {
for (int i = 0; i <= 30; i++) {
if (po[i] > h) return;
if (po[i] * 8 > w * 10) return;
long long tempw = floor(po[i] * 1.25);
tempw = min(tempw, w);
long long rans = tempw * po[i];
if (rans > ans) {
ans = rans;
ansh = tempw;
answ = po[i];
} else if (rans == ans && tempw >= ansh) {
ansh = tempw;
answ = po[i];
}
}
}
int main() {
init();
long long h, w;
scanf("%I64d%I64d", &h, &w);
ans = ansh = answ = 0;
work(h, w);
exwork(w, h);
printf("%I64d %I64d\n", ansh, answ);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int dl;
long long int sh;
cin >> dl;
cin >> sh;
long long int stdl;
long long int stsh;
long long int temp;
long long int dltp;
for (int i = 1; i <= dl && i <= sh * 1.25; i *= 2) stdl = i;
for (int i = 1; i <= sh && i <= dl * 1.25; i *= 2) stsh = i;
if (stdl == stsh) {
if (dl >= sh || (stdl * 1.25 <= dl && stsh * 1.25 <= sh)) {
temp = stsh;
dltp = stsh * 1.25;
while (temp < dltp && temp < dl) temp++;
cout << temp << " ";
cout << stsh;
} else {
temp = stdl;
dltp = stdl * 1.25;
while (temp < dltp && temp < sh) temp++;
cout << stdl << " ";
cout << temp;
}
} else {
if (stdl > stsh) {
cout << stdl << " ";
cout << sh;
} else {
cout << dl << " ";
cout << stsh;
}
}
cin >> dl;
}
|
#include <bits/stdc++.h>
using namespace std;
int T, t, n, k, a, m, maxn;
int tree[200010], x[200010];
bool vis[200010];
int lowbit(int x) { return x & (-x); }
void update(int x, int num) {
for (; x <= n; x += lowbit(x)) tree[x] += num;
}
int query(int x) {
int ret = 0;
for (; x > 0; x -= lowbit(x)) ret += tree[x];
return ret;
}
int fen1(int pos) {
int i, j, k, l, r, mi;
l = 1;
r = pos;
while (l < r) {
mi = (l + r) / 2;
if (query(pos) - query(mi - 1) == pos - mi + 1)
r = mi;
else
l = mi + 1;
}
return l;
}
int fen2(int pos) {
int i, j, k, l, r, mi;
l = pos;
r = n;
while (l < r) {
mi = (l + r + 1) / 2;
if (query(mi) - query(pos - 1) == mi - pos + 1)
l = mi;
else
r = mi - 1;
}
return l;
}
void solve() {
int i, j, l, r, len, len1, len2;
scanf("%d%d%d", &n, &k, &a);
maxn = (n + 1) / (a + 1);
scanf("%d", &m);
for (i = 1; i <= m; i++) scanf("%d", &x[i]);
for (i = 1; i <= n; i++) update(i, 1);
for (i = 1; i <= m; i++) {
if (vis[x[i]]) continue;
vis[x[i]] = 1;
l = fen1(x[i]);
r = fen2(x[i]);
update(x[i], -1);
len = r - l + 1;
len1 = x[i] - l;
len2 = r - x[i];
maxn = maxn - (len + 1) / (a + 1) + (len1 + 1) / (a + 1) +
(len2 + 1) / (a + 1);
if (maxn >= k)
continue;
else {
printf("%d\n", i);
return;
}
}
printf("-1\n");
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long n, m, k, a, tot;
set<long long> s;
long long seg(long long x) {
long long num = x / (a + 1);
if (x % (a + 1) == a) num++;
return num;
}
int main() {
cin >> n >> k >> a;
tot = seg(n);
s.insert(0);
s.insert(n + 1);
cin >> m;
long long c;
for (int i = 1; i <= m; i++) {
cin >> c;
s.insert(c);
set<long long>::iterator it = s.find(c), s = it, e = it;
s--;
e++;
tot -= seg(*e - *s - 1);
tot += seg(c - *s - 1) + seg(*e - c - 1);
if (tot < k) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
const long double PI = 2 * acos(0.0);
const long double eps = 1e-15;
const int infi = 1e9;
const long long Linfi = (long long)1e18;
const long long MOD = 1000000007;
const int c1 = 31;
const int c2 = 37;
const int maxn = 200005;
int n, k, a;
int m;
int x[maxn], xet[maxn];
set<pair<long long, long long> > S;
set<pair<long long, long long> >::iterator it;
void solve() {
S.insert(pair<long long, long long>(1, n));
S.insert(pair<long long, long long>(infi, infi));
int cnt = (n + 1) / (a + 1);
for (int i = 1; i <= m; i++) {
int pos = x[i];
if (xet[pos]) continue;
it = S.lower_bound(pair<long long, long long>(pos, 0));
if (it->first > pos) it--;
int u = it->first, v = it->second;
S.erase(it);
if (pos > u) {
S.insert(pair<long long, long long>(u, pos - 1));
cnt += (pos - u + 1) / (a + 1);
}
if (pos < v) {
S.insert(pair<long long, long long>(pos + 1, v));
cnt += (v - pos + 1) / (a + 1);
}
cnt -= (v - u + 2) / (a + 1);
if (cnt < k) {
cout << i << endl;
return;
}
xet[pos] = 1;
}
cout << -1 << endl;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> a;
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> x[i];
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m;
int f(int first, int second) {
int l = second - first - 1;
if (l <= 0) return 0;
return (l + 1) / (a + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> a >> m;
int ret = f(0, n + 1);
set<int> s;
s.insert(0);
s.insert(n + 1);
for (int fl = 0; fl < m; fl++) {
int i;
cin >> i;
s.insert(i);
set<int>::iterator it = s.find(i);
it--;
int p = *it;
it++;
it++;
int n = *it;
ret -= f(p, n);
ret += f(p, i);
ret += f(i, n);
if (ret < k) {
cout << fl + 1 << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > s;
const int maxn = 2e5 + 20;
int t[maxn];
int main() {
int n, k, a, m;
scanf("%d%d%d", &n, &k, &a);
int pos;
int cnt = (n + 1) / (a + 1);
scanf("%d", &m);
for (int i = 0; i < m; i++) scanf("%d", &t[i]);
s.insert(make_pair(1, n));
for (int i = 0; i < m; i++) {
int b = t[i];
set<pair<int, int> >::iterator it = s.lower_bound(make_pair(b, b));
if (it == s.end()) it--;
if ((it->second) < b) continue;
if ((it->first) > b) it--;
int c = (it->first);
int d = b - 1;
int e = b + 1;
int f = (it->second);
if (!(b >= c && b <= f)) continue;
cnt -= (2 + f - c) / (a + 1);
s.erase(it);
if ((d - c + 2) / (a + 1) > 0) {
cnt += (d - c + 2) / (a + 1);
s.insert(make_pair(c, d));
}
if ((f - e + 2) / (a + 1) > 0) {
cnt += (f - e + 2) / (a + 1);
s.insert(make_pair(e, f));
}
if (cnt < k) {
pos = i;
break;
}
}
if (cnt >= k)
printf("-1\n");
else
printf("%d\n", pos + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a;
int m;
int num[200005];
int Copy[200005];
int Ans(int pp) {
int ret = 0;
if (pp >= a) {
++ret;
pp -= a;
}
ret += pp / (a + 1);
return ret;
}
bool Check(int pp) {
std::copy(num, num + 1 + pp, Copy);
sort(Copy, Copy + pp + 1);
int ret = 0;
for (int i = 1; i <= pp; ++i) {
ret += Ans(Copy[i] - Copy[i - 1] - 1);
}
ret += Ans((num[m + 1] - Copy[pp]));
return ret >= k;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> a;
cin >> m;
for (int i = 1; i <= m; ++i) {
cin >> num[i];
}
int beg = 0, en = m + 1;
num[0] = 0;
num[m + 1] = n;
int last = 0x3f3f3f3f;
while (beg < en) {
int mid = beg + en >> 1;
if (Check(mid)) {
beg = mid + 1;
} else {
last = min(last, mid);
en = mid;
}
}
if (last != 0x3f3f3f3f)
cout << last << endl;
else
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, k, a;
cin >> n >> k >> a;
long n_moves;
cin >> n_moves;
set<pair<long, long> > s;
s.insert(make_pair(n, 1));
long max_ships = (n + 1) / (a + 1);
for (int i = 1; i <= n_moves; i++) {
long x;
cin >> x;
set<pair<long, long> >::iterator it = s.lower_bound(make_pair(x, -1));
long l = it->second;
long r = it->first;
max_ships -= (r - l + 2) / (a + 1);
if ((x - 1) >= l) {
max_ships += ((x - 1) - l + 2) / (a + 1);
}
if ((x + 1) <= r) {
max_ships += (r - (x + 1) + 2) / (a + 1);
}
if (max_ships < k) {
cout << i;
return 0;
}
s.erase(it);
if ((x - 1) >= l) s.insert(make_pair(x - 1, l));
if ((x + 1) <= r) s.insert(make_pair(r, x + 1));
}
cout << "-1";
return 0;
}
|
#include <bits/stdc++.h>
int cnt, a, k;
struct node {
int hit;
int height;
struct node *left, *right;
};
int height(struct node *node) {
if (node == NULL)
return 0;
else
return node->height;
}
struct node *leftRotate(struct node *node) {
struct node *tmp = node;
node = node->right;
tmp->right = node->left;
tmp->height =
1 + (height(tmp->left) > height(tmp->right) ? height(tmp->left)
: height(tmp->right));
node->left = tmp;
node->height =
1 + (height(node->left) > height(node->right) ? height(node->left)
: height(node->right));
return node;
}
struct node *rightRotate(struct node *node) {
struct node *tmp = node;
node = node->left;
tmp->left = node->right;
tmp->height =
1 + (height(tmp->left) > height(tmp->right) ? height(tmp->left)
: height(tmp->right));
node->right = tmp;
node->height =
1 + (height(node->left) > height(node->right) ? height(node->left)
: height(node->right));
return node;
}
struct node *insert(struct node *node, int hit, int down, int up) {
if (node == NULL) {
node = (struct node *)malloc(sizeof *node);
cnt -= (up - down) / (a + 1);
cnt += (up - hit) / (a + 1);
cnt += (hit - down) / (a + 1);
node->hit = hit;
node->height = 1;
node->left = NULL;
node->right = NULL;
return node;
}
if (node->hit < hit)
node->right = insert(node->right, hit, node->hit, up);
else
node->left = insert(node->left, hit, down, node->hit);
switch (height(node->right) - height(node->left)) {
case 2:
if (height(node->right->right) < height(node->right->left))
node->right = rightRotate(node->right);
node = leftRotate(node);
break;
case -2:
if (height(node->left->left) < height(node->left->right))
node->left = leftRotate(node->left);
node = rightRotate(node);
break;
default:
node->height =
1 + (height(node->left) > height(node->right) ? height(node->left)
: height(node->right));
}
return node;
}
void printTree(struct node *node) {
if (node == NULL) return;
printf("%i %i ", node->hit, node->height);
printTree(node->left);
printTree(node->right);
}
int main() {
int i, n, m, hit;
scanf("%d %d %d\n", &n, &k, &a);
scanf("%d\n", &m);
cnt = (n + 1) / (a + 1);
struct node *root = NULL;
for (i = 1; i <= m; i++) {
scanf("%d", &hit);
if (hit > n || hit < 1) continue;
root = insert(root, hit, 0, n + 1);
if (cnt < k) {
printf("%i\n", i);
return 0;
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> s;
set<int>::iterator it;
int n, k, a, now;
int m, x[200100];
int main() {
scanf("%d%d%d", &n, &k, &a);
a++;
scanf("%d", &m);
now = (n + 1) / a;
s.insert(0);
s.insert(n + 1);
for (int i = 1; i <= m; ++i) {
int x;
scanf("%d", &x);
it = s.lower_bound(x);
int r = (*it);
it--;
int l = (*it);
now -= (r - l) / a;
now += (x - l) / a + (r - x) / a;
if (now < k) {
printf("%d\n", i);
exit(0);
}
s.insert(x);
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = (3e5) + 10, mod = 1e9 + 7;
long long int n, k, a, m;
vector<long long int> v;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> a;
cin >> m;
for (long long int i = 1; i <= m; i++) {
long long int x;
cin >> x;
v.push_back(x);
}
long long int l = 0, r = m + 1;
while (r - l > 1) {
long long int mid = (l + r) / 2;
vector<long long int> v1;
v1.push_back(0);
for (long long int i = 0; i < mid; i++) v1.push_back(v[i]);
v1.push_back(n + 1);
sort(v1.begin(), v1.end());
long long int res = 0;
for (long long int i = 0; i < v1.size(); i++) {
if (i < v1.size() - 1 && v1[i + 1] - v1[i] - 1 >= a) {
res++;
res += max((v1[i + 1] - v1[i] - 1 - a) / (a + 1), (long long int)0);
}
}
if (res < k)
r = mid;
else
l = mid;
}
if (r == m + 1)
cout << -1 << endl;
else
cout << r << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a;
scanf("%d", &n);
scanf("%d", &k);
scanf("%d", &a);
int ans = 0;
int pos = 0;
pos = (n + 1) / (a + 1);
bool print = false;
if (pos < k) {
cout << ans;
print = true;
}
int m;
scanf("%d", &m);
set<int> vec;
set<int>::iterator it;
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
it = vec.lower_bound(x);
int sz = vec.size();
if (it == vec.end()) {
if (sz == 0) {
pos -= (n + 1) / (a + 1);
pos += (x) / (a + 1);
pos += (n - x + 1) / (a + 1);
vec.insert(x);
if (pos < k && print == false) {
cout << i + 1;
print = true;
}
} else {
int y = *vec.rbegin();
pos -= (n - y + 1) / (a + 1);
pos += (x - y) / (a + 1);
pos += (n - x + 1) / (a + 1);
vec.insert(x);
if (pos < k && print == false) {
cout << i + 1;
print = true;
}
}
} else {
if (it == vec.begin()) {
int y = *it;
pos -= y / (a + 1);
pos += x / (a + 1);
pos += (y - x) / (a + 1);
vec.insert(x);
if (pos < k && print == false) {
cout << i + 1;
print = true;
}
} else {
int y = *it;
int z = *(--it);
it++;
pos -= (y - z) / (a + 1);
pos += (x - z) / (a + 1);
pos += (y - x) / (a + 1);
vec.insert(x);
if (pos < k && print == false) {
cout << i + 1;
print = true;
}
}
}
}
if (print == false) cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int a;
struct AVL {
int s, e, n, h;
AVL *l, *r;
AVL(int _s, int _e) {
s = _s, e = _e;
int q = (e - s + 1) / (a + 1);
int rm = (e - s + 1) - q * (a + 1);
n = q;
if (rm == a) n++;
h = 1;
l = r = NULL;
}
};
int get_n(AVL *cur) {
if (!cur)
return 0;
else
return cur->n;
}
int get_h(AVL *cur) {
if (!cur)
return 0;
else
return cur->h;
}
int BF(AVL *cur) {
if (!cur)
return 0;
else
return get_h(cur->l) - get_h(cur->r);
}
void upd(AVL *cur) {
if (!cur) return;
int q = (cur->e - cur->s + 1) / (a + 1);
int r = (cur->e - cur->s + 1) - q * (a + 1);
if (r == a) q++;
cur->n = q + get_n(cur->l) + get_n(cur->r);
cur->h = 1 + max(get_h(cur->l), get_h(cur->r));
}
AVL *right_rot(AVL *Q) {
AVL *P = Q->l;
Q->l = P->r;
P->r = Q;
upd(Q);
upd(P);
return P;
}
AVL *left_rot(AVL *P) {
AVL *Q = P->r;
P->r = Q->l;
Q->l = P;
upd(P);
upd(Q);
return Q;
}
AVL *balance(AVL *cur) {
if (BF(cur) == 2) {
if (BF(cur->l) == -1) cur->l = left_rot(cur->l);
cur = right_rot(cur);
} else if (BF(cur) == -2) {
if (BF(cur->r) == 1) cur->r = right_rot(cur->r);
cur = left_rot(cur);
}
return cur;
}
AVL *insert(AVL *cur, int s, int e) {
if (!cur)
return new AVL(s, e);
else if (e < cur->s)
cur->l = insert(cur->l, s, e);
else if (cur->e < s)
cur->r = insert(cur->r, s, e);
upd(cur);
return balance(cur);
}
AVL *search(AVL *cur, int x) {
if (!cur) return NULL;
if (x < cur->s)
return search(cur->l, x);
else if (cur->e < x)
return search(cur->r, x);
else
return cur;
}
AVL *find_min(AVL *cur) {
if (!cur) return NULL;
while (cur->l) cur = cur->l;
return cur;
}
AVL *remove(AVL *cur, int s, int e, int x) {
if (!cur) return NULL;
if (e < cur->s)
cur->l = remove(cur->l, s, e, x);
else if (cur->e < s)
cur->r = remove(cur->r, s, e, x);
else {
int S = cur->s;
cur->s = x + 1;
cur->l = insert(cur->l, S, x - 1);
}
upd(cur);
return balance(cur);
}
int n, k, m;
int main() {
read_file();
while (scanf("%d %d %d\n", &n, &k, &a) != EOF) {
AVL *root = NULL;
root = insert(root, 1, n);
scanf("%d\n", &m);
int ans = -1;
for (int i = 0; i < m; i++) {
int x;
scanf("%d ", &x);
AVL *tmp = search(root, x);
root = remove(root, tmp->s, tmp->e, x);
int cur = get_n(root);
if (cur < k) {
ans = i + 1;
for (int j = i + 1; j < m; j++) scanf("%d ", &x);
break;
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &x) {
int q = 1;
char ch;
x = 0;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-'; ch = getchar())
;
if (ch == '-') ch = getchar(), q = -1;
for (; '0' <= ch && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
x *= q;
}
template <class T>
void write(T x) {
if (x < 0)
putchar('-'), write(-x);
else if (x < 10)
putchar(x + '0');
else
write(x / 10), putchar(x % 10 + '0');
}
int n, m, k, z, x;
inline int get_ships(int l, int r) { return ((r - l) / z); }
int main() {
read(n);
read(k);
read(z);
read(m);
z++;
set<int> st;
st.insert(0);
st.insert(n + 1);
int ships = (n + 1) / z;
for (int i = 0; i < m; i++) {
read(x);
st.insert(x);
int l = *(--st.lower_bound(x));
int r = *st.upper_bound(x);
ships = ships - get_ships(l, r) + get_ships(l, x) + get_ships(x, r);
if (ships < k) {
write(i + 1);
exit(0);
}
}
write(-1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, k, a, m;
int g[N];
void init() {
cin >> n >> k >> a;
cin >> m;
for (int i = 1; i <= m; i++) {
cin >> g[i];
}
}
bool check(int mid) {
static vector<int> obs;
obs.clear();
obs.push_back(0);
for (int i = 1; i <= mid; i++) {
obs.push_back(g[i]);
}
obs.push_back(n + 1);
sort(obs.begin(), obs.end());
obs.erase(unique(obs.begin(), obs.end()), obs.end());
int tmp = 0;
for (int i = 1; i < (int)obs.size(); i++) {
tmp += (obs[i] - obs[i - 1]) / (a + 1);
}
return tmp < k;
}
void work() {
int low = 0, high = m, ans = m + 1;
while (low <= high) {
int mid = (low + high) >> 1;
if (check(mid)) {
ans = min(ans, mid);
high = mid - 1;
} else {
low = mid + 1;
}
}
if (ans == m + 1) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
}
int main() {
ios::sync_with_stdio(false);
init(), work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> s;
set<int>::iterator it;
int n, k, a;
int GetNum(int x, int y) {
int len = y - x - 1;
return (len + 1) / (a + 1);
}
int main() {
scanf("%d%d%d", &n, &k, &a);
s.clear();
s.insert(0);
s.insert(n + 1);
int cnt = GetNum(0, n + 1);
int ans = -1;
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int mid;
scanf("%d", &mid);
if (s.find(mid) == s.end()) {
s.insert(mid);
it = s.find(mid);
int x = *(--it);
it++;
int y = *(++it);
int left = GetNum(x, mid);
int right = GetNum(mid, y);
int all = GetNum(x, y);
cnt -= (all - (left + right));
if (cnt < k) {
ans = i;
break;
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const int N = (int)2e5 + 7, mod = 1000000007, M = 2e9;
int n, k, a, m, node[N], cnt, t;
struct bit {
void update(int x) {
while (x <= n) {
node[x]++;
x += x & -x;
}
}
int get(int x) {
int c = 0;
while (x) {
c += node[x];
x -= x & -x;
}
return c;
}
int bs(int x) {
int st = 1, en = n + 1, mid;
while (st < en) {
mid = (st + en) >> 1;
if (get(mid) < x)
st = mid + 1;
else
en = mid;
}
return st;
}
bool insrt(int x) {
int w = get(x), y = bs(w), z = bs(w + 1) - 1, v = (z - y + 2) / a;
cnt -= v;
v = (z - x + 1) / a + (x - y + 1) / a;
cnt += v;
update(x);
update(x + 1);
return cnt < k;
}
} x;
int main() {
scanf("%d%d%d%d", &n, &k, &a, &m);
a++;
node[n + 1] = 2 * N;
cnt = (n + 1) / a;
for (int i = 1; i <= m; i++) {
scanf("%d", &t);
if (x.insrt(t)) {
cout << i;
return 0;
}
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m;
int calc(int n, int a) { return (n + 1) / (a + 1); }
int main() {
scanf("%d%d%d", &n, &k, &a);
scanf("%d", &m);
set<pair<int, int> > s;
set<pair<int, int> >::iterator it;
s.insert(make_pair(1, n));
int can = calc(n, a);
for (int x, i = 1; i <= m; ++i) {
scanf("%d", &x);
it = s.upper_bound(make_pair(x, 1e9));
--it;
can -= calc(it->second - it->first + 1, a);
pair<int, int> cur = *it;
s.erase(it);
if (cur.first != x) {
can += calc(x - cur.first, a);
s.insert(make_pair(cur.first, x - 1));
}
if (cur.second != x) {
can += calc(cur.second - x, a);
s.insert(make_pair(x + 1, cur.second));
}
if (can < k) {
printf("%d\n", i);
return 0;
}
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 1e7 + 9, M = 1e5 + 9, OO = 0x3f3f3f3f;
const double EPS = 1e-10;
inline int readi() {
int n;
scanf("%d", &n);
return n;
}
inline long long readll() {
long long n;
scanf("%I64d", &n);
return n;
}
inline char readc() {
char c;
scanf("%c ", &c);
return c;
}
inline double readd() {
double n;
scanf("%lf", &n);
return n;
}
inline bool dCMP(const long double& a, const long double& b) {
return fabsl(a - b) < EPS;
}
int n, k, a;
set<pair<int, int>> s;
int calc(int l, int r) { return (r - l + 2) / (a + 1); }
int main() {
n = readi();
k = readi();
a = readi();
int m = readi();
int maxs = calc(1, n);
s.emplace(n, 1);
for (int i = 0; i < m; ++i) {
int x = readi();
auto it = s.lower_bound({x, -1});
int r = it->first, l = it->second;
s.erase(it);
maxs -= calc(l, r);
maxs += calc(l, x - 1) + calc(x + 1, r);
s.emplace((x - 1), l);
s.emplace(r, (x + 1));
if (maxs < k) {
printf("%d\n", i + 1);
return 0;
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAXN = 2e5 + 4;
bool was[MAXN];
int a;
int cnt(int len) { return (len + 1) / (a + 1); }
set<pair<int, int> > st;
void solve() {
int n, k, m;
cin >> n >> k >> a >> m;
int sum = cnt(n);
st.insert(make_pair(1, n));
int x;
st.insert(make_pair(INF, INF));
for (int i = 0; i < m; i++) {
scanf("%d", &x);
if (was[x]) continue;
was[x] = 1;
if ((int)st.size() == 1) break;
set<pair<int, int> >::iterator it = st.upper_bound(make_pair(x, INF));
--it;
pair<int, int> cur = *it;
st.erase(cur);
sum -= cnt(cur.second - cur.first + 1);
if (cur.first == x) {
if (x + 1 <= cur.second) {
pair<int, int> to = make_pair(x + 1, cur.second);
sum += cnt(to.second - to.first + 1);
st.insert(to);
}
} else if (cur.second == x) {
pair<int, int> to = make_pair(cur.first, x - 1);
sum += cnt(to.second - to.first + 1);
st.insert(to);
} else {
pair<int, int> to1 = make_pair(cur.first, x - 1);
pair<int, int> to2 = make_pair(x + 1, cur.second);
sum += cnt(to1.second - to1.first + 1);
sum += cnt(to2.second - to2.first + 1);
st.insert(to1);
st.insert(to2);
}
if (sum < k) {
printf("%d", i + 1);
return;
}
}
printf("-1");
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int howMany(int n, int a, vector<pair<int, int> > &V, int bound) {
int last = 0;
int result = 0;
for (int i = 0; i < V.size(); ++i) {
if (V[i].second <= bound) {
result += (V[i].first - last) / (a + 1);
last = V[i].first;
}
}
result += (n + 1 - last) / (a + 1);
return result;
}
int main() {
int n, k, a;
cin >> n >> k >> a;
int m;
cin >> m;
vector<pair<int, int> > V(m);
for (int i = 0; i < m; ++i) {
cin >> V[i].first;
V[i].second = i;
}
sort(V.begin(), V.end());
int low = 0, up = m;
while (low < up) {
int mid = (low + up) / 2;
if (howMany(n, a, V, mid) >= k) {
low = mid + 1;
} else {
up = mid;
}
}
if (low == m)
cout << -1 << endl;
else
cout << low + 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mp[2000005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k, a;
cin >> n >> k >> a;
long long m;
cin >> m;
long long x[m + 5];
for (long long i = 0; i < m; i++) cin >> x[i];
long long l = 1;
long long r = m;
long long mid = (l + r) / 2;
long long ans = 1e+16;
while (l <= r) {
for (long long i = 0; i < mid; i++) {
mp[x[i]]++;
}
long long c = 0;
long long p = 0;
for (long long i = 1; i <= n; i++) {
if (mp[i] == 1) {
p = p + ((c + 1) / (a + 1));
c = 0;
} else {
c++;
}
mp[i] = 0;
}
p = p + ((c + 1) / (a + 1));
if (p >= k) {
l = mid + 1;
} else {
r = mid - 1;
ans = min(ans, mid);
}
mid = (l + r) / 2;
}
if (ans == 1e+16) {
cout << "-1" << endl;
} else {
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.14159265359;
const long long MOD = (long long)998244353ll;
const long long MAXN = (long long)2e5 + 10;
const long long INF = (long long)9223372036854775;
const long double EPS = (long double)1e-8;
set<long long> s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, a;
cin >> n >> k >> a;
long long p = (n + 1) / (a + 1);
s.insert(0);
s.insert(n + 1);
long long m;
cin >> m;
long long v;
long long up, dw;
for (int i = 1; i <= m; i++) {
cin >> v;
up = *s.upper_bound(v);
dw = *(--s.lower_bound(v));
p = p - ((up - dw) / (a + 1) - ((up - v) / (a + 1) + (v - dw) / (a + 1)));
if (p < k) return cout << i, 0;
s.insert(v);
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
const int maxn = 300000 + 10;
const long long INF = 1e9 + 7;
set<int> q;
set<int>::iterator it;
int nxt[maxn], ma[maxn];
inline void solve(void) {
int n, k, a;
cin >> n >> k >> a;
int m, x;
cin >> m;
q.insert(n);
nxt[n] = 1;
ma[n] = (n + 1) / (a + 1);
int sum = ma[n];
int ans = 1;
while (m--) {
cin >> x;
it = q.lower_bound(x);
int x1 = nxt[*it];
int y1 = *it;
int l = y1 - x1 + 1;
if (x1 == x) {
sum -= ((l + 1) / (a + 1));
int naya = (l / (a + 1));
if (sum + naya < k) {
cout << ans << endl;
return;
}
sum += naya;
if (y1 >= x1 + 1) nxt[y1] = x1 + 1;
} else if (y1 == x) {
sum -= ((l + 1) / (a + 1));
int naya = (l / (a + 1));
if (sum + naya < k) {
cout << ans << endl;
return;
}
sum += naya;
q.erase(y1);
if (y1 - 1 >= x1) q.insert(y1 - 1);
nxt[y1 - 1] = x1;
} else {
int l1 = x - x1;
int l2 = y1 - x;
sum -= ((l + 1) / (a + 1));
int naya = ((l1 + 1) / (a + 1)) + ((l2 + 1) / (a + 1));
if (sum + naya < k) {
cout << ans << endl;
return;
}
sum += naya;
q.insert(x - 1);
nxt[x - 1] = x1;
nxt[y1] = x + 1;
}
ans++;
}
cout << "-1\n";
return;
}
void init() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
}
int main(int argc, const char *argv[]) {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int n, m, k, a[MAXN], op;
bool vis[MAXN];
bool check(int x) {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= x; i++) {
vis[a[i]] = 1;
}
int last = 1, ans = 0;
for (int i = 1; i <= n; i++) {
if (vis[i]) {
continue;
}
int tmp = 1;
while (!vis[i + 1] && i + 1 <= n) {
i++;
tmp++;
}
ans += (tmp + 1) / (k + 1);
}
return ans < m;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
scanf("%d", &op);
for (int i = 1; i <= op; i++) {
scanf("%d", &a[i]);
}
int l = 1, r = op + 1;
while (l <= r) {
if (l > op) {
break;
}
int mid = (l + r) >> 1;
if (check(mid)) {
r = mid - 1;
} else {
l = mid + 1;
}
}
printf("%d\n", l > op ? -1 : l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m;
vector<int> hits;
int f(int s) {
if (s < a) return 0;
int times = (s - a) / (a + 1) + 1;
return times;
}
bool solve(int moves) {
if (moves == m + 1) return true;
vector<int> all;
for (int i = 0; i < moves; ++i) all.push_back(hits[i]);
sort(all.begin(), all.end());
int cnt = 0;
cnt += f(all[0] - 1);
cnt += f(n - all.back());
for (int i = 0; i < moves - 1; ++i) cnt += f(all[i + 1] - all[i] - 1);
return cnt >= k;
}
int main() {
cin >> n >> k >> a >> m;
hits.resize(m);
for (int i = 0; i < m; ++i) scanf("%d", &hits[i]);
int lo = 1, hi = m + 1, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (!solve(mid))
hi = mid;
else
lo = mid + 1;
}
if (lo == m + 1)
cout << "-1\n";
else
cout << lo << '\n';
};
|
#include <bits/stdc++.h>
using namespace std;
set<int> use;
int main() {
int n, k, a, m, cnt, low, up, temp = 0, x;
scanf("%d %d %d", &n, &k, &a);
scanf("%d", &m);
use.insert(0);
use.insert(n + 1);
cnt = (n + 1) / (a + 1);
set<int>::iterator it1;
while (temp < m) {
scanf("%d", &x);
temp++;
it1 = use.lower_bound(x);
up = *it1;
it1--;
low = *it1;
cnt = cnt - (up - low) / (a + 1) + (x - low) / (a + 1) + (up - x) / (a + 1);
if (cnt < k) {
printf("%d", temp);
return (0);
}
use.insert(x);
}
printf("-1");
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using ii = pair<lli, lli>;
int MOD = 1e9 + 7;
lli n, k, a;
set<ii> avail;
lli num = 0;
lli calc(lli x) { return (x + 1) / (a + 1); }
void add(int l, int r) {
avail.insert(make_pair(l, r));
num += calc(r - l + 1);
}
void remove(int l, int r) {
avail.erase(make_pair(l, r));
num -= calc(r - l + 1);
}
void solve() {
cin >> n >> k >> a;
add(1, n);
int q;
cin >> q;
int ans = -1;
for (int i = 0; i < q; i++) {
int x;
cin >> x;
auto it = avail.upper_bound(make_pair(x, MOD));
if (it == avail.begin()) {
continue;
}
it--;
int lo = it->first;
int hi = it->second;
if (x < lo || x > hi) continue;
remove(lo, hi);
if (x == lo) {
lo++;
if (lo <= hi) {
add(lo, hi);
}
} else if (x == hi) {
hi--;
if (lo <= hi) {
add(lo, hi);
}
} else {
add(lo, x - 1);
add(x + 1, hi);
}
if (ans == -1 && num < k) {
ans = i + 1;
}
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int calcularespacio(int SPacio, int taman) {
int ships = 0;
ships = (SPacio + 1) / (taman + 1);
return ships;
}
int main() {
int n, minships, taman;
int moves;
scanf("%d %d %d", &n, &minships, &taman);
scanf("%d", &moves);
vector<pair<int, int>> AvailableSpace;
AvailableSpace.push_back(pair<int, int>(1, n));
vector<int> Punteros = vector<int>(n + 1, 0);
int SpaceActual = calcularespacio(n, taman);
for (int m = 0; m < moves; m++) {
int temp;
scanf("%d", &temp);
int inicio = AvailableSpace[Punteros[temp]].first;
int sizeofSpace = AvailableSpace[Punteros[temp]].second;
SpaceActual -=
calcularespacio(AvailableSpace[Punteros[temp]].second, taman);
if (temp == inicio) {
AvailableSpace[Punteros[temp]].first += 1;
AvailableSpace[Punteros[temp]].second -= 1;
SpaceActual +=
calcularespacio(AvailableSpace[Punteros[temp]].second, taman);
} else {
if (temp == inicio + sizeofSpace - 1) {
AvailableSpace[Punteros[temp]].second -= 1;
SpaceActual +=
calcularespacio(AvailableSpace[Punteros[temp]].second, taman);
} else {
AvailableSpace[Punteros[temp]].second = temp - inicio;
AvailableSpace.push_back(
pair<int, int>(temp + 1, inicio + sizeofSpace - (temp + 1)));
for (int i = 0; i < inicio + sizeofSpace - (temp + 1); i++) {
Punteros[temp + 1 + i] = AvailableSpace.size() - 1;
}
SpaceActual +=
calcularespacio(AvailableSpace[Punteros[temp]].second, taman);
SpaceActual += calcularespacio(
AvailableSpace[AvailableSpace.size() - 1].second, taman);
}
}
if (SpaceActual < minships) {
printf("%d", m + 1);
return 0;
}
}
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
const int OO = 0x3f3f3f3f;
using namespace std;
void fast() { ios::sync_with_stdio(false), cin.tie(0), cout.tie(0); }
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
const int sizee = 2e5 + 5;
int N[sizee];
int J[sizee];
int n, k, a, m;
bool solve(int F) {
for (int i = 1; i <= F; i++) J[i] = N[i];
sort(J + 1, J + F + 1);
int var = 0;
J[0] = 1;
J[F + 1] = n;
for (int i = 1; i <= F + 1; i++) {
int temp = 0;
if (i == 1 || i == F + 1) {
temp = (J[i] - J[i - 1]);
} else {
temp = (J[i] - J[i - 1] - 1);
}
int H = temp / (a + 1);
if (temp % (a + 1) == a) {
++H;
}
var += H;
}
return var >= k;
}
int main() {
fast();
cin >> n >> k >> a >> m;
for (int i = 1; i <= m; i++) cin >> N[i];
int L = 1, R = m, mid, ans = 0;
while (L <= R) {
mid = (L + R) >> 1;
if (!solve(mid)) {
ans = mid;
R = mid - 1;
} else {
L = mid + 1;
}
}
if (!ans) {
cout << -1;
exit(0);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ships = 0, n, k, a, m;
set<pair<int, int> > xs;
int cal(int l, int r) { return (r - l + 2) / (a + 1); }
int main() {
cin >> n >> k >> a >> m;
xs.insert({n, 1});
ships = cal(1, n);
for (int i = 1; i <= m; i++) {
int x;
int newa = 0, newb = 0;
cin >> x;
auto it = xs.lower_bound({x, -1});
int l = it->second, r = it->first;
if (x - 1 >= l) newa = cal(l, x - 1);
if (x + 1 <= r) newb = cal(x + 1, r);
ships -= cal(l, r);
ships += newb + newa;
if (ships < k) {
cout << i << endl;
return 0;
}
xs.erase(it);
if (x - 1 >= l) xs.insert({x - 1, l});
if (x + 1 <= r) xs.insert({r, x + 1});
}
cout << -1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[100005];
int main() {
set<int> s;
int n, k, a, m, i, x;
cin >> n >> k >> a;
cin >> m;
s.insert(0);
s.insert(n + 1);
int cnt = (n + 1) / (a + 1);
for (i = 1; i <= m; i++) {
cin >> x;
set<int>::iterator it = s.upper_bound(x);
int r = *(it--);
int l = *it;
cnt -= ((r - l) / (a + 1) - (x - l) / (a + 1) - (r - x) / (a + 1));
if (cnt < k) {
cout << i << endl;
return 0;
}
s.insert(x);
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, k, m, cnt, ans, maxi, mini;
int num[200000 + 10];
int main() {
while (scanf("%d%d%d%d", &n, &k, &a, &m) == 4) {
ans = -1, cnt = 0;
for (int i = 1; i <= m; ++i) scanf("%d", &num[i]);
set<int> s;
s.insert(0), s.insert(n + 1);
cnt = (n + 1) / (a + 1);
for (int i = 1; i <= m; ++i) {
mini = *(--s.lower_bound(num[i]));
maxi = *s.upper_bound(num[i]);
cnt -= (maxi - mini) / (a + 1);
cnt += (maxi - num[i]) / (a + 1) + (num[i] - mini) / (a + 1);
s.insert(num[i]);
if (cnt < k) {
ans = i;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> st;
int x[200005];
int main() {
int n, k, a, m, i, cnt;
scanf("%d%d%d%d", &n, &k, &a, &m);
for (i = 0; i < m; i++) scanf("%d", &x[i]);
st.insert(0);
st.insert(n + 1);
cnt = (n + 1) / (a + 1);
for (i = 0; i < m; i++) {
int l = *(--st.lower_bound(x[i]));
int r = *st.lower_bound(x[i]);
cnt -= (r - l) / (a + 1) - (x[i] - l) / (a + 1) - (r - x[i]) / (a + 1);
if (cnt < k) {
printf("%d\n", i + 1);
break;
}
st.insert(x[i]);
}
if (i == m) puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000 + 10;
int n, k, a;
int m, q[MAXN];
set<int> s;
set<int>::iterator ite;
int main() {
cin >> n >> k >> a >> m;
for (int i = 0; i < m; i++) cin >> q[i];
s.insert(0);
s.insert(n + 1);
int maxShip = (n + 1) / (a + 1);
for (int i = 0; i < m; i++) {
ite = s.lower_bound(q[i]);
if (*ite == q[i]) continue;
int r = *ite, l = *(--ite), Before = (r - l) / (a + 1);
int chipL = (q[i] - l) / (a + 1), chipR = (r - q[i]) / (a + 1);
maxShip = maxShip - Before + chipL + chipR;
s.insert(q[i]);
if (maxShip < k) {
printf("%d\n", i + 1);
return 0;
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, i, l, m, t;
set<int> S;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> a;
cin >> m;
S.insert(0);
S.insert(++n);
t = n / ++a;
for (; cin >> n; i++) {
auto it = S.upper_bound(n);
m = *it, l = *(--it);
S.insert(n);
t += (n - l) / a + (m - n) / a - (m - l) / a;
if (t < k) return cout << ++i, 0;
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m;
set<pair<long long, long long> > xs;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> a >> m;
int ships = (n - 1 + 2) / (a + 1);
xs.insert(make_pair(n, 1));
for (long long i = 0; i < m; i++) {
int x;
cin >> x;
set<pair<long long, long long> >::iterator it =
xs.lower_bound(make_pair(x, -1));
int l = int(it->second);
int r = int(it->first);
int k1 = 0, k2 = 0;
if (x - 1 >= l) k1 = (x - 1 - l + 2) / (a + 1);
if (x + 1 <= r) k2 = (r - x - 1 + 2) / (a + 1);
ships -= (r - l + 2) / (a + 1);
ships += k1 + k2;
if (ships < k) {
cout << (i + 1);
return 0;
}
xs.erase(it);
if (x - 1 >= l) xs.insert(make_pair(x - 1, l));
if (x + 1 <= r) xs.insert(make_pair(r, x + 1));
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a;
int m;
int s[200010];
multiset<int> pos, len;
multiset<int>::iterator it, il, ir;
int main() {
scanf("%d%d%d", &n, &k, &a);
scanf("%d", &m);
pos.insert(0);
pos.insert(n + 1);
len.insert(n);
int cnt = (n + 1) / (a + 1);
int flag = -1;
for (int i = 0; i < m; i++) {
scanf("%d", &s[i]);
pos.insert(s[i]);
it = pos.find(s[i]);
il = ir = it;
il--;
ir++;
int l = *ir - *il - 1;
len.erase(len.find(l));
len.insert(*it - *il - 1);
len.insert(*ir - *it - 1);
cnt -= (l + 1) / (a + 1);
cnt += (*it - *il) / (a + 1);
cnt += (*ir - *it) / (a + 1);
if (flag == -1 && cnt < k) {
flag = i + 1;
}
}
printf("%d\n", flag);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) {
sum = (sum << 1) + (sum << 3) + (c ^ 48);
c = getchar();
}
return sum;
}
int n, k, a, m;
set<int> s;
set<int>::iterator it;
int main() {
n = read(), k = read(), a = read();
s.insert(0), s.insert(n + 1);
m = read();
int rest = (n + 1) / (a + 1);
if (rest < k) {
printf("0\n");
return 0;
}
for (int i = 1; i <= m; i++) {
int x = read();
it = s.lower_bound(x);
int a1 = *it;
it--;
int a2 = *it;
int dist = a1 - a2 - 1, dist1 = x - a2 - 1, dist2 = a1 - x - 1;
int b = (dist + 1) / (a + 1), b1 = (dist1 + 1) / (a + 1),
b2 = (dist2 + 1) / (a + 1);
rest -= (b - (b1 + b2));
if (rest < k) {
printf("%d\n", i);
return 0;
}
s.insert(x);
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const long long INF64 = 9e18;
const long double EPS = 1e-9;
const long double PI = 3.14159265358979310000;
const int N = 810000;
const int M = 104600;
int n, k, a, m;
struct tree {
int t[N];
tree() {
for (int i = 0; i < int(N); i++) t[i] = 0;
}
void update(int v, int tl, int tr, int num) {
if (tl == tr)
t[v] = 1;
else {
int tm = (tl + tr) / 2;
if (num <= tm)
update(v * 2, tl, tm, num);
else
update(v * 2 + 1, tm + 1, tr, num);
t[v] = t[v * 2] + t[v * 2 + 1];
}
}
int sum(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return t[v];
int tm = (tl + tr) / 2;
return sum(v * 2, tl, tm, l, min(r, tm)) +
sum(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
int left(int v, int tl, int tr, int num) {
if (tl == tr) return tl;
int tm = (tl + tr) / 2;
if (sum(1, 0, n, tm + 1, num) > 0)
return left(v * 2 + 1, tm + 1, tr, num);
else
return left(v * 2, tl, tm, num);
}
int right(int v, int tl, int tr, int num) {
if (tl == tr) return tl;
int tm = (tl + tr) / 2;
if (sum(1, 0, n, num, tm) > 0)
return right(v * 2, tl, tm, num);
else
return right(v * 2 + 1, tm + 1, tr, num);
}
} t;
int check(int first) {
int l, r, m;
l = 0;
r = n / a + 10;
while (r - l > 1) {
m = (l + r) / 2;
if (a * m + m - 1 <= first)
l = m;
else
r = m;
}
if (a * r + r - 1 <= first)
return r;
else
return l;
}
int main() {
int sum, first, second, w, tt = -1;
cin >> n >> k >> a;
n++;
t.update(1, 0, n, 0);
t.update(1, 0, n, n);
cin >> m;
sum = check(n - 1);
for (int u = 0; u < int(m); u++) {
scanf("%d", &w);
first = t.left(1, 0, n, w - 1);
second = t.right(1, 0, n, w + 1);
sum -= check(second - first - 1);
t.update(1, 0, n, w);
sum += check(w - first - 1) + check(second - w - 1);
if (sum < k) {
if (tt == -1) tt = u + 1;
}
}
cout << tt;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Segment {
int a, b;
Segment(int a, int b) {
this->a = a;
this->b = b;
};
bool operator<(const Segment &s2) const {
if (a != s2.a)
return a < s2.a;
else
return b < s2.b;
}
int size() { return b - a + 1; }
int max_ships(int aa) { return (size() + 1) / (aa + 1); }
};
int main() {
int n, k, a, m;
cin >> n >> k >> a >> m;
set<Segment> ships;
Segment init = Segment(1, n);
ships.insert(init);
int i = 0;
int move = -1;
int capacity = init.max_ships(a);
while (i < m && move == -1) {
int x;
cin >> x;
set<Segment>::iterator seg_it = ships.upper_bound(Segment(x, 99999999));
seg_it--;
if (seg_it != ships.end()) {
Segment seg = *seg_it;
if (x <= seg.b) {
ships.erase(seg_it);
capacity -= seg.max_ships(a);
if (x - 1 >= seg.a && x - 1 <= seg.b) {
Segment s1 = Segment(seg.a, x - 1);
if (s1.size() >= a) {
ships.insert(s1);
capacity += s1.max_ships(a);
}
}
if (x + 1 <= seg.b) {
Segment s2 = Segment(x + 1, seg.b);
if (s2.size() >= a) {
ships.insert(s2);
capacity += s2.max_ships(a);
}
}
}
}
if (capacity < k) {
move = i + 1;
}
i++;
}
if (move != -1) {
cout << move << endl;
} else {
cout << -1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m, cut[200007];
int L[200007], R[200007], S[200007], V[200007], sum[200007], IP, N, RT;
int ShipNumber(int length) { return (length + 1) / (a + 1); }
void Init() { L[0] = R[0] = S[0] = V[0] = IP = N = RT = 0; }
void PushUp(int &rt) {
S[rt] = S[L[rt]] + S[R[rt]] + 1;
sum[rt] = sum[L[rt]] + sum[R[rt]] + V[rt];
}
void zig(int &rt) {
int t = R[rt];
R[rt] = L[t];
L[t] = rt;
S[t] = S[rt];
S[rt] = S[L[rt]] + S[R[rt]] + 1;
sum[t] = sum[rt];
sum[rt] = sum[L[rt]] + sum[R[rt]] + V[rt];
rt = t;
}
void zag(int &rt) {
int t = L[rt];
L[rt] = R[t];
R[t] = rt;
S[t] = S[rt];
S[rt] = S[L[rt]] + S[R[rt]] + 1;
sum[t] = sum[rt];
sum[rt] = sum[L[rt]] + sum[R[rt]] + V[rt];
rt = t;
}
void maintain(int &rt) {
if (S[L[L[rt]]] > S[R[rt]]) {
zag(rt);
maintain(R[rt]);
maintain(rt);
return;
}
if (S[R[R[rt]]] > S[L[rt]]) {
zig(rt);
maintain(L[rt]);
maintain(rt);
return;
}
if (S[R[L[rt]]] > S[R[rt]]) {
zig(L[rt]);
zag(rt);
maintain(L[rt]);
maintain(R[rt]);
return;
}
if (S[L[R[rt]]] > S[L[rt]]) {
zag(R[rt]);
zig(rt);
maintain(L[rt]);
maintain(R[rt]);
return;
}
}
void InsertLeft(int &rt, int C) {
if (!rt) {
rt = ++IP;
sum[rt] = V[rt] = C;
L[rt] = R[rt] = 0;
S[rt] = 1;
return;
}
InsertLeft(L[rt], C);
sum[rt] += C;
++S[rt];
maintain(rt);
}
void Cut(int &rt, int C) {
if (C <= 0) return;
if (sum[L[rt]] + S[L[rt]] >= C) {
Cut(L[rt], C);
PushUp(rt);
maintain(rt);
return;
}
if (sum[L[rt]] + V[rt] + S[L[rt]] < C) {
Cut(R[rt], C - sum[L[rt]] - V[rt] - S[L[rt]] - 1);
PushUp(rt);
maintain(rt);
return;
}
C -= S[L[rt]] + sum[L[rt]];
N += ShipNumber(V[rt] - C) + ShipNumber(C - 1) - ShipNumber(V[rt]);
InsertLeft(R[rt], V[rt] - C);
V[rt] = C - 1;
PushUp(rt);
maintain(rt);
}
void show(int rt, bool end) {
if (S[L[rt]]) show(L[rt], false);
printf("%d ", V[rt]);
if (S[R[rt]]) show(R[rt], false);
if (end) printf("\n");
}
void Show(int rt) { show(rt, true); }
int main(void) {
while (~scanf("%d%d%d%d", &n, &k, &a, &m)) {
Init();
InsertLeft(RT, n);
int temp, ANS = -1;
N = ShipNumber(n);
for (int i = 0; i < m; ++i) scanf("%d", &cut[i]);
for (int i = 0; i < m; ++i) {
Cut(RT, cut[i]);
if (N < k) {
ANS = i + 1;
break;
}
}
printf("%d\n", ANS);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m;
int x[222222];
int ff[222222];
bool can(int pp) {
for (int i = 0; i <= n; ++i) ff[i] = 0;
for (int i = 0; i <= pp; ++i) ff[x[i]] = 1;
int cc = 0, cnt = 0;
for (int i = 1; i <= n; ++i) {
if (ff[i] == 1)
cc = 0;
else {
cc++;
if (cc == a) {
cc = -1;
cnt++;
}
}
}
return cnt >= k;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k >> a >> m;
for (int i = 0; i < m; ++i) cin >> x[i];
if (!can(0)) {
cout << "1\n";
return 0;
}
int ans = 0;
for (int s = 20; s >= 0; --s) {
if (ans + (1 << s) >= m) continue;
if (can(ans + (1 << s))) ans += (1 << s);
}
if (ans + 1 >= m) ans = -3;
cout << ans + 2 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> segs;
int main() {
int n, k, a;
scanf("%d %d %d", &n, &k, &a);
segs[0] = n;
int s = (n + 1) / (a + 1);
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
x--;
map<int, int>::iterator t = segs.upper_bound(x);
t--;
int l = t->second;
s -= (l + 1) / (a + 1);
int l1 = x - t->first;
int l2 = l - l1 - 1;
s += (l1 + 1) / (a + 1);
s += (l2 + 1) / (a + 1);
segs[t->first] = l1;
segs[x + 1] = l2;
if (s < k) {
printf("%d\n", i + 1);
return 0;
}
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> s;
int n, m, k, len, sum;
void init() { scanf("%d%d%d%d", &n, &k, &len, &m); }
inline int f(int x) { return (x + 1) / (len + 1); }
void solve() {
int sum = f(n);
s.clear();
s.insert(0), s.insert(n + 1);
int lie = -1;
for (int i = 1, x; i <= m; ++i) {
scanf("%d", &x);
int l = *(--s.lower_bound(x)), r = *s.lower_bound(x);
if (r == x) continue;
++l, --r;
sum -= f(r - l + 1), sum += f(x - l) + f(r - x), s.insert(x);
if (sum < k) {
lie = i;
break;
}
}
printf("%d\n", lie);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
bool ok(int t);
using namespace std;
int N, K, A, M, moves[200005];
int used[200005], b[200005], c[200005];
bool ok(int t) {
for (int i = 0; i < N; i++) used[i] = 0;
for (int i = 0; i < t; i++) used[moves[i]] = 1;
for (int i = 0; i < N; i++) {
if (i) used[i] += used[i - 1];
}
int placed = 0, u = 0, v = 0, w = 0;
for (int i = 0; i < N; i++) {
if (i + A - 1 < N && used[i + A - 1] == (i == 0 ? 0 : used[i - 1])) {
placed += 1, i += A;
}
}
return placed >= K;
}
int main() {
scanf("%d%d%d%d", &N, &K, &A, &M);
for (int i = 0; i < M; i++) scanf("%d", moves + i);
for (int i = 0; i < M; i++) --moves[i];
if (ok(M)) return printf("-1\n"), 0;
int lo = 0, hi = M;
while (hi - lo > 1) {
int mid = (hi + lo) / 2;
if (ok(mid))
lo = mid;
else
hi = mid;
}
printf("%d\n", hi);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = ((ans % m) * (a % m)) % m;
b /= 2;
a = ((a % m) * (a % m)) % m;
}
return ans % m;
}
const long double eps = 1e-10L;
long long n, k, a, m;
set<pair<long long, long long> > s;
long long move1[300005];
long long cal(long long l, long long r) { return (r - l + 2) / (a + 1); }
int main() {
cin >> n >> k >> a;
cin >> m;
s.insert(make_pair(n, 1));
long long sh = cal(1, n);
for (long long i = 1; i <= m; i++) {
cin >> move1[i];
}
long long sum = a;
for (long long i = 1; i <= m; i++) {
long long x = move1[i];
set<pair<long long, long long> >::iterator it =
s.lower_bound(make_pair(move1[i], -1));
long long l = it->second;
long long r = it->first;
long long ship1 = 0, ship2 = 0;
if (x - 1 >= l) {
ship1 += cal(l, x - 1);
s.insert(make_pair(x - 1, l));
}
if (r >= x + 1) {
ship2 += cal(x + 1, r);
s.insert(make_pair(r, x + 1));
}
s.erase(it);
sh += ship1 + ship2;
sh -= cal(l, r);
if (sh < k) {
cout << i;
return 0;
}
}
cout << "-1";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a;
int m;
int x;
int curr;
map<int, int> ma;
map<int, int>::iterator it1, it2;
inline int ans_len(int len) { return (len + 1) / (a + 1); }
int main() {
int i, sm_l, new_l, new_r, ans = -1;
scanf("%d%d%d", &n, &k, &a);
ma[0] = n;
ma[n + 1] = 0;
curr = ans_len(n);
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d", &x);
if (ans != -1) continue;
it2 = ma.upper_bound(x);
it1 = it2;
it1--;
sm_l = it1->second;
new_l = x - it1->first - 1;
new_r = it2->first - x - 1;
curr -= ans_len(sm_l);
curr += ans_len(new_l);
curr += ans_len(new_r);
ma[it1->first] = new_l;
ma[x] = new_r;
if (curr < k) ans = i;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000005;
int n, k, a, m;
int p[N];
int b[N];
bool check(int mid) {
for (int i = 1; i <= mid + 1; i++) {
b[i] = p[i - 1];
}
sort(b + 1, b + mid + 2);
b[0] = 0;
b[mid + 2] = n + 1;
int ans = 0;
for (int i = 1; i <= mid + 2; i++) {
ans += (b[i] - b[i - 1]) / (a + 1);
}
return ans >= k;
}
int solve() {
int l = 0;
int r = m;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid)) {
l = mid + 1;
} else {
r = mid;
}
}
if (l == m)
return -1;
else
return l + 1;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> a >> m;
for (int i = 0; i < m; ++i) cin >> p[i];
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m, x[200005];
int f(int p) {
int b[200005] = {0};
for (int i = 1; i <= p; i++) b[x[i]] = 1;
b[n + 1] = 1;
int ans = 0, z = 0;
for (int i = 1; i <= n + 1; i++) {
if (b[i] == 1) {
ans += (i - z) / (a + 1);
z = i;
}
}
return ans > k - 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> a >> m;
for (int i = 1; i <= m; i++) cin >> x[i];
int lo = 1, hi = m + 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (f(mid))
lo = mid + 1;
else
hi = mid - 1;
}
if (lo >= m + 1)
cout << "-1";
else
cout << lo;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2 * 1e5 + 1;
struct interval {
int le, ri;
interval() = default;
interval(int l, int r) : le(l), ri(r) {}
};
int n, k, a, m, x[maxN], curr, answer = -1;
set<interval> intervals;
bool operator<(interval a, interval b) { return a.le < b.le; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> a >> m;
intervals.insert(interval(0, n - 1));
set<interval>::iterator it;
int le = 0, ri = n - 1;
curr = (ri - le + 2) / (a + 1);
for (int i = 0; i < m; i++) {
cin >> x[i];
x[i]--;
if (answer != -1) continue;
it = intervals.upper_bound(interval(x[i], x[i] + 1));
it--;
le = it->le;
ri = it->ri;
intervals.erase(it);
if (x[i] != le) intervals.insert(interval(le, x[i] - 1));
if (x[i] != ri) intervals.insert(interval(x[i] + 1, ri));
curr -= (ri - le + 2) / (a + 1);
curr += (x[i] - 1 - le + 2) / (a + 1) + (ri - x[i] - 1 + 2) / (a + 1);
if (curr < k) answer = i + 1;
}
cout << answer << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m;
int ships(int left, int right) {
if ((right - left + 2) % (a + 1) == 0)
return ((right - left + 1) / (a + 1)) + 1;
else
return (right - left + 1) / (a + 1);
}
int main() {
cin >> n >> k >> a;
cin >> m;
int move;
map<int, int> mymap;
map<int, int>::iterator it, prv, nxt;
int currentSum = ships(1, n);
mymap.insert(pair<int, int>(0, currentSum));
int check_flag = 1;
if (currentSum < k) {
cout << 0 << endl;
check_flag = 0;
}
if (check_flag == 1) {
int temp;
for (int i = 0; i < m; ++i) {
cin >> move;
mymap.insert(pair<int, int>(move, 0));
it = mymap.find(move);
prv = prev(it);
temp = (prv->second);
prv->second = ships(prv->first + 1, move - 1);
currentSum = currentSum - temp + prv->second;
nxt = next(it);
if (nxt != mymap.end()) {
it->second = ships(move + 1, nxt->first - 1);
currentSum += it->second;
} else {
it->second = ships(move + 1, n);
currentSum += it->second;
}
if (currentSum < k) {
cout << check_flag << endl;
break;
}
check_flag++;
}
if (currentSum >= k) cout << "-1" << endl;
}
}
|
#include <bits/stdc++.h>
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
long long int gcd(long long int a, long long int b) {
return (a ? gcd(b % a, a) : b);
}
long long int modPow(long long int a, long long int b, long long int MOD) {
long long int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % MOD;
}
b /= 2;
y = (y * y) % MOD;
}
return x;
}
long long int modInverse(long long int a, long long int p) {
return modPow(a, p - 2, p);
}
using namespace std;
const int N = 2e5 + 5;
int arr[N];
int seq[N];
int n, k, a, m;
bool isPossible(int p) {
int i, j;
for (int i = 0; i < (n + 1); i++) seq[i] = 0;
for (int i = 0; i < (p); i++) seq[arr[i]]++;
for (int i = (1); i <= (n); i++) seq[i] += seq[i - 1];
int idx = 0;
int ctr = 0;
while (idx + a <= n && ctr < k) {
if (seq[idx] == seq[idx + a]) {
ctr++;
idx += a + 1;
} else
idx++;
}
return (ctr == k);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int hi, lo, mid, i, j, l, ans;
cin >> n >> k >> a;
cin >> m;
for (int i = (0); i <= (m - 1); i++) cin >> arr[i];
if (isPossible(m)) {
cout << "-1\n";
return 0;
}
lo = 0;
hi = m + 2;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (isPossible(mid)) {
ans = mid;
lo = mid + 1;
} else
hi = mid - 1;
}
cout << ans + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 * 2;
int L[maxn], R[maxn];
int A[maxn], P[maxn];
bool use[maxn];
int solve(int L, int R, int A) {
int l = 1, r = R - L - 1, ans = 0;
if (r <= A) return r / A;
while (l <= r) {
int mid = (l + r) >> 1;
if ((R - L - mid) / A >= mid) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
return ans;
}
int main() {
int n, k, a;
while (scanf("%d%d%d", &n, &k, &a) == 3) {
memset(use, false, sizeof(use));
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &A[i]);
P[i] = A[i];
}
A[0] = 0;
A[m + 1] = n + 1;
A[m + 2] = n + 2;
sort(A, A + m + 3);
int D = unique(A, A + m + 3) - A;
R[0] = A[1];
for (int i = 1; i < D; i++) {
L[A[i]] = A[i - 1];
R[A[i]] = A[i + 1];
}
int num = 0;
for (int i = 1; i < D; i++) {
num += solve(A[i - 1], A[i], a);
}
if (num >= k) {
puts("-1");
continue;
}
int f = 1;
for (int i = m; i > 0; i--) {
int d = P[i];
if (use[d]) {
continue;
}
use[d] = true;
int r1 = solve(L[d], d, a);
int r2 = solve(d, R[d], a);
num -= (r1 + r2);
num += solve(L[d], R[d], a);
R[L[d]] = R[d];
L[R[d]] = L[d];
if (num >= k) {
f = i;
break;
}
}
printf("%d\n", f);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, t;
const int N = 200009;
int tiros[N];
bool flag = 0;
map<int, int> m;
map<int, int>::iterator pos;
int main() {
scanf("%d %d %d", &n, &k, &a);
a++;
scanf("%d", &t);
for (int i = 0; i < t; ++i) {
scanf("%d", tiros + i);
tiros[i]--;
}
int cant = (n + 1) / a;
m[0] = n - 1;
int i;
for (i = 0; i < t; ++i) {
int curTiro = tiros[i];
pos = m.upper_bound(curTiro);
pos--;
pair<int, int> cur = *pos;
cant -= ((cur.second - cur.first) + 2) / a;
m.erase(pos);
if (curTiro == cur.first || curTiro == cur.second) {
pair<int, int> toAdd;
if (curTiro == cur.first) {
toAdd = make_pair(cur.first + 1, cur.second);
} else {
toAdd = make_pair(cur.first, cur.second - 1);
}
if (toAdd.second >= toAdd.first) {
cant += ((toAdd.second - toAdd.first) + 2) / a;
m.insert(toAdd);
}
} else {
pair<int, int> a1 = make_pair(cur.first, curTiro - 1);
pair<int, int> a2 = make_pair(curTiro + 1, cur.second);
if (a1.second >= a1.first) {
cant += ((a1.second - a1.first) + 2) / a;
m.insert(a1);
}
if (a2.second >= a2.first) {
cant += ((a2.second - a2.first) + 2) / a;
m.insert(a2);
}
}
if (cant < k) {
flag = 1;
break;
}
}
if (flag)
printf("%d", i + 1);
else
printf("-1");
return 0;
}
|
#include <bits/stdc++.h>
int dx[] = {0, 1, 0, -1, 1, -1, 1, -1, -2, 2, 0, 0},
dy[] = {1, 0, -1, 0, -1, 1, 1, -1, 0, 0, -2, 2};
using namespace std;
int n, k, a;
int avail;
int getAvail(pair<long long, long long> r) {
int len = r.second - r.first + 1;
return (len + 1) / (a + 1);
}
set<pair<long long, long long> > ss;
int main() {
ios_base::sync_with_stdio(false);
scanf("%d %d %d", &n, &k, &a);
ss.insert(make_pair(1, n));
avail = getAvail(make_pair(1, n));
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
auto it = ss.upper_bound(make_pair(x, INT_MAX));
it--;
pair<long long, long long> cur = *it;
if (x < cur.first || x > cur.second) continue;
avail -= getAvail(cur);
ss.erase(it);
pair<long long, long long> first = make_pair(cur.first, x - 1);
pair<long long, long long> second = make_pair(x + 1, cur.second);
int fg = getAvail(first);
int sg = getAvail(second);
avail += fg;
avail += sg;
ss.insert(first);
ss.insert(second);
if (avail < k) {
cout << i + 1;
exit(0);
}
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[300000] = {}, b[300000] = {}, n, m, k, a;
bool ok(int mid) {
for (int i = 0; i < n + 5; ++i) b[i] = 0;
for (int i = 1; i <= mid; ++i) b[arr[i]] = 1;
for (int i = 1; i <= n; ++i) b[i] += b[i - 1];
int x = 0;
for (int i = 1; i <= n - a + 1; ++i) {
if (b[i + a - 1] - b[i - 1] == 0) ++x, i += a;
}
return (x >= k ? 0 : 1);
}
int main() {
cin >> n >> k >> a >> m;
for (int i = 1; i <= m; ++i) cin >> arr[i];
int lo = 1, hi = m, mid = 0;
while (lo < hi) {
mid = (lo + hi) / 2;
if (ok(mid))
hi = mid;
else
lo = mid + 1;
}
if (lo == m)
cout << (ok(m) == 0 ? -1 : lo);
else
cout << lo;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, a, m, shot[((int)200003)];
bool noShip[((int)200003)];
bool k_ships(int limit) {
int ships = 0, last = 0, now = 0;
memset(noShip, 0, sizeof(noShip));
for (int i = 0; i <= limit; i++) noShip[shot[i]] = 1;
for (int i = 1; i <= n; i++, now++)
if (noShip[i]) {
ships += (i - last) / a;
last = i;
}
return (ships + (n + 1 - last) / a) >= k;
}
int lie_on() {
int left = 0, right = m - 1, middle;
while (left < right) {
middle = (left + right) >> 1;
if (k_ships(middle))
left = middle + 1;
else
right = middle - 1;
}
if (k_ships(left)) left++;
return left == m ? -2 : left;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> a >> m;
a++;
for (int i = 0; i < m; i++) cin >> shot[i];
cout << lie_on() + 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
const long long LINF = numeric_limits<long long>::max();
void solve() {
int n, k, a;
cin >> n >> k >> a;
int m;
cin >> m;
set<pair<int, int> > q;
q.insert(make_pair(n, 1));
int am;
if (n < a)
am = 0;
else
am = 1 + (n - a) / (a + 1);
for (int ans = 1; ans <= m; ++ans) {
int x;
cin >> x;
set<pair<int, int> >::iterator it = q.lower_bound(make_pair(x, 0));
int l = it->second, r = it->first;
int d = r - l + 2;
q.erase(it);
am -= d / (a + 1);
if (l <= x - 1) {
q.insert(make_pair(x - 1, l));
am += (x - l + 1) / (a + 1);
}
if (x + 1 <= r) {
q.insert(make_pair(r, x + 1));
am += (r - (x + 1) + 2) / (a + 1);
}
if (am < k) {
cout << ans;
return;
}
}
cout << -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
const int MOD = 1000000007;
const int MAX = 200005;
int arr[MAX];
using namespace std;
int main() {
int n, k, a;
scanf("%d %d %d", &n, &k, &a);
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d", &arr[i]);
};
int ct = (n + 1) / (a + 1);
set<pair<int, int> > s;
s.insert(make_pair(n, 1));
set<pair<int, int> >::iterator it;
for (int i = 0; i < m; i++) {
int q = arr[i];
it = s.lower_bound(make_pair(q, 1));
pair<int, int> ele = *it;
if (ele.first == ele.second) {
if (a == 1) {
ct--;
}
s.erase(ele);
if (ct < k) {
cout << i + 1 << endl;
return 0;
}
continue;
}
ct -= (ele.first - ele.second + 1 + 1) / (a + 1);
ct += (q - ele.second + 1) / (a + 1) + (ele.first - q + 1) / (a + 1);
s.erase(ele);
if (ct < k) {
cout << i + 1 << endl;
return 0;
}
s.insert(make_pair(ele.first, q + 1));
s.insert(make_pair(q - 1, ele.second));
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class TAT>
void read(TAT &a) {
static char cc;
static bool fff;
while (((cc = getchar()) < '0' || cc > '9') && cc != '-')
;
if (cc == '-')
a = 0, fff = 1;
else
a = cc - 48, fff = 0;
while ((cc = getchar()) >= '0' && cc <= '9') a = a * 10 + cc - 48;
if (fff) a = -a;
}
template <class TAT>
void write(TAT a) {
static char cc[25];
static int ct;
if (a == 0) {
putchar('0');
return;
}
if (a < 0) {
putchar('-');
return;
}
ct = 0;
while (a) cc[++ct] = a % 10 + 48, a /= 10;
while (ct) putchar(cc[ct--]);
}
void begin() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void end() {
fclose(stdin);
fclose(stdout);
}
const int maxn = 200005;
int n, K, A, m;
int Xu[maxn];
struct data {
int l, r;
data() {}
data(int ll, int rr) : l(ll), r(rr) {}
bool operator<(const data &b) const { return l < b.l; }
bool operator<=(const data &b) const { return l <= b.l; }
};
set<data> Set;
int res;
void Init() {
register int i, j, k;
read(K), read(n), read(A);
read(m);
for (i = 1; i <= m; ++i) read(Xu[i]);
}
void Solve() {
register int i, j, k;
register int l, r;
register set<data>::iterator it;
res = (K + 1) / (A + 1);
Set.insert(data(1, K));
for (i = 1; i <= m; ++i) {
it = Set.upper_bound(data(Xu[i], Xu[i]));
if (it == Set.begin()) continue;
it--;
if ((*it).r < Xu[i]) continue;
l = (*it).l, r = (*it).r;
Set.erase(it);
res -= (r - l + 2) / (A + 1);
if (Xu[i] > l) {
Set.insert(data(l, Xu[i] - 1));
res += (Xu[i] - 1 - l + 2) / (A + 1);
}
if (Xu[i] < r) {
Set.insert(data(Xu[i] + 1, r));
res += (r - Xu[i] - 1 + 2) / (A + 1);
}
if (res < n) {
write(i);
putchar('\n');
return;
}
}
puts("-1");
}
int main() {
Init();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, num;
int a[200010];
int vis[200010];
int judge(int mid) {
for (int i = 1; i <= n; i++) vis[i] = 0;
for (int i = 1; i <= mid; i++) {
vis[a[i]] = 1;
}
int sum = 0;
int ok = 0;
for (int i = 1; i <= n; i++) {
if (vis[i] == 1) {
ok = 0;
} else {
ok++;
if (ok >= num) {
ok -= num;
sum++;
i++;
}
}
}
return sum >= k;
}
int main() {
scanf("%d%d%d", &n, &k, &num);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
int l = 1, r = m;
while (l <= r) {
int mid = (l + r) / 2;
if (judge(mid)) {
l = mid + 1;
} else {
r = mid - 1;
}
}
if (l == m + 1)
printf("-1\n");
else
printf("%d\n", l);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.