text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
int n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<int, int> > data(n);
for (int i = 0; i < n; i++) {
cin >> data[i].first >> data[i].second;
}
sort(data.begin(), data.end());
vector<int> d(k);
for (int i = 0; i < k; i++) {
cin >> d[i];
}
sort(d.begin(), d.end());
d.push_back(s);
k++;
int l = 0, r = INF;
while (r - l > 1) {
int mid = (r + l) / 2;
int left = 0;
int time = 0;
bool fl = 0;
for (int i = 0; i < k; i++) {
int rast = d[i] - left;
int x = mid;
left = d[i];
if (x < rast) {
fl = 1;
break;
}
x -= rast;
if (rast <= x) {
time += rast;
} else {
time += x + (rast - x) * 2;
}
}
if (!fl && time <= t) {
r = mid;
} else {
l = mid;
}
}
for (int i = 0; i < n; i++) {
if (data[i].second >= r) {
cout << data[i].first << endl;
return 0;
}
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(0) * 2;
const double EPS = 1e-8;
const long long MOD = 1e9 + 7;
const int MAXN = 3e5 + 5;
const int oo = 1e9 + 5;
const double foo = 1e30;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcounll(s);
}
template <class T>
T sqr(T x) {
return x * x;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
int n, k, S, t, c[MAXN], v[MAXN], g[MAXN], pos[MAXN];
long long s[MAXN];
int main() {
scanf("%d%d%d%d", &n, &k, &S, &t);
for (int i = 0; i < n; i++) {
scanf("%d%d", &c[i], &v[i]);
}
for (int i = 0; i < k; i++) scanf("%d", &g[i]);
sort(g, g + k);
pos[0] = g[0];
for (int i = 0; i < k - 1; i++) {
pos[i + 1] = g[i + 1] - g[i];
}
pos[k] = S - g[k - 1];
sort(pos, pos + k + 1);
s[0] = pos[0];
for (int i = 1; i <= k; i++) {
s[i] = s[i - 1] + pos[i];
}
int ans = oo;
for (int i = 0; i < n; i++) {
if (v[i] < pos[k]) continue;
int can = v[i] / 2;
int now = upper_bound(pos, pos + k + 1, can) - pos;
now--;
long long tot;
if (~now)
tot = s[now] + (s[k] - s[now]) * 2ll;
else
tot = s[now];
int cur = upper_bound(pos, pos + k + 1, v[i]) - pos;
cur--;
long long mi = 0;
if (~cur) mi = s[cur];
if (~now) mi -= s[now];
int rem = cur - now;
long long has = (long long)rem * v[i] - mi;
tot -= has;
if (tot <= t) ans = min(ans, c[i]);
}
if (ans == oo)
puts("-1");
else
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, t, cost[200001], volume[200001];
const long long INF = 1000000001;
vector<int> dist;
bool can(long long mid) {
long long vol = mid;
long long time = 0;
for (int i = 1; i <= k + 1; i++) {
long long dis = dist[i] - dist[i - 1];
if (dis > vol)
return false;
else {
long long fast = min(dis, vol - dis);
long long slow = dis - fast;
time += slow * 2 + fast;
}
}
if (time > t)
return false;
else
return true;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) cin >> cost[i] >> volume[i];
dist.push_back(0);
dist.push_back(s);
for (int i = 1; i <= k; i++) {
long long a;
cin >> a;
dist.push_back(a);
}
sort(dist.begin(), dist.end());
int left = 0, right = INF;
long long ok = right;
while (left < right) {
long long mid = (left + right) / 2;
if (can(mid) == true) {
right = mid;
ok = mid;
} else {
left = mid + 1;
}
}
long long ans = 2 * INF;
bool answ = false;
for (int i = 0; i < n; i++) {
if (volume[i] >= ok) {
if (cost[i] < ans) {
ans = cost[i];
answ = true;
}
}
}
if (answ == false) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long k, t;
bool can(long long h, long long arr[]) {
long long dis = 0;
long long pre = 0;
long long pos = 0;
long long ans = 0;
for (int i = 0; i < k + 1; i++) {
long long two = 0;
long long ones = 0;
dis = arr[i] - pre;
pre = arr[i];
if (dis > h) {
return false;
}
if (dis * 2 > h) {
two = (2 * dis) - h;
ones = dis - two;
} else {
ones = dis;
}
ans += 2 * two + ones;
}
if (ans <= t) {
return true;
} else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, s;
cin >> n >> k >> s >> t;
long long maxi = -1;
long long mini = 2e9;
vector<pair<long long, long long>> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i].first;
;
cin >> arr[i].second;
maxi = max(maxi, arr[i].second);
mini = min(mini, arr[i].second);
}
long long pos[k + 1];
for (int i = 0; i < k; i++) {
cin >> pos[i];
}
pos[k] = s;
sort(pos, pos + k + 1);
long long left = mini - 1;
long long right = maxi + 1;
long long mid;
long long j = 7e10;
if (t < s) {
cout << -1 << endl;
return 0;
}
while (right - left > 1) {
mid = left + (right - left) / 2;
if (can(mid, pos)) {
right = mid;
j = mid;
} else {
left = mid;
}
}
long long answer = 7e10;
for (int i = 0; i < n; i++) {
if (arr[i].second >= j) {
answer = min(arr[i].first, answer);
}
}
if (answer == 7e10)
cout << -1 << endl;
else
cout << answer << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t, c[200001], v[200001], g[200001];
int cost(int dist, int x) {
if (dist * 2 <= x)
return dist;
else if (dist > x)
return t + 1;
else
return -x + dist + dist + dist;
}
bool can(int x) {
long long sum = cost(g[1], x);
for (int i = 2; i <= k; i++) sum += cost(g[i] - g[i - 1], x);
sum += cost(s - g[k], x);
return sum <= t;
}
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%d %d", &c[i], &v[i]);
for (int i = 1; i <= k; i++) scanf("%d", &g[i]);
sort(g + 1, g + 1 + k);
int s = 1, e = 1e9, ans = 1e9 + 1;
while (s <= e) {
int mid = (s + e) / 2;
if (can(mid))
ans = mid, e = mid - 1;
else
s = mid + 1;
}
int ret = 1e9 + 1;
for (int i = 1; i <= n; i++)
if (v[i] >= ans) ret = min(ret, c[i]);
if (ret == 1e9 + 1) ret = -1;
printf("%d", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, k;
long long s, t;
int g[maxn];
pair<int, int> a[maxn];
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first < b.first;
return a.second > b.second;
}
long long calc(long long v, long long d) {
long long x = v - d;
if (x < 0) return INT_MAX;
if (x >= d) return d;
return x + 2LL * (d - x);
}
long long check(long long v) {
long long ans = 0;
for (int i = 0; i <= k; i++) {
long long tmp = calc(v, g[i + 1] - g[i]);
if (tmp >= INT_MAX) return INT_MAX;
ans += tmp;
}
return ans;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].first, &a[i].second);
for (int i = 1; i <= k; i++) scanf("%d", &g[i]);
g[0] = 0;
sort(g + 1, g + 1 + k);
g[k + 1] = s;
sort(a + 1, a + 1 + n, cmp);
vector<pair<int, int> > vec;
vec.push_back(a[1]);
for (int i = 2; i <= n; i++) {
if (a[i].first != a[i - 1].first) vec.push_back(a[i]);
}
for (int i = 1; i < vec.size(); i++)
vec[i].second = max(vec[i - 1].second, vec[i].second);
int l = 0, r = vec.size() - 1;
while (l < r) {
int mid = (l + r) >> 1;
if (check(vec[mid].second) <= t)
r = mid;
else
l = mid + 1;
}
if (check(vec[r].second) <= t)
cout << vec[r].first << endl;
else
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MaxN = 3e5 + 10, inf = 2e9;
namespace IO {
char buf[1 << 15], *fs, *ft;
inline char getc() {
return (ft == fs &&
(ft = (fs = buf) + fread(buf, 1, 1 << 15, stdin), ft == fs))
? 0
: *fs++;
}
template <typename T>
inline void read(T &x) {
x = 0;
T f = 1, ch = getchar();
while (!isdigit(ch) && ch ^ '-') ch = getchar();
if (ch == '-') f = -1, ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
x *= f;
}
char Out[1 << 24], *fe = Out;
inline void flush() {
fwrite(Out, 1, fe - Out, stdout);
fe = Out;
}
template <typename T>
inline void write(T x, char str) {
if (!x) *fe++ = 48;
if (x < 0) *fe++ = '-', x = -x;
T num = 0, ch[20];
while (x) ch[++num] = x % 10 + 48, x /= 10;
while (num) *fe++ = ch[num--];
*fe++ = str;
}
} // namespace IO
using IO::read;
using IO::write;
template <typename T>
inline bool chkMin(T &a, const T &b) {
return a > b ? (a = b, true) : false;
}
template <typename T>
inline bool chkMax(T &a, const T &b) {
return a < b ? (a = b, true) : false;
}
template <typename T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
inline T max(T a, T b) {
return a > b ? a : b;
}
int n, k, s, t;
int c[MaxN], v[MaxN], d[MaxN];
inline bool check(int v) {
long long sum = 0;
for (int i = 1; i <= k; ++i) {
int s = d[i] - d[i - 1];
long long x = v - s, y = (s << 1) - v;
if (x < 0) return 0;
if (y < 0)
sum += s;
else
sum += x + (y << 1);
}
return sum <= t;
}
int main() {
read(n), read(k), read(s), read(t);
for (int i = 1; i <= n; ++i) read(c[i]), read(v[i]);
for (int i = 1; i <= k; ++i) read(d[i]);
d[++k] = s;
std::sort(d + 1, d + k + 1);
long long l = 0, r = inf, V = inf;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid - 1, V = mid;
else
l = mid + 1;
}
long long ans = inf;
for (int i = 1; i <= n; ++i)
if (v[i] >= V) chkMin(ans, (long long)c[i]);
write(ans == inf ? -1 : ans, '\n');
IO::flush();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int mxN = 200001;
int n, k, s, t;
pair<ll, ll> arr[mxN];
vector<ll> gas;
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> k >> s >> t;
ll a, b;
for (int i = 0; i < n; ++i) {
cin >> a >> b;
arr[i] = {a, b};
}
for (int i = 0; i < k; ++i) {
cin >> a;
gas.push_back(a);
}
sort(gas.begin(), gas.end());
int l = 0;
int r = 1e9 + 10;
while (l < r) {
int mid = l + (r - l) / 2;
int tt = 0;
int pos = 0;
bool ok = true;
for (int i = 0; i < k; ++i) {
if (gas[i] - pos > mid) {
ok = false;
break;
}
tt += 2 * (gas[i] - pos) - min(gas[i] - pos, mid - gas[i] + pos);
pos = gas[i];
}
if (s - pos > mid) ok = false;
tt += 2 * (s - pos) - min(s - pos, mid - s + pos);
if (ok && tt <= t) {
r = mid;
} else {
l = mid + 1;
}
}
ll ans = INF;
for (int i = 0; i < n; ++i) {
if (arr[i].second < l) continue;
ans = min(ans, arr[i].first);
}
if (ans == INF) {
cout << "-1\n";
} else {
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, nn, k, s, t, gas[200005];
pair<int, int> arr[200005];
vector<pair<int, int> > cars;
struct carsort {
bool operator()(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first == b.first) {
return a.second > b.second;
} else
return a.first < b.first;
}
};
bool func(int car) {
bool ret = true;
int cap = cars[car].second;
int tm = 0;
int prev = 0;
for (int i = 0; i < k; i++) {
int dist = gas[i] - prev;
if (dist > cap) {
ret = false;
break;
} else {
if (2 * dist <= cap) {
tm += dist;
} else {
tm += (cap - dist) + (2 * dist - cap) * 2;
}
}
prev = gas[i];
}
int dist = s - prev;
if (dist > cap) {
ret = false;
} else {
if (2 * dist <= cap) {
tm += dist;
} else {
tm += (cap - dist) + (2 * dist - cap) * 2;
}
}
if (tm > t) {
ret = false;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
}
for (int i = 0; i < k; i++) {
cin >> gas[i];
}
sort(arr, arr + n, carsort());
sort(gas, gas + k);
int maxv = -1;
for (int i = 0; i < n; i++) {
if (arr[i].second > maxv) {
cars.push_back(arr[i]);
maxv = arr[i].second;
}
}
nn = cars.size();
int l = 0;
int r = nn - 1;
int ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
bool val = func(mid);
if (val) {
if (l == r) {
ans = mid;
l = mid + 1;
break;
}
r = mid;
} else {
l = mid + 1;
}
}
if (ans == -1)
cout << ans;
else
cout << cars[ans].first;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[200005], b[200005], c[200005];
int main() {
int n, m, i, j, flag;
long long s, t, l, r, mid, tim, ans;
while (~scanf("%d%d%lld%lld", &n, &m, &s, &t)) {
for (i = 0; i < n; i++) scanf("%lld%lld", &c[i], &a[i]);
b[0] = 0;
b[m + 1] = s;
for (i = 1; i <= m; i++) scanf("%lld", &b[i]);
sort(b, b + m + 2);
l = 0;
r = s * 2;
while (l < r) {
tim = 0;
mid = (l + r) / 2;
flag = 0;
for (i = 0; i <= m; i++) {
if (mid >= 2 * (b[i + 1] - b[i]))
tim += b[i + 1] - b[i];
else if (mid >= (b[i + 1] - b[i]))
tim += mid - (b[i + 1] - b[i]) + (2 * (b[i + 1] - b[i]) - mid) * 2;
else {
flag = -1;
break;
}
}
if (tim > t || flag == -1)
l = mid + 1;
else
r = mid;
}
ans = 2000000001;
if (l != s * 2 || s <= t) {
for (i = 0; i < n; i++) {
if (a[i] >= l && c[i] < ans) ans = c[i];
}
}
if (ans == 2000000001) ans = -1;
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int g[200000 + 10], n, s, k, t;
void Read(int& x) {
char c;
while (c = getchar(), c != EOF) {
if (c >= '0' && c <= '9') {
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
ungetc(c, stdin);
return;
}
}
}
struct Car {
int v, c;
bool operator<(const Car& rhs) const { return v < rhs.v; }
} cars[200000 + 10];
bool check(int val) {
double ret = 0;
for (int i = 0; i <= k; i++) {
if (g[i + 1] - g[i] > val) return false;
ret += 2.0 * (g[i + 1] - g[i]);
int oth = val - g[i + 1] + g[i];
if (oth > g[i + 1] - g[i])
ret -= 1.0 * (g[i + 1] - g[i]);
else
ret -= 1.0 * oth;
}
return ret <= t;
}
int main() {
Read(n), Read(k), Read(s), Read(t);
for (int i = 1; i <= n; i++) Read(cars[i].c), Read(cars[i].v);
sort(cars + 1, cars + 1 + n);
for (int i = 1; i <= k; i++) Read(g[i]);
sort(g + 1, g + 1 + k);
g[k + 1] = s;
int l = 0, r = cars[n].v, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (ans == -1) {
printf("-1\n");
return 0;
}
int op = 0x3f3f3f3f;
for (int i = n; i >= 1; i--) {
if (cars[i].v < ans) break;
op = min(op, cars[i].c);
}
printf("%d\n", op);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct name {
long long c, v;
} car[200010];
long long n, k, s, t, g[200010], ans;
bool cmp(name a, name b) { return a.v < b.v; }
bool cek(int x) {
int anst = 0;
for (int i = 1; i <= k; i++) {
int a = g[i] - g[i - 1];
if (car[x].v >= a) {
anst += 2 * a;
if (car[x].v >= 2 * a) {
anst -= a;
} else {
anst -= (car[x].v - a);
}
} else
return false;
}
int a = s - g[k];
if (car[x].v >= a) {
anst += 2 * a;
if (car[x].v >= 2 * a) {
anst -= a;
} else {
anst -= (car[x].v - a);
}
} else
return false;
if (anst <= t) {
return true;
} else
return false;
}
void binser() {
int lo = 1, hi = n, mid;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (cek(mid)) {
ans = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ans = -1;
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) {
cin >> car[i].c >> car[i].v;
}
for (int i = 1; i <= k + 1; i++) {
cin >> g[i];
}
ans = -1;
sort(g + 1, g + k + 1);
sort(car + 1, car + n + 1, cmp);
binser();
if (ans == -1) {
cout << ans << endl;
return 0;
}
long long mins = 2e9;
for (int i = ans; i <= n; i++) {
mins = min(mins, car[i].c);
}
cout << mins << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, t;
long long c[200005], v[200005], g[200005];
bool C(long long vol) {
long long tt = 0;
for (long long i = 1; i <= k + 1; i++) {
if (vol < g[i] - g[i - 1])
return false;
else if (vol >= 2 * (g[i] - g[i - 1]))
tt += g[i] - g[i - 1];
else {
long long dis = (g[i] - g[i - 1]) * 2 - vol;
tt += g[i] - g[i - 1] + dis;
}
}
return tt <= t;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &k, &s, &t);
for (long long i = 1; i <= n; i++) scanf("%I64d%I64d", &c[i], &v[i]);
for (long long i = 1; i <= k; i++) scanf("%I64d", &g[i]);
sort(g + 1, g + 1 + k);
g[0] = 0;
g[k + 1] = s;
long long l = 1, r = 2 * 1000000000 + 1;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (C(mid))
r = mid;
else
l = mid;
}
long long ans = 2 * 1000000000 + 1;
for (long long i = 1; i <= n; i++)
if (v[i] >= r) ans = min(ans, c[i]);
if (ans == 2 * 1000000000 + 1)
puts("-1");
else
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
const long long LIM = 1e18;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double PI = atan(1.0) * 4;
int n, k;
long long s, t, c[N + 10], v[N + 10], g[N + 10];
int check(long long x) {
long long rec = 0;
int loc = 0;
for (int i = 1; i <= k; i++) {
long long len = g[i] - g[i - 1];
if (len > x) return 0;
long long c = min(x - len, len);
long long needt = len * 2 - c;
rec += needt;
if (rec > t) return 0;
}
return 1;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) cin >> c[i] >> v[i];
for (int i = 1; i <= k; i++) cin >> g[i];
sort(g + 1, g + 1 + k);
g[++k] = s;
g[0] = 0;
long long l = 1, r = 1e9 + 10;
while (l < r) {
long long mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
long long maxc = INF;
for (int i = 1; i <= n; i++)
if (v[i] >= l) maxc = min(maxc, c[i]);
cout << (maxc == INF ? -1 : maxc);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int g[MAXN];
int p[MAXN];
int c[MAXN];
int dis[MAXN];
int dis2[MAXN];
int ds[MAXN];
int main() {
int n, k, s, t;
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%d %d", p + i, c + i);
for (int i = 0; i < k; i++) scanf("%d", g + i);
sort(g, g + k);
for (int i = 0; i < k; i++) {
dis[i] = g[i];
if (i) dis[i] -= g[i - 1];
dis2[i] = 2 * dis[i];
}
dis[k] = s - g[k - 1];
dis2[k] = 2 * dis[k];
sort(dis, dis + k + 1);
sort(dis2, dis2 + k + 1);
ds[0] = dis[0];
for (int i = 1; i <= k; i++) ds[i] = dis[i] + ds[i - 1];
int mn = 1000000005;
for (int i = 0; i < n; i++) {
if (c[i] < dis[k]) continue;
long long save = 0;
int ind = upper_bound(dis2, dis2 + k + 1, c[i]) - dis2;
ind--;
if (ind >= 0) save += ds[ind];
int rem = k - ind;
int rest = ds[k];
if (ind >= 0) rest -= ds[ind];
save += rem * 1ll * c[i] - rest;
if (2 * s - save <= t) mn = min(mn, p[i]);
}
if (mn <= 1000000000)
printf("%d\n", mn);
else
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
struct car {
long long c, v;
} num[200005];
long long g[200005];
int cmp(car a, car b) {
if (a.c == b.c) return a.v > b.v;
return a.c < b.c;
}
long long check(long long a, long long k, long long t) {
long long time = 0;
for (long long i = 1; i <= k; i++) {
if (a < g[i] - g[i - 1]) return 0;
time += 2 * (g[i] - g[i - 1]);
time -= min(a - (g[i] - g[i - 1]), g[i] - g[i - 1]);
}
return time <= t;
}
long long binary(long long l, long long r, long long k, long long t) {
long long mid;
while (l <= r) {
mid = (l + r) / 2;
if (!check(mid, k, t)) {
l = mid + 1;
} else {
r = mid - 1;
}
}
return l;
}
int main() {
long long n, k, s, t, stal, star, flag, ans;
while (~scanf("%lld %lld %lld %lld", &n, &k, &s, &t)) {
flag = g[0] = 0;
for (int i = 0; i < n; i++) scanf("%lld %lld", &num[i].c, &num[i].v);
for (int i = 1; i <= k; i++) scanf("%lld", &g[i]);
sort(g, g + k + 1);
g[++k] = s;
sort(num, num + n, cmp);
ans = binary(1, 1e9, k, t);
for (int i = 0; i < n; i++) {
if (num[i].v >= ans) {
printf("%lld\n", num[i].c);
flag = 1;
break;
}
}
if (!flag) printf("-1\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7, INF = 0x3f3f3f3f;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long qpow(long long a, long long n) {
long long r = 1 % P;
for (a %= P; n; a = a * a % P, n >>= 1)
if (n & 1) r = r * a % P;
return r;
}
long long inv(long long first) {
return first <= 1 ? 1 : inv(P % first) * (P - P / first) % P;
}
const int N = 1e6 + 10;
int n, k, s, t;
int c[N], v[N], a[N], g[N];
int chk(int first) {
if (g[k] > first) return 0;
long long sum = 0;
for (int i = 1; i <= k; ++i) {
int p = min(g[i], first - g[i]);
sum += (long long)2 * g[i] - p;
}
return sum <= t;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
if (s > t) return puts("-1"), 0;
for (int i = 1; i <= n; ++i) scanf("%d%d", c + i, v + i);
for (int i = 1; i <= k; ++i) scanf("%d", a + i);
a[++k] = 0, a[++k] = s;
sort(a + 1, a + 1 + k);
for (int i = 2; i <= k; ++i) g[i - 1] = a[i] - a[i - 1];
--k;
sort(g + 1, g + 1 + k);
int l = 1, r = 1e9, ans = INF;
while (l <= r) {
if (chk(((l + r) >> 1)))
ans = ((l + r) >> 1), r = ((l + r) >> 1) - 1;
else
l = ((l + r) >> 1) + 1;
}
int mi = INF;
for (int i = 1; i <= n; ++i)
if (v[i] >= ans) mi = min(mi, c[i]);
printf("%d\n", mi == INF ? -1 : mi);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s, t, l, r, mid, ans;
int mincost;
int c[200005], v[200005], a[200005];
bool check(int x) {
int pos = 0;
int dqt = 0;
for (int i = 1; i <= m; ++i) {
int len = a[i] - pos;
if (x < len) return false;
int c1, c2 = x - len;
c2 = min(c2, len);
c1 = len - c2;
dqt += 2 * c1 + c2;
pos = a[i];
}
if (dqt <= t)
return true;
else
return false;
}
int main() {
scanf("%d%d%d%d", &n, &m, &s, &t);
for (int i = 1; i <= n; ++i) scanf("%d%d", &c[i], &v[i]);
for (int i = 1; i <= m; ++i) scanf("%d", &a[i]);
++m;
a[m] = s;
sort(a + 1, a + m + 1);
l = 0;
r = 1e9;
ans = -1;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (ans == -1) ans = 2e9;
mincost = 2e9;
for (int i = 1; i <= n; ++i)
if (v[i] >= ans) mincost = min(mincost, c[i]);
if (mincost == 2e9) mincost = -1;
printf("%d\n", mincost);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXQ = 200000;
const int MAXN = 200000;
typedef struct Q {
int p, cap;
} Q;
bool operator<(const Q &a, const Q &b) {
if (a.p != b.p) return a.p < b.p;
return a.cap >= b.cap;
}
int nq, n, s, t;
Q q[MAXQ];
int x[MAXN];
bool ok(int cap) {
int left = t;
for (int i = (0); i <= (n); ++i) {
long long d = (i == n ? s : x[i]) - (i == 0 ? 0 : x[i - 1]);
if (d > cap) return false;
long long need = 2 * d <= cap ? d : 3 * d - cap;
if (need > left)
return false;
else
left -= need;
}
return true;
}
void run() {
scanf("%d%d%d%d", &nq, &n, &s, &t);
for (int i = (0); i < (nq); ++i) scanf("%d%d", &q[i].p, &q[i].cap);
for (int i = (0); i < (n); ++i) scanf("%d", &x[i]);
sort(x, x + n);
{
sort(q, q + nq);
int m = 0;
for (int i = (0); i < (nq); ++i)
if (m == 0 || q[i].cap > q[m - 1].cap) q[m++] = q[i];
nq = m;
}
int l = -1, h = nq;
while (l + 1 < h) {
int m = l + (h - l) / 2;
if (ok(q[m].cap))
h = m;
else
l = m;
}
printf("%d\n", h == nq ? -1 : q[h].p);
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int calcTime(int vol, const vector<int>& deltas) {
int ans = 0;
for (int s : deltas) {
if (s > vol) {
return INT_MAX;
}
if (vol >= 2 * s) {
ans += s;
} else {
int add = vol - s;
ans += 2 * (s - add) + add;
}
}
return ans;
}
int main() {
cin.sync_with_stdio(0);
int n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<int, int> > cars(n);
for (int i = 0; i < n; i++) {
cin >> cars[i].second;
cin >> cars[i].first;
}
sort(cars.begin(), cars.end());
vector<pair<int, int> > cars2;
cars2.reserve(n);
for (int i = n - 1; i >= 0; i--) {
if (i > 0 && cars[i - 1].first == cars[i].first) {
continue;
}
if (cars2.size() > 0 && cars[i].second >= cars2.back().second) {
continue;
}
cars2.push_back(cars[i]);
}
reverse(cars2.begin(), cars2.end());
vector<int> fuel(k + 2);
for (int i = 0; i < k; i++) {
cin >> fuel[i];
}
fuel[k] = 0;
fuel[k + 1] = s;
sort(fuel.begin(), fuel.end());
vector<int> deltas(k + 1);
for (int i = 1; i < fuel.size(); i++) {
deltas[i - 1] = (fuel[i] - fuel[i - 1]);
}
sort(deltas.begin(), deltas.end());
n = cars2.size();
int a = -1;
int b = n - 1;
while (a < b - 1) {
int m = (a + b) / 2;
int testT = calcTime(cars2[m].first, deltas);
if (testT > t) {
a = m;
} else {
b = m;
}
}
if (b >= n || calcTime(cars2[b].first, deltas) > t) {
cout << -1 << endl;
return 0;
}
int bestV = cars2[b].first;
int bestCost = cars2[b].second;
for (int i = 0; i < n; i++) {
if (cars2[i].first >= bestV && cars2[i].second <= bestCost) {
bestCost = cars2[i].second;
}
}
cout << bestCost << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200100;
const int inf = 2000000000;
pair<int, int> v[MAX_N];
int g[MAX_N];
int main() {
ios::sync_with_stdio(false);
int n, k, s, t;
cin >> n >> k >> s >> t;
for (int i = 0; i < n; ++i) {
cin >> v[i].first >> v[i].second;
}
for (int i = 1; i <= k; ++i) {
cin >> g[i];
}
g[0] = 0;
g[k + 1] = s;
sort(g, g + k + 2);
vector<int> x;
for (int i = 1; i <= k + 1; ++i) {
int dx = g[i] - g[i - 1];
x.push_back(dx);
}
sort(x.begin(), x.end());
vector<int> sum(x.size());
sum[0] = x[0];
for (int i = 1; i < (int)x.size(); ++i) {
sum[i] = sum[i - 1] + x[i];
}
int ans = inf;
for (int i = 0; i < n; ++i) {
if (x.back() > v[i].second) {
continue;
}
long long res = 0;
int pos1 = upper_bound(x.begin(), x.end(), v[i].second / 2) - x.begin() - 1;
if (pos1 >= 0) {
res += sum[pos1];
}
int pos2 = upper_bound(x.begin(), x.end(), v[i].second) - x.begin() - 1;
if (pos2 >= 0 && x[pos2] > v[i].second / 2) {
res += 3LL * (sum[pos2] - (pos1 >= 0 ? sum[pos1] : 0)) -
(long long)v[i].second * (pos2 - pos1);
}
if (res <= t) {
ans = min(ans, v[i].first);
}
}
if (ans == inf) {
cout << -1;
} else {
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (1 << 30) - 1;
const long long linf = (1ll << 62) - 1;
int main() {
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<long long, long long>> cars(n);
for (auto &i : cars) {
scanf("%lld%lld", &i.first, &i.second);
}
vector<long long> g(k + 2);
g[0] = 0;
g[k + 1] = s;
for (int i = 1; i <= k; i++) {
scanf("%lld", &g[i]);
}
sort((g).begin(), (g).end());
k += 2;
long long l = 0, r = 1e10 + 100;
while (r - l > 1) {
long long m = (l + r) / 2;
long long total_time = 0;
for (int i = 0; i < k - 1; i++) {
if (m < g[i + 1] - g[i]) {
total_time = linf;
break;
}
total_time += g[i + 1] - g[i];
long long left = 2 * (g[i + 1] - g[i]) - m;
total_time += max(0LL, left);
}
if (total_time > t) {
l = m;
} else {
r = m;
}
}
long long min_cost = linf;
for (auto i : cars) {
if (i.second >= r) {
min_cost = min(min_cost, i.first);
}
}
if (min_cost >= linf) {
min_cost = -1;
}
cout << min_cost << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 222222, inf = 1111111111;
int n, k, s, t, a[max_n];
pair<int, int> p[max_n];
vector<pair<int, int> > v;
bool check(int v) {
int last = 0, res = 0;
for (int i = 0; i < k; ++i) {
int len2 = a[i] - last;
if (len2 > v) {
return false;
}
int o = v - len2;
int x = min(len2, o);
int len1 = x;
len2 -= x;
res += len2 * 2 + len1;
last = a[i];
}
return res <= t;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &p[i].second, &p[i].first);
}
for (int i = 0; i < k; ++i) {
scanf("%d", &a[i]);
}
a[k] = s;
++k;
sort(a, a + k);
sort(p, p + n);
int l = -1, r = n;
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(p[mid].first)) {
r = mid;
} else {
l = mid;
}
}
if (r == n) {
printf("-1\n");
return 0;
}
int ans = p[r].second;
for (int i = r; i < n; ++i) {
ans = min(ans, p[i].second);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
template <class T>
inline T isqrt(T k) {
T r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
template <class T>
inline T icbrt(T k) {
T r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
const int maxn = 200000 + 10;
int n, k, s, t;
int c[maxn];
int v[maxn];
int p[maxn];
long long calc(long long cap) {
long long res = 0;
for (int i = (1); i < (k + 2); i++) {
long long x = p[i] - p[i - 1];
long long a = max(0LL, 2 * x - cap);
if (a > x) return LINF;
res += x + a;
}
return res;
}
void solve() {
cin >> n >> k >> s >> t;
for (int i = (0); i < (n); i++) cin >> c[i] >> v[i];
p[0] = 0;
for (int i = (1); i < (k + 1); i++) cin >> p[i];
p[k + 1] = s;
sort(p, p + k + 2);
long long l = 1, r = LINF;
while (l < r) {
long long m = l + r >> 1;
if (calc(m) > t) {
l = m + 1;
} else {
r = m;
}
}
int ans = INF << 1;
for (int i = (0); i < (n); i++) {
if (v[i] >= l) {
chkmin(ans, c[i]);
}
}
if (ans == (INF << 1)) ans = -1;
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e18;
vector<long long> g;
long long go(long long x) {
long long res = 0;
for (int i = 1; i < g.size(); i++) {
long long len = g[i] - g[i - 1];
if (len > x) return INF;
long long slow = max(0ll, 2 * len - x);
res += len + slow;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
long long n, s, t, k;
cin >> n >> k >> s >> t;
vector<long long> c(n);
vector<long long> v(n);
for (int i = 0; i < n; i++) cin >> c[i] >> v[i];
g = {0, s};
for (int i = 0; i < k; i++) {
long long x;
cin >> x;
g.push_back(x);
}
long long lo = 0;
long long hi = INF;
sort(g.begin(), g.end());
long long res = INF;
while (hi - lo > 1) {
long long mid = (lo + hi) / 2;
if (go(mid) <= t)
hi = mid;
else
lo = mid;
}
for (int i = 0; i < n; i++) {
if (v[i] >= hi) res = min(res, c[i]);
}
if (res == INF) res = -1;
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int c[200100], v[200100], g[200100];
int n, k, s, t;
bool check(long long x) {
long long tt = 0;
for (int i = 1; i <= k + 1; i++) {
int dist = g[i] - g[i - 1];
if (x >= dist * 2) {
tt += dist;
} else if (x >= dist) {
tt += (x - dist) + (dist - x + dist) * 2;
} else
return false;
}
return tt <= t;
}
int main() {
n = read();
k = read();
s = read();
t = read();
for (int i = 1; i <= n; i++) {
c[i] = read();
v[i] = read();
}
for (int i = 1; i <= k; i++) g[i] = read();
sort(g + 1, g + 1 + k);
g[k + 1] = s;
long long l = 1, r = 2e9, mid;
while (l + 5 < r) {
mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid;
}
int lb = l;
for (int i = l; i <= r; i++) {
if (check(i)) {
lb = i;
break;
}
}
long long mn = 2e9;
for (int i = 1; i <= n; i++) {
if (v[i] >= lb) mn = min(mn, 1ll * c[i]);
}
if (mn == 2e9) mn = -1;
cout << mn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 1;
long long g[N];
int car[N][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k, s, t;
cin >> n >> k >> s >> t;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 2; ++j) {
cin >> car[i][j];
}
}
for (int i = 0; i < k; ++i) {
cin >> g[i];
}
sort(g, g + k);
g[k] = s - g[k - 1];
for (int i = k - 1; i > 0; --i) {
g[i] -= g[i - 1];
}
int lo = *max_element(g, g + k + 1);
int hi = INT_MAX;
while (lo < hi) {
int v = lo + (hi - lo) / 2;
long long need = 0;
for (int i = 0; i <= k; ++i) {
need += max(g[i], 3 * g[i] - v);
}
if (need <= t) {
hi = v;
} else {
lo = v + 1;
}
}
int ans = INT_MAX;
for (int i = 0; i < n; ++i) {
if (car[i][1] >= lo) {
ans = min(ans, car[i][0]);
}
}
cout << (ans == INT_MAX ? -1 : ans) << "\n";
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:60777216")
using namespace std;
int n, k, s, t;
int c[222222];
int v[222222];
int x[222222];
bool good(long long V) {
long long tt = 0;
for (int i = (1); i < (k); i++) {
int d = x[i] - x[i - 1];
if (d > V) return 0;
int diff = V - d;
tt += 2 * d;
tt -= min(d, diff);
}
return tt <= t;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = (0); i < (n); i++) scanf("%d %d", c + i, v + i);
for (int i = (0); i < (k); i++) scanf("%d", x + i + 1);
k++;
x[k] = s;
k++;
sort(x, x + k);
long long best = -1;
long long from = 0, to = s;
while (from <= to) {
long long m = (from + to) / 2;
if (good(m))
best = m, to = m - 1;
else
from = m + 1;
}
if (best == -1) {
puts("-1");
return 0;
}
int res = 2e9;
for (int i = (0); i < (n); i++)
if (v[i] >= best) res = min(res, c[i]);
if (res == 2e9)
puts("-1");
else
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int c[maxn], v[maxn];
int g[maxn];
vector<int> dist;
long long pdist[maxn];
int main() {
int n, k;
long long s, t;
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
scanf("%d%d", &c[i], &v[i]);
}
for (int i = 0; i < k; i++) {
scanf("%d", &g[i]);
}
sort(g, g + k);
dist.push_back(g[0] - 0);
for (int i = 1; i < k; i++) {
dist.push_back(g[i] - g[i - 1]);
}
dist.push_back(s - g[k - 1]);
sort(dist.begin(), dist.end());
pdist[0] = dist[0];
for (int i = 1; i < dist.size(); i++) pdist[i] = pdist[i - 1] + dist[i];
long long ans = 1e15;
for (int i = 0; i < n; i++) {
int in =
lower_bound(dist.begin(), dist.end(), v[i] / 2 + 1) - dist.begin() - 1;
if (dist[(dist.size() - 1)] > v[i]) continue;
long long time = pdist[in] + 3 * (s - pdist[in]) -
(long long)((int)dist.size() - in - 1) * v[i];
if (time <= t) {
if (c[i] < ans) ans = c[i];
}
}
if (ans > (long long)(1e10)) {
cout << -1;
return 0;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long start, endi, cars, stations, street, time_, station, max_distance,
ans;
pair<long long, long long> cn;
vector<pair<long long, long long> > myvec;
vector<long long> spaces, store;
bool can(long long fuel) {
long long check = 0;
for (long long i = 0; i < spaces.size(); i++) {
check += min(fuel - spaces[i], spaces[i]);
if (fuel < 0) return 0;
check += (spaces[i] - (min(fuel - spaces[i], spaces[i]))) * 2;
}
if (check <= time_) {
return 1;
} else
return 0;
}
void binary(long long mid) {
if (start > endi) return;
if (can(mid)) {
endi = mid - 1;
ans = mid;
} else {
start = mid + 1;
}
binary((start + endi) / 2);
}
int main() {
scanf("%lld %lld %lld %lld", &cars, &stations, &street, &time_);
for (long long i = 0; i < cars; i++) {
scanf("%lld %lld", &cn.first, &cn.second);
myvec.push_back(cn);
}
sort(myvec.begin(), myvec.end());
for (long long i = cars - 2; i >= 0; i--) {
myvec[i].first = min(myvec[i + 1].first, myvec[i].first);
}
store.push_back(0);
store.push_back(street);
for (long long i = 0; i < stations; i++) {
scanf("%lld", &station);
store.push_back(station);
}
sort(store.begin(), store.end());
for (long long i = 1; i < store.size(); i++) {
long long distance = store[i] - store[i - 1];
spaces.push_back(distance);
max_distance = max(max_distance, distance);
}
start = max_distance;
endi = street;
binary((start + endi) / 2);
if (ans == 0) {
printf("-1\n");
return 0;
} else {
for (int i = 0; i < myvec.size(); i++) {
if (ans <= myvec[i].second) {
printf("%lld", myvec[i].first);
return 0;
}
}
}
printf("-1\n");
}
|
#include <bits/stdc++.h>
using namespace std;
int Set(int n, int pos) { return n = n | (1 << pos); }
int reset(int n, int pos) { return n = n & ~(1 << pos); }
bool check(int n, int pos) { return (bool)(n & (1 << pos)); }
long long int power(long long int x, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0) {
long long int y = power(x, n / 2);
return y * y;
} else
return x * power(x, n - 1);
}
int strTOint(string s) {
stringstream second;
int x;
second << s;
second >> x;
return x;
}
double geo_dist(int a, int b, int c, int d) {
double dd = (double)(a - c) * (a - c) + (b - d) * (b - d);
double r = sqrt(dd) + 1e-9;
return r;
}
long long int bigmod(long long int a, long long int p, long long int m) {
if (p == 0) return 1 % m;
if (p % 2 == 0) {
long long int y = bigmod(a, p / 2, m);
return (y * y) % m;
} else {
return (a * bigmod(a, p - 1, m)) % m;
}
}
long long int x, y, d, g;
void ext_gcd(long long int a, long long int b) {
if (b == 0) {
x = 1;
y = 0;
d = a;
return;
}
ext_gcd(b, a % b);
long long int x1 = y;
long long int y1 = x - (a / b) * y;
x = x1;
y = y1;
}
long long int modInv(long long int a, long long int m) {
ext_gcd(a, m);
x %= m;
if (x < 0) x += m;
return x;
}
vector<int> num;
void input(string s) {
istringstream second(s);
int n;
while (second >> n) {
num.push_back(n);
}
}
int fx[] = {0, 0, -1, 1, -1, 1, 1, -1};
int fy[] = {1, -1, 0, 0, 1, 1, -1, -1};
map<string, int> mp;
vector<long long int> dist;
pair<long long int, long long int> cost[200010], cap[200010];
long long int gas[200010];
long long int n, k, s, t, len;
long long int func(long long int j) {
long long int ans = 0;
for (long long int i = 0; i < len; i++) {
long long int temp = cap[j].first / dist[i];
long long int m = cap[j].first % dist[i];
if (temp >= 2)
ans += dist[i];
else if (temp == 1) {
if (m == 0)
ans += (dist[i] * 2);
else {
long long int res = (temp + 1) * dist[i];
long long int p = res - cap[j].first;
long long int q = dist[i] - p;
p *= 2;
ans += (p + q);
}
} else
return -1;
}
return ans;
}
int binary() {
long long int low = 0, high = n - 1;
long long int mid;
while (high - low > 5) {
mid = (low + high) / 2;
long long int khoroch = func(mid);
if (khoroch > t || khoroch == -1)
low = mid;
else
high = mid;
}
for (long long int i = low; i <= high; i++) {
long long int khoroch = func(i);
if (khoroch != -1 && khoroch <= t) return i;
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
while (cin >> n >> k >> s >> t) {
dist.clear();
for (long long int i = 0; i < n; i++) {
cin >> cost[i].first >> cost[i].second;
cap[i].first = cost[i].second;
cap[i].second = cost[i].first;
}
sort(cap, cap + n);
for (long long int i = 0; i < k; i++) {
cin >> gas[i];
}
sort(gas, gas + k);
long long int prev = 0;
for (long long int i = 0; i < k; i++) {
dist.push_back(gas[i] - prev);
prev = gas[i];
}
dist.push_back(s - prev);
len = dist.size();
long long int in = binary();
if (in == -1) {
cout << -1 << endl;
continue;
}
long long int ans = 1e18;
for (long long int i = in; i < n; i++) {
if (cap[i].second <= ans) ans = cap[i].second;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXK = 2 * 1e5 + 2;
const int MXN = 2 * 1e5 + 2;
long long N, K, S, T;
int G[MXK] = {};
pair<long long, long long> A[MXN] = {};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> K >> S >> T;
for (int x = 0; x < N; x++) cin >> A[x].first >> A[x].second;
for (int x = 0; x < K; x++) cin >> G[x + 1];
G[K + 1] = S;
sort(G + 1, G + K + 1);
long long low1 = 0, high1 = 1e9, ans1 = 1e9 + 1;
while (low1 <= high1) {
long long lims = (low1 + high1) / 2LL;
long long t = 0;
for (int i = 0; i < K + 1; i++) {
long long len = G[i + 1] - G[i];
long long low = 0, high = len, mid, ans = -1;
while (low <= high) {
mid = (low + high) / 2;
long long lits = 2LL * mid;
if ((len - mid) + lits <= lims) {
ans = max(ans, mid);
low = mid + 1;
} else {
high = mid - 1;
}
}
if (ans == -1) {
t = -1;
break;
} else {
long long l = min(ans, len) + max(2LL * (len - ans), 0LL);
t += l;
}
}
if (t != -1 && t <= T) {
ans1 = min(ans1, lims);
high1 = lims - 1;
} else {
low1 = lims + 1;
}
}
long long v = -1;
for (int x = 0; x < N; x++)
if (A[x].second >= ans1) {
if (v == -1)
v = A[x].first;
else
v = min(A[x].first, v);
}
cout << v << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long n, k, s, t;
pair<long long, long long> c[200003];
long long x[200004];
int check(long long i) {
long h = c[i].first;
long long to = 0;
for (long j = 1; j <= k; j++) {
long long f = x[j] - x[j - 1];
if (f > h) return 0;
long long p = h - f;
if (p > f) p = f;
to = to + p + (f - p) * 2LL;
}
if (to <= t) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s >> t;
for (long i = 1; i <= n; i++) {
cin >> c[i].second >> c[i].first;
}
for (long i = 1; i <= k; i++) cin >> x[i];
sort(x + 1, x + k + 1);
x[0] = 0;
k++;
x[k] = s;
sort(c + 1, c + n + 1);
long l = 0;
long r = n;
if (check(n) == 0) {
cout << "-1" << endl;
return 0;
}
while (r - l > 1) {
long mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
long mm = c[r].second;
for (long i = 1; i <= n; i++) {
if (c[i].first >= c[r].first && c[i].second < mm) mm = c[i].second;
}
cout << mm << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 1000000000;
const int MAX = 100007;
const int MAX2 = 1000000;
const int MAXD = 20;
const int BASE = 1000000007;
const int MOD = 1000000007;
int n, k, s, t;
vector<int> A, B;
vector<pair<int, int> > C;
bool F(int x) {
int sum = 0;
for (int i = 0; i < (int)B.size(); ++i) {
if (x < B[i]) return 0;
sum += 2 * B[i] - min(x - B[i], B[i]);
}
return sum <= t;
}
int main() {
cin >> n >> k >> s >> t;
vector<pair<int, int> > CC;
for (int i = (0); i < (n); i++) {
int x, y;
scanf("%d%d", &x, &y);
CC.push_back(make_pair(y, x));
}
sort(CC.begin(), CC.end());
for (int i = (0); i < ((int)CC.size()); i++) {
while ((int)C.size() && C.back().second >= CC[i].second) C.pop_back();
if (C.empty() || CC[i].first > C.back().first) C.push_back(CC[i]);
}
for (int i = (0); i < (k); i++) {
int x;
cin >> x;
A.push_back(x);
}
A.push_back(0);
A.push_back(s);
sort(A.begin(), A.end());
A.resize(unique(A.begin(), A.end()) - A.begin());
for (int i = (0); i < ((int)A.size() - 1); i++) {
B.push_back(A[i + 1] - A[i]);
}
int L = 0;
int R = (int)C.size() - 1;
if (!F(C[R].first)) {
cout << -1 << endl;
return 0;
}
while (R - L > 1) {
int X = (L + R) / 2;
if (F(C[X].first))
R = X;
else
L = X;
}
if (F(C[L].first)) R = L;
cout << C[R].second;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e9 + 10;
const int N = 1e6;
long long n, k, s, t, b[N];
pair<long long, long long> car[N];
vector<pair<long long, long long> > vec;
long long road[N];
bool check(long long x) {
long long sum = 0;
for (int i = 1; i <= k; i++) {
if (x < road[i]) return 0;
if (x >= 2 * road[i]) {
sum += road[i];
} else {
sum += x - road[i] + 2 * (2 * road[i] - x);
}
}
return sum <= t;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) cin >> car[i].second >> car[i].first;
long long last = 0;
for (int i = 1; i <= k; i++) {
cin >> b[i];
}
sort(b + 1, b + k + 1);
for (int i = 1; i <= k; i++) {
long long tt = b[i];
road[i] = tt - last;
last = tt;
}
k++;
road[k] = s - last;
sort(car + 1, car + n + 1);
long long now = INF;
for (int i = n; i >= 1; i--) {
if (car[i].second < now) {
vec.push_back(car[i]);
now = car[i].second;
}
}
int l = 0, r = vec.size() - 1, ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (check(vec[mid].first)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
if (ans == -1)
puts("-1");
else
cout << vec[ans].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, k, t;
int a[200005];
long long trial(long long x) {
long long ret = 0;
for (int i = 0; i < k; i++) {
if (a[i] > x) return 1e12;
long long k = x - a[i];
k = min(k, 1ll * a[i]);
ret += 2 * a[i] - k;
}
return ret;
}
int main() {
scanf("%d %d", &n, &k);
scanf("%d %d", &a[k], &t);
vector<pair<int, int> > v;
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
v.push_back(pair<int, int>(a, b));
}
for (int i = 0; i < k; i++) scanf("%d", &a[i]);
k++;
sort(a, a + k);
for (int i = k - 1; i; i--) a[i] -= a[i - 1];
long long s = 0, e = 1e10;
while (s != e) {
long long m = (s + e) / 2;
if (trial(m) <= t)
e = m;
else
s = m + 1;
}
if (trial(s) > t) {
puts("-1");
return 0;
}
int ret = 2e9 + 22;
for (auto &i : v) {
if (i.second >= s) ret = min(ret, i.first);
}
if (ret > 2e9 + 2) {
ret = -1;
}
cout << ret;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long base, long long p, long long mod = (1000000007LL)) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
int n, k, gas[200005];
long long s, t;
pair<long long, long long> cars[200005];
vector<long long> dist;
int main() {
scanf("%d%d%lld%lld", &n, &k, &s, &t);
for (int i = 1; i <= n; i++)
scanf("%lld%lld", &cars[i].second, &cars[i].first);
sort(cars + 1, cars + n + 1);
for (int i = 1; i <= k; i++) scanf("%d", &gas[i]);
sort(gas + 1, gas + k + 1);
dist.push_back(gas[1]);
for (int i = 2; i <= k; i++) dist.push_back(gas[i] - gas[i - 1]);
dist.push_back(s - gas[k]);
sort(dist.begin(), dist.end(), greater<long long>());
long long sum = accumulate(dist.begin(), dist.end(), 0);
int start = -1;
long long ans = (1000000007LL);
long long curr_time = 0;
for (int i = 1; i <= n; i++) {
if (cars[i].first < dist[0]) continue;
for (auto it : dist) curr_time += 2 * it;
if (curr_time <= t) ans = min(ans, cars[i].second);
start = i;
break;
}
if (start == -1) {
printf("-1\n");
return 0;
}
for (int i = start; i <= n; i++) {
long long cap = cars[i].first;
while (!dist.empty() && cap >= dist.back() * 2) {
curr_time -= dist.back();
sum -= dist.back();
dist.pop_back();
}
if (curr_time - ((int)dist.size() * cap - sum) <= t)
ans = min(ans, cars[i].second);
}
if (ans == (1000000007LL)) ans = -1;
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops", \
"omit-frame-pointer", "inline")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,fma,tune=native")
#pragma GCC option("arch=native", "no-zero-upper")
using namespace std;
const long long oo = (long long)(1e18);
vector<long long> dis;
long long solve(long long x) {
long long res = 0;
for (auto y : dis) {
if (y > x) return 1e18;
long long best = min(x - y, y);
res += 2 * y - best;
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k, second, t;
cin >> n >> k >> second >> t;
vector<pair<long long, long long> > cars;
for (int i = 0; i < n; i++) {
int c, v;
cin >> c >> v;
cars.push_back(pair<long long, long long>(c, v));
}
sort((cars).begin(), (cars).end());
vector<pair<long long, long long> > nc;
nc.push_back(cars[0]);
for (int i = 1; i < n; i++)
if (cars[i].second > nc.back().second) nc.push_back(cars[i]);
cars = nc;
n = cars.size();
vector<int> ps;
ps.push_back(0);
for (int i = 0; i < k; i++) {
int x;
cin >> x;
ps.push_back(x);
}
ps.push_back(second);
sort((ps).begin(), (ps).end());
for (int i = 1; i < ps.size(); i++) dis.push_back(ps[i] - ps[i - 1]);
int pos = -1;
for (int po = (1 << 17); po; po >>= 1)
if (pos + po < n && solve(cars[pos + po].second) > t) pos += po;
pos++;
if (pos == n)
cout << (-1) << '\n';
else
cout << (cars[pos].first) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long maxTime;
vector<pair<int, int> > prune(vector<pair<int, int> > cars) {
sort(cars.begin(), cars.end());
vector<pair<int, int> > ret;
int befTank = -123;
for (auto& it : cars) {
if (it.second > befTank) {
befTank = it.second;
ret.push_back(it);
}
}
return ret;
}
bool can(pair<int, int> c, const vector<int>& gases) {
int now = 0;
int tank = c.second;
long long tm = 0;
for (auto& it : gases) {
if (it - now > tank) {
return false;
}
int rem = tank - (it - now);
tm += 2ll * (it - now);
tm -= min(rem, it - now);
now = it;
}
return tm <= maxTime;
}
int main() {
ios::sync_with_stdio(false);
int n, k, s;
cin >> n >> k >> s >> maxTime;
vector<pair<int, int> > cars;
for (int i = 0; i < n; i++) {
int price, tank;
cin >> price >> tank;
cars.push_back(make_pair(price, tank));
}
cars = prune(cars);
vector<int> gases;
for (int i = 0; i < k; i++) {
int pos;
cin >> pos;
gases.push_back(pos);
}
gases.push_back(s);
sort(gases.begin(), gases.end());
int lo = 0, hi = cars.size() - 1;
int ans = -1;
while (lo <= hi) {
int md = (lo + hi) / 2;
if (can(cars[md], gases)) {
hi = md - 1;
ans = cars[md].first;
} else {
lo = md + 1;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
const long long INF = (long long)3e9;
int n, k, s, t;
long long v[N], c[N], g[N];
long long calc(long long len, long long cap) {
if (cap < len) {
return INF;
}
long long y = min(len, cap - len);
long long x = len - y;
return x + x + y;
}
bool check(int mid) {
long long sum = 0;
long long cap = 0;
for (int i = 0; i < n; i++) {
if (c[i] <= mid) {
cap = max(cap, v[i]);
}
}
for (int i = 0; i <= k; i++) {
sum += calc(g[i + 1] - g[i], cap);
}
return sum <= t;
}
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &c[i], &v[i]);
}
g[0] = 0;
for (int i = 1; i <= k; i++) {
scanf("%lld", &g[i]);
}
g[k + 1] = s;
sort(g, g + (k + 1));
int low = 0;
int high = *max_element(c, c + n);
if (!check(high)) {
puts("-1");
exit(0);
}
while (low <= high) {
int mid = (low + high) / 2;
if (check(mid)) {
high = mid - 1;
} else {
low = mid + 1;
}
}
printf("%d\n", low);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t;
const int maxn = 2e5 + 5;
int c[maxn], v[maxn];
int g[maxn];
bool check(int V) {
long long ans = 0;
for (int i = 1; i <= k; i++) {
int S = g[i] - g[i - 1];
int t2 = min(S, V - S);
if (t2 < 0) return false;
int t1 = 2 * S - 2 * t2;
if (t1 < 0) return false;
ans += (t1 + t2);
}
return ans <= (long long)t;
}
int main() {
cin >> n >> k >> s >> t;
int l = 1e9 + 5, r = -1;
for (int i = 1; i <= n; i++)
scanf("%d%d", c + i, v + i), l = min(l, v[i]), r = max(r, v[i]);
for (int i = 1; i <= k; i++) scanf("%d", g + i);
sort(g + 1, g + 1 + k);
g[k + 1] = s;
k++;
g[0] = 0;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
if (!check(l)) {
printf("-1\n");
} else {
int mc = 1e9 + 5;
for (int i = 1; i <= n; i++) {
if (v[i] >= l) mc = min(mc, c[i]);
}
if (mc == 1e9 + 5)
printf("-1\n");
else
printf("%d\n", mc);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000000 + 7;
long long addm(long long& a, long long b) {
return (a += b) < mod ? a : a -= mod;
}
template <class T, class U>
bool smin(T& a, U b) {
return a > b ? (a = b, 1) : 0;
}
template <class T, class U>
bool smax(T& a, U b) {
return a < b ? (a = b, 1) : 0;
}
long long n, k, s, t;
long long C[200000], V[200000];
long long gas[200000];
long long time(long long d, long long f) {
if (f < d) return -1;
return max((long long)3 * d - f, d);
}
bool doable(long long cap) {
long long tm = 0;
long long pos = 0;
for (long long i = 0; i < k; i++) {
long long ct = time(gas[i] - pos, cap);
if (ct == -1) return 0;
tm += ct;
pos = gas[i];
}
long long ct = time(s - pos, cap);
if (ct == -1) return 0;
tm += ct;
pos = s;
return tm <= t;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> s >> t;
for (long long i = 0; i < n; i++) cin >> C[i] >> V[i];
for (long long i = 0; i < k; i++) cin >> gas[i];
sort(gas, gas + k);
long long l = 0, u = 2000000000;
while (l != u) {
long long mid = (l + u) / 2;
if (doable(mid))
u = mid;
else
l = mid + 1;
}
long long bp = INT_MAX;
for (long long i = 0; i < n; i++)
if (V[i] >= l) smin(bp, C[i]);
if (bp == INT_MAX)
cout << -1 << endl;
else
cout << bp << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, ng, s, t;
pair<int, int> c[N];
int d[N];
bool posi(int cap) {
int tt = 0;
for (int i = 0; i <= ng; i++) {
if (d[i] > cap) return false;
if (cap >= 2 * d[i]) {
tt += d[i];
if (tt > t) return false;
continue;
}
tt += 3 * d[i] - cap;
if (tt > t) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> ng >> s >> t;
for (int i = 0; i < n; i++) {
cin >> c[i].second >> c[i].first;
}
for (int i = 0; i < ng; i++) {
cin >> d[i];
}
sort(d, d + ng);
int temp, ppos = 0;
for (int i = 0; i < ng; i++) {
temp = d[i];
d[i] = d[i] - ppos;
ppos = temp;
}
d[ng] = s - ppos;
int h = 1e9 + 9;
if (!posi(h)) {
cout << -1;
return 0;
}
int l = 0;
int m = (l + h) / 2;
while (h - l > 1) {
if (posi(m)) {
h = m;
m = (l + h) / 2;
continue;
}
l = m;
m = (l + h) / 2;
}
int mini = 1e9 + 1;
for (int i = 0; i < n; i++) {
if (c[i].first >= h) {
mini = min(mini, c[i].second);
}
}
cout << (mini > 1e9 ? -1 : mini);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int setBit(int N, int pos) { return N = N | (1 << pos); }
inline int resetBit(int N, int pos) { return N = N & ~(1 << pos); }
inline bool checkBit(int N, int pos) { return (bool)(N & (1 << pos)); }
int n, k;
long long s, T, P[200000 + 10];
pair<long long, long long> A[200000 + 10];
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
return a.second < b.second;
}
bool ok(long long c) {
long long ret = 0;
for (int i = 1; i <= k + 1; i++) {
long long x = P[i] - P[i - 1];
if (x > c) return false;
if (c / 2 >= x)
ret += x;
else {
ret += (c - x) + 2 * (2 * x - c);
}
}
return ret <= T;
}
int main() {
int i, j, cs;
scanf("%d %d", &n, &k);
scanf("%lld %lld", &s, &T);
for (i = 1; i <= n; i++) scanf("%lld %lld", &A[i].first, &A[i].second);
for (i = 1; i <= k; i++) scanf("%lld", &P[i]);
sort(A + 1, A + n + 1, cmp);
sort(P + 1, P + k + 1);
P[k + 1] = s;
int lo = 1, hi = n, mid;
while (lo < hi) {
mid = (lo + hi) / 2;
if (ok(A[mid].second))
hi = mid;
else
lo = mid + 1;
}
if (!ok(A[lo].second))
printf("-1\n");
else {
long long ret = A[hi].first;
for (int i = hi; i <= n; i++) ret = min(A[i].first, ret);
printf("%lld\n", ret);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[200010], v[200010], gas[200010];
int n, k, s, t;
int judge(int x) {
int timeUse = 0, len, fastS, slowS;
for (int i = 1; i <= k + 1; i++) {
len = gas[i] - gas[i - 1];
if (x < len) return 0;
fastS = x - len;
slowS = 2 * len - x;
if (slowS > 0)
timeUse += (fastS + slowS * 2);
else
timeUse += len;
}
if (timeUse <= t)
return 1;
else
return 0;
}
int main() {
long long l, r, mid;
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) scanf("%d%d", &c[i], &v[i]);
for (int i = 1; i <= k; i++) scanf("%d", &gas[i]);
gas[k + 1] = s;
sort(gas, gas + k + 2);
l = 0;
r = s * 2 + 1;
while (l < r) {
mid = (l + r) / 2;
if (judge(mid))
r = mid;
else
l = mid + 1;
}
int minPrice = INT_MAX;
for (int i = 1; i <= n; i++)
if (c[i] <= minPrice && v[i] >= l && r != s * 2 + 1) minPrice = c[i];
if (minPrice == INT_MAX)
cout << -1 << endl;
else
cout << minPrice << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long INF = 1000000000000;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
long long s, t;
cin >> n >> k >> s >> t;
vector<int> c(n), v(n);
for (int i = 0; i < n; i++) {
cin >> c[i] >> v[i];
}
vector<int> g(k);
for (int i = 0; i < k; i++) {
cin >> g[i];
}
g.push_back(0);
g.push_back(s);
k += 2;
sort(g.begin(), g.end());
long long tv = INF;
long long fv = 0;
while (tv - fv > 1) {
long long mid = (tv + fv) / 2;
long long time = 0;
bool ok = true;
for (int i = 0; i < k - 1; i++) {
long long d = g[i + 1] - g[i];
if (mid < d) {
ok = false;
} else if (mid > d * 2) {
time += d;
} else {
time += 3 * d - mid;
}
}
if (ok && time <= t) {
tv = mid;
} else {
fv = mid;
}
}
long long ans = INF;
for (int i = 0; i < n; i++) {
if (v[i] >= tv) {
ans = min(ans, (long long)c[i]);
}
}
if (ans == INF) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int maxn = 2e5 + 3;
int c[maxn], vv[maxn];
int main() {
ios_base::sync_with_stdio(false);
int n, k, s, t;
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) {
cin >> c[i] >> vv[i];
}
vector<int> v;
v.push_back(0);
for (int i = 1; i <= k; i++) {
int x;
cin >> x;
v.push_back(x);
}
v.push_back(s);
sort(v.begin(), v.end());
if (t < s) {
cout << -1 << "\n";
return 0;
}
if (t > 2 * s) {
t = 2 * s;
}
vector<int> f;
for (int i = 1; i < (int)v.size(); i++) {
f.push_back(v[i] - v[i - 1]);
}
sort(f.begin(), f.end());
vector<int> sum(f.size(), f[0]);
for (int i = 1; i < (int)f.size(); i++) {
sum[i] = sum[i - 1] + f[i];
}
int INF = 1e9 + 7;
int ans = INF;
for (int i = 1; i <= n; i++) {
int value = vv[i];
if (f.back() > value) {
continue;
}
int pos = upper_bound(f.begin(), f.end(), value / 2) - f.begin();
if (pos >= (int)f.size()) {
ans = min(ans, c[i]);
continue;
}
int cnt = (int)f.size() - pos;
pos--;
int delta =
cnt * value - (sum[(int)f.size() - 1] - (pos >= 0 ? sum[pos] : 0));
int quick = (pos >= 0 ? sum[pos] : 0) + delta;
int cur = quick + (s - quick) * 2;
if (cur <= t) {
ans = min(c[i], ans);
}
}
if (ans == INF) {
ans = -1;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
pair<long long int, long long int> a[N];
long long s, t;
long long int gas[N];
int n, k, s1, t1;
bool valid(long long m) {
int tim = 0;
for (int i = 2; i <= k; i++) {
long long int l = gas[i] - gas[i - 1];
if (m < l) return false;
int tans = 0;
if (m >= 2LL * l) {
tim += l;
continue;
}
long long x = 2LL * l - m;
tim += (l + x);
}
return (tim <= t);
}
int main() {
scanf("%d%d%d%d", &n, &k, &s1, &t1);
t = t1;
s = s1;
for (int i = 1; i <= n; i++) scanf("%I64d%I64d", &a[i].second, &a[i].first);
for (int i = 1; i <= k; i++) scanf("%I64d", &gas[i]);
gas[k + 1] = 0;
gas[k + 2] = s;
k += 2;
sort(gas + 1, gas + k + 1);
long long int lo = 0, hi = 1e15;
long long int ans = hi;
while (lo <= hi) {
long long int mid = (lo + hi) / 2;
if (valid(mid)) {
ans = min(ans, mid);
hi = mid - 1;
} else
lo = mid + 1;
}
long long int cmin = 1e9 + 10;
for (int i = 1; i <= n; i++) {
if (a[i].first >= ans) {
cmin = min(cmin, a[i].second);
}
}
if (cmin == (int)(1e9 + 10)) cmin = -1;
cout << cmin << endl;
return 0;
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::deque;
using std::endl;
using std::map;
using std::max;
using std::min;
using std::multiset;
using std::pair;
using std::queue;
using std::set;
using std::sort;
using std::stack;
using std::string;
using std::vector;
int n, k, s, t;
int c[200005] = {
0,
};
int v[200005] = {
0,
};
int g[200005] = {
0,
};
bool isGood(int middle) {
int time = 0;
for (int i = 1; i <= k + 1; i++) {
int len = g[i] - g[i - 1];
if (len > middle) {
return false;
}
if (middle >= len * 2) {
time += len;
} else {
time += (len * 2 - middle) * 2 + (middle - len);
}
}
if (time <= t) return true;
return false;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
scanf("%d%d", c + i, v + i);
}
g[0] = 0;
g[k + 1] = s;
for (int i = 1; i <= k; i++) {
scanf("%d", g + i);
}
sort(g, g + k + 2);
const int up = 2123456789;
int badBak = 0;
int goodBak = up;
while (badBak + 1 != goodBak) {
int middle = (int)((1LL * badBak + goodBak) / 2);
if (isGood(middle)) {
goodBak = middle;
} else {
badBak = middle;
}
}
if (goodBak == up) {
cout << -1;
return 0;
}
int cheap = up;
for (int i = 0; i < n; i++) {
if (v[i] >= goodBak && c[i] < cheap) {
cheap = c[i];
}
}
if (cheap == up) {
cout << -1;
return 0;
}
cout << cheap;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int msz = 10000;
const int mod = 1e9 + 7;
const double eps = 1e-8;
const int maxn = 212345;
struct Car {
int c, v;
bool operator<(const struct Car a) const {
return c == a.c ? v > a.v : c < a.c;
}
} cr[maxn], us[maxn];
int tp;
int k, s, t;
int g[maxn];
long long got(int dis, int v) {
int l = 0, r = dis;
long long ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (2 * mid + (dis - mid) <= v) {
ans = mid + 2 * (dis - mid);
l = mid + 1;
} else
r = mid - 1;
}
return ans;
}
bool cal(int v) {
long long ned = 0;
for (int i = 1; i <= k; ++i) {
int dis = g[i] - g[i - 1];
if (dis > v) return false;
long long now = got(dis, v);
if (now == -1) return false;
ned += now;
}
return ned <= t;
}
int main() {
int n;
tp = 0;
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; ++i) scanf("%d%d", &cr[i].c, &cr[i].v);
g[0] = 0;
for (int i = 1; i <= k; ++i) scanf("%d", &g[i]);
g[++k] = s;
sort(g, g + k + 1);
sort(cr, cr + n);
int mx = cr[0].v;
for (int i = 0; i < n; ++i) {
if (i == 0 || cr[i].v > mx) {
us[tp++] = cr[i];
mx = cr[i].v;
}
}
int ans = -1;
int l, r;
l = 0, r = tp - 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (cal(us[mid].v)) {
ans = us[mid].c;
r = mid - 1;
} else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_MEM = (int)1e8;
int mpos = 0;
char mem[MAX_MEM];
inline void *operator new(size_t n) {
char *res = mem + mpos;
mpos += n;
return (void *)res;
}
inline void operator delete(void *) {}
struct __io_dev {
__io_dev(const bool &__fastio = false) {
if (__fastio) ios_base::sync_with_stdio(false), cin.tie(nullptr);
srand(time(nullptr));
if (!string("").empty())
freopen(
""
".in",
"r", stdin),
freopen(
""
".out",
"w", stdout);
}
~__io_dev() { fprintf(stderr, "%.6f ms\n", 1e3 * clock() / CLOCKS_PER_SEC); }
} __io(false);
const long long inf = (long long)1e+9 + 7ll;
const long long linf = (long long)1e+18 + 7ll;
const long double eps = (long double)1e-9;
const long double pi = acosl((long double)-1.0);
const int alph = 26;
const int maxs = 512l;
static char buff[(int)2e6 + 17];
long long __p[3] = {29ll, 31ll, 33ll};
long long __mod[3] = {inf, inf + 2ll, 14881337ll};
const int maxn = (int)3e5 + 17;
int n, k, s, t;
int x[maxn];
pair<int, int> a[maxn];
bool check(int i) {
int cur = 0, v = a[i].first;
for (long long i = (long long)1; i < (long long)k; ++i) {
int l = x[i] - x[i - 1];
if (v < l) return false;
cur += min(l, v - l) + 2 * (l - min(l, v - l));
}
return cur <= t;
}
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
for (long long i = 0ll; i < (long long)n; ++i)
scanf("%d %d", &a[i].second, &a[i].first);
for (long long i = 0ll; i < (long long)k; ++i) scanf("%d", x + i);
x[k++] = 0, x[k++] = s;
sort(x, x + k);
sort(a, a + n);
for (int i = n - 2; i >= 0; --i)
a[i].second = min(a[i].second, a[i + 1].second);
int l = 0, r = n - 1;
for (int m; l < r; m = (l + r) / 2, check(m) ? r = m : l = m + 1)
;
if (check(l))
printf("%d\n", a[l].second);
else
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long s, t;
vector<long long> price;
vector<long long> tank;
vector<long long> gas;
vector<long long> dist;
vector<long long> sums;
int getfirst(long long tank) {
int start = -1, end = (int)(dist.size()) - 1;
while (start != end) {
int mid = (start + end + 1) / 2;
if (dist[mid] * 2 <= tank)
start = mid;
else
end = mid - 1;
}
return start;
}
int main() {
cin >> n >> k >> s >> t;
tank.resize(n);
price.resize(n);
gas.resize(k);
for (int i = (0); i < (n); ++i) scanf("%d %d", &price[i], &tank[i]);
for (int i = (0); i < (k); ++i) scanf("%d", &gas[i]);
gas.push_back(s);
gas.push_back(0);
sort(gas.begin(), gas.end());
for (int i = (0); i < ((int)(gas.size()) - 1); ++i)
dist.push_back(gas[i + 1] - gas[i]);
sort(dist.begin(), dist.end());
sums.push_back(0);
for (int i = (0); i < ((int)(dist.size())); ++i)
sums.push_back(sums.back() + dist[i]);
long long minprice = 1.5e9;
for (int i = (0); i < (n); ++i)
if (dist.back() <= tank[i]) {
int pos = getfirst(tank[i]);
long long extra = ((int)(dist.size()) - 1 - pos) * tank[i] -
(sums.back() - sums[pos + 1]);
long long time =
sums[pos + 1] + (sums.back() - sums[pos + 1]) * 2 - extra;
if (time <= t) minprice = min(minprice, price[i]);
}
if (minprice > 1.1e9)
cout << -1 << endl;
else
cout << minprice << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<long long> c(n), v(n), g(k + 1, 1e9 + 5), f(k + 2, 0);
for (int i = 0; i < n; i++) cin >> c[i] >> v[i];
for (int i = 0; i < k; i++) cin >> g[i];
sort(g.begin(), g.end());
g[k] = s;
for (int i = k - 1; i >= 0; i--) g[i + 1] -= g[i];
sort(g.begin(), g.end());
for (int i = 1; i <= k + 1; i++) f[i] = f[i - 1] + g[i - 1];
long long ret = -1;
for (int i = 0; i < n; i++)
if (g[k] <= v[i]) {
long long x = upper_bound(g.begin(), g.end(), v[i] / 2) - g.begin();
if (2 * s - f[x] - (k + 1 - x) * v[i] + (f[k + 1] - f[x]) <= t) {
if (ret == -1)
ret = c[i];
else
ret = min(ret, c[i]);
}
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t, b[(long long)(5 + 2e5)];
pair<int, int> a[(long long)(5 + 2e5)];
bool CMP(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
bool Try(int C) {
long long T = t, d;
for (int i = 0; i < k; i++)
if (C < (d = b[i + 1] - b[i]))
return 0;
else if (C >= 2 * d)
T -= d;
else
T -= 2 * d - (C - d);
return T >= 0;
}
int solve() {
int l = 0, r = n - 1, mid;
while (l + 1 < r) {
mid = l + r >> 1;
if (Try(a[mid].second))
r = mid;
else
l = mid + 1;
}
if (Try(a[l].second)) return a[l].second;
return a[r].second;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) scanf("%d%d", &a[i].first, &a[i].second);
for (int i = 0; i < k; i++) scanf("%d", &b[i]);
b[k] = s;
sort(a, a + n, CMP);
k++;
sort(b, b + k + 1);
a[n++] = {1 + 2e9, 1 + 2e9};
int ans = solve();
n--;
sort(a, a + n);
for (int i = 0; i < n; i++)
if (a[i].second >= ans) {
cout << a[i].first << endl;
return 0;
}
cout << -1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t, c[200005], v[200005], q[200005], g[200005], d[200005], ans;
bool cmp(int x, int y) { return x < y; }
bool ok(int x) {
long long tot = 0;
for (int i = (0); i < (k + 1); i++) {
if (d[i] + d[i] <= x)
tot += d[i];
else if (d[i] <= x)
tot += 3LL * d[i] - x;
else
return 0;
}
return tot <= t;
}
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = (0); i < (n); i++) scanf("%d %d", &c[i], &v[i]);
g[0] = 0;
for (int i = (1); i <= (k); i++) scanf("%d", &g[i]);
g[k + 1] = s;
sort(g, g + k + 2);
for (int i = (0); i < (k + 1); i++) d[i] = g[i + 1] - g[i];
int l = 0, h = 1000000001;
while (l < h) {
int m = (long long)l + h >> 1;
if (ok(m))
h = m;
else
l = m + 1;
}
ans = 2e9;
for (int i = (0); i < (n); i++)
if (c[i] < ans && v[i] >= h) ans = c[i];
printf("%d\n", ans > 1.5e9 ? -1 : ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, k;
long long int s, t;
long long int g[N];
long long int ic[N], iv[N];
bool solve(long long int c) {
long long int tt = 0;
for (int i = 1; i <= k; i++) {
long long int d = g[i] - g[i - 1];
long long int a = min(d, c - d);
if (a < 0) return false;
tt += d + d - a;
if (tt > t) return false;
}
return (tt <= t);
}
int main() {
scanf("%d %d %lld %lld", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%lld %lld", &iv[i], &ic[i]);
for (int i = 1; i <= k; i++) scanf("%lld", &g[i]);
k++;
g[k] = s;
sort(g, g + k + 1);
long long int lo = 0;
long long int hi = 1e9 + 3;
while (lo < hi) {
long long int mid = (lo + hi) / 2;
if (solve(mid))
hi = mid;
else
lo = mid + 1;
}
long long int res = 1e9 + 3;
for (int i = 0; i < n; i++) {
if (ic[i] >= lo) res = min(iv[i], res);
}
if (res == 1e9 + 3) res = -1;
printf("%lld\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10;
const int INF = 2e9 + 7;
int n, m, s, t, g[MAXN];
pair<int, int> vec[MAXN];
int get(int f) {
int ret = 0;
for (int i = 0; ret < INF && i + 1 < m; i++) {
int dis = g[i + 1] - g[i];
if (dis > f) return INF;
ret += dis << 1;
int z = min(dis, f - dis);
ret -= z;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> s >> t;
for (int i = 0; i < n; i++) cin >> vec[i].first >> vec[i].second;
for (int i = 0; i < m; i++) cin >> g[i];
g[m++] = 0;
g[m++] = s;
sort(g, g + m);
int b = 1, e = 1e9, ret = 2e9;
while (b <= e) {
int mid = b + e >> 1, mx = 0;
for (int i = 0; i < n; i++)
if (vec[i].first <= mid) mx = max(mx, vec[i].second);
if (get(mx) <= t)
ret = mid, e = mid - 1;
else
b = mid + 1;
}
if (ret > 1e9 + 7) ret = -1;
cout << ret << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 9;
const long long mod = 1e9 + 7;
int n, k, nb = 0;
long long s, t;
long long cur, mx, sum, pre, res = -1;
long long c[maxn], v[maxn], g[maxn];
map<long long, long long> num, pree;
set<long long> st;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
cin >> c[i] >> v[i];
}
for (int i = 0; i < k; i++) {
cin >> g[i];
}
sort(g, g + k);
for (int i = 0; i < k; i++) {
num[g[i] - pre]++;
st.insert(g[i] - pre);
mx = max(mx, g[i] - pre);
pre = g[i];
}
st.insert(s - pre);
num[s - pre]++;
mx = max(mx, s - pre);
for (int i = 0; i < n; i++) {
st.insert(v[i] / 2);
}
for (auto x : st) {
nb += num[x];
cur += num[x] * x;
pree[x] = cur;
num[x] = nb;
}
for (int i = 0; i < n; i++) {
if (v[i] < mx) {
continue;
}
long long f = num[v[i] / 2];
long long ff = pree[v[i] / 2];
long long cur = v[i] * (k + 1 - f) - (s - ff);
if (ff + cur + (s - ff - cur) * 2 <= t) {
res = ((res + 1) ? min(res, c[i]) : c[i]);
}
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T chmin(T &x, const T &y) {
if (y < x) return x = y;
return x;
}
template <class T>
T chmax(T &x, const T &y) {
if (x < y) return x = y;
return x;
}
template <class P, class Q>
ostream &operator<<(ostream &os, const pair<P, Q> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
bool was = false;
for (const T &x : v) {
if (was) os << ", ";
was = true;
os << x;
}
os << '}';
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << '[';
bool was = false;
for (const T &x : v) {
if (was) os << ", ";
was = true;
os << x;
}
os << ']';
return os;
}
template <class P, class Q>
ostream &operator<<(ostream &os, const map<P, Q> &m) {
os << '<';
bool was = false;
for (const auto &x : m) {
if (was) os << ", ";
was = true;
os << x;
}
os << '>';
return os;
}
const long long INF = (long long)2e9 + 1;
const long long MAXN = (long long)2e5 + 10;
long long n, k, s, t;
long long cost[MAXN], v[MAXN], pos[MAXN];
long long f(long long V) {
long long res = 0;
for (long long i = k + 1; i; i--) {
if ((pos[i] - pos[i - 1]) > V) {
return INF;
}
if (V >= (pos[i] - pos[i - 1]) * 2)
res += pos[i] - pos[i - 1];
else
res += 3 * (pos[i] - pos[i - 1]) - V;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (long long i = 1; i <= n; i++) {
cin >> cost[i] >> v[i];
}
pos[0] = 0, pos[k + 1] = s;
for (long long i = 1; i <= k; i++) {
cin >> pos[i];
}
sort(pos + 1, pos + k + 1);
long long l = 1, r = (long long)1e9 + 2;
while (r - l > 1) {
long long md = (l + r) >> 1;
if (f(md) > t)
l = md;
else
r = md;
}
long long cc = INF, ans = 0;
for (int i = 1; i <= n; i++) {
if (v[i] >= r)
if (cc > cost[i]) cc = cost[i], ans = i;
}
if (cc == INF)
cout << -1;
else
cout << cc;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, s, t;
cin >> n >> k >> s >> t;
vector<int> c(n);
vector<int> v(n);
for (int i = 0; i < n; i++) scanf("%d%d", &c[i], &v[i]);
vector<int> g(k + 2);
for (int i = 0; i < k; i++) scanf("%d", &g[i]);
g[k] = 0;
g[k + 1] = s;
k += 2;
sort(g.begin(), g.end());
int q = 2e9;
int start = 0;
int end = 2e9;
int mid = 2e9 / 2;
for (int i = 0; i <= 32 && start < end; i++) {
bool flag = true;
int y = 0;
for (int j = 1; j < k && flag; j++)
if (g[j] - g[j - 1] > mid)
flag = false;
else
y +=
min(g[j] - g[j - 1], mid - g[j] + g[j - 1]) +
2 * (g[j] - g[j - 1] - min(g[j] - g[j - 1], mid - g[j] + g[j - 1]));
if (flag && y <= t) {
end = mid;
mid = (end + start) / 2;
q = end;
} else {
start = mid;
mid = (end + start) / 2;
}
}
int min1 = 2e9 + 1;
for (int i = 0; i < n; i++)
if (v[i] >= q && c[i] < min1) min1 = c[i];
if (min1 == 2e9 + 1)
cout << "-1";
else
cout << min1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n = 0, k = 0, s = 0, t = 0;
pair<int, int> cars[200002];
int gas[200002];
bool check(int index) {
int v = cars[index].first;
int pos = 0, time = 0;
for (int i = 0; i <= k; i++) {
if (time > t || gas[i] - pos > v) return false;
int left = 0, right = gas[i] - pos + 1;
while (left != (right - 1)) {
int middle = (left + right) >> 1;
if (middle * 2 + (gas[i] - pos - middle) <= v)
left = middle;
else
right = middle;
}
time += left + (gas[i] - pos - left) * 2;
pos = gas[i];
}
if (time > t) return false;
return true;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%d%d", &cars[i].second, &cars[i].first);
sort(cars, cars + n);
for (int i = 0; i < k; i++) scanf("%d", gas + i);
sort(gas, gas + k);
gas[k] = s;
if (!check(n - 1)) {
printf("-1\n");
return 0;
}
int left = -1, right = n - 1;
while (left != (right - 1)) {
int middle = (left + right) >> 1;
if (check(middle))
right = middle;
else
left = middle;
}
int min_c = cars[right].second;
for (int i = right + 1; i < n; i++)
if (cars[i].second < min_c) min_c = cars[i].second;
printf("%d\n", min_c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 201010;
struct Car {
int c, v;
} b[maxn];
int x[maxn], a[maxn];
int k;
inline long long get(int lim) {
long long ans = 0;
for (int i = 1; i <= k; i++) {
if (a[i] > lim)
return 0;
else if (a[i] * 2 <= lim)
ans += a[i];
else
ans += lim - a[i];
}
return ans;
}
int main() {
int n, t, s;
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) scanf("%d%d", &b[i].c, &b[i].v);
int prev = 0;
for (int i = 1; i <= k; i++) scanf("%d", &x[i]);
sort(x + 1, x + k + 1);
for (int i = 1; i <= k; i++) a[i] = x[i] - x[i - 1];
a[k + 1] = s - x[k];
k++;
long long sum = 0;
sort(a + 1, a + k + 1);
for (int i = 1; i <= k; i++) sum += a[k] - a[i];
if (t < s) {
cout << "-1";
return 0;
}
int cnt = max(0, 2 * s - t);
long long l = a[k], r = 2 * s, mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (get(mid) >= cnt)
r = mid;
else
l = mid;
}
int cap;
if (get(l) >= cnt)
cap = l;
else
cap = r;
int id = -1;
for (int i = 1; i <= n; i++) {
if (b[i].v >= cap) {
if (id == -1 || b[i].c < b[id].c) id = i;
}
}
if (id == -1) {
cout << "-1";
return 0;
}
cout << b[id].c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 22, INF = 1e10 + 7;
long long n, k, s, t, x, dis[MAXN], high, low, mid;
pair<long long, long long> car[MAXN];
bool check(long long ans) {
if (ans < x) return false;
long long u, e = 0;
for (int i = 1; i <= k + 1; i++) {
u = ans - dis[i] + dis[i - 1];
if (u <= dis[i] - dis[i - 1])
e += u + (2 * (dis[i] - dis[i - 1]) - ans) * 2;
else
e += dis[i] - dis[i - 1];
}
if (e <= t)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) cin >> car[i].first >> car[i].second;
dis[k + 1] = s;
for (int i = 1; i <= k; i++) cin >> dis[i];
sort(dis + 1, dis + 1 + k);
sort(car + 1, car + 1 + n);
for (int i = 1; i <= k + 1; i++) x = max(x, dis[i] - dis[i - 1]);
low = 0, high = INF;
while (high >= low) {
mid = (low + high) / 2;
if (check(mid))
high = mid - 1;
else
low = mid + 1;
}
for (int i = 1; i <= n; i++) {
if (car[i].second >= low) {
cout << car[i].first;
return 0;
}
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p);
int Bit(long long x);
long long Sum(int x);
inline int D() {
int t;
scanf("%d", &t);
return t;
}
inline long long llD() {
long long t;
scanf("%lld", &t);
return t;
}
const int N = 1e6 + 5;
int arr[N];
vector<pair<long long, long long>> vec;
int n, k, l, r, mid, ans;
long long s, t, a, two, one, cap, MN = 1e9 + 10;
bool flage;
bool can(int idx) {
cap = vec[idx].first, two = one = 0, flage = true;
for (int i = 1; i <= k; ++i) {
flage &= (arr[i] - arr[i - 1] <= cap);
if (cap >= 2ll * (arr[i] - arr[i - 1])) {
two += arr[i] - arr[i - 1];
continue;
}
a = cap - (arr[i] - arr[i - 1]);
two += a;
one += cap - 2 * a;
}
if (flage && two + 2 * one <= t) return true;
return false;
}
int BS() {
l = 0, r = n - 1, mid;
while (l < r) {
mid = (l + r) >> 1;
if (can(mid))
r = mid;
else
l = mid + 1;
}
if (can(r)) return r;
return -1;
}
int main() {
n = D(), k = D(), s = llD(), t = llD();
for (int i = 0; i < n && scanf("%lld%lld", &two, &one); ++i)
vec.push_back({one, two});
for (int i = 1; i <= k; ++i) scanf("%d", arr + i);
sort(vec.begin(), vec.end());
sort(arr + 1, arr + k + 1);
arr[++k] = s;
ans = BS();
if (ans != -1)
while (ans < n) MN = min(MN, vec[ans++].second);
else
MN = -1;
printf("%lld", MN);
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int Bit(long long x) {
if (!x) return 0;
return 1 + Bit(x >> 1);
}
long long Sum(int x) { return (1ll * x * (x + 1)) >> 1ll; }
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int MAXN = 1e6 + 10;
const long long MOD = 1e9 + 7;
const long long MOD2 = 998244353;
const long long INF = 8e18;
const int LOG = 20;
long long pw(long long a, long long b, long long mod) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % mod, b / 2, mod)) % mod
: pw(a * a % mod, b / 2, mod)));
}
int n, k, s, t;
vector<pair<int, int> > v;
vector<int> gas;
bool check(int x) {
if (x >= n) return 0;
long long ans = 0, last = v[x].first;
for (int i = 1; i <= k + 1; i++) {
int del = gas[i] - gas[i - 1];
if (del > last) return 0;
ans += 2 * (del);
ans -= max(0ll, min(1ll * del, (last - del)));
}
if (ans > t) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
v.push_back(make_pair(b, a));
}
for (int i = 1; i <= k; i++) {
int a;
cin >> a;
gas.push_back(a);
}
gas.push_back(s);
gas.push_back(0);
sort((gas).begin(), (gas).end());
sort((v).begin(), (v).end());
reverse((v).begin(), (v).end());
int d = 0, up = n;
while (up - d > 1) {
int mid = (up + d) >> 1;
if (check(mid)) {
d = mid;
} else {
up = mid;
}
}
if (check(0) == 0) {
return cout << -1, 0;
}
int ans = 2e9;
for (int i = 0; i <= d; i++) {
ans = min(ans, v[i].second);
}
for (int i = 0; i < n; i++) {
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, t;
vector<long long> station;
bool can(long long gas) {
long long time = 0;
for (long long i = 1; i <= k + 1; i++) {
long long dist = station[i] - station[i - 1];
long long acc = min(gas - dist, dist);
long long normal = dist - acc;
if (acc < 0) return false;
time += acc + 2 * normal;
}
return time <= t;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> k >> s >> t;
vector<pair<long long, long long>> car(n);
for (long long i = 0; i < n; i++) cin >> car[i].first >> car[i].second;
station = vector<long long>(k + 2);
for (long long i = 1; i < k + 1; i++) {
cin >> station[i];
}
station[k + 1] = s;
sort(station.begin(), station.end());
long long lo = 0, hi = 1e10, mid;
long long mini = 1e11;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (can(mid)) {
mini = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
long long ans = 1e10;
sort(car.begin(), car.end());
for (long long i = 0; i < n; i++) {
if (car[i].second >= mini) {
ans = car[i].first;
break;
}
}
if (ans != 1e10)
cout << ans << '\n';
else
cout << -1 << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
string world[8] = {"U", "D", "R", "L", "UL", "UR", "DR", "DL"};
const int rx[8] = {-1, 1, 0, 0, -1, -1, 1, 1};
const int ry[8] = {0, 0, 1, -1, -1, 1, 1, -1};
const long long mod = 1000000007;
int main() {
int n, k, s, t;
cin >> n >> k >> s >> t;
pair<int, int> a[n];
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i].second, &a[i].first);
}
int g[k + 1];
for (int i = 0; i < k; i++) {
scanf("%d", &g[i]);
}
g[k] = s;
k++;
sort(g, g + k);
sort(a, a + n);
int ans = 1e9;
int res = 1e9;
int l = 0, r = n - 1;
while (l <= r) {
int m = (l + r) / 2;
int mid = a[m].first;
bool f = true;
int L = 0;
int t1 = 0;
for (int i = 0; i < k; i++) {
int R = g[i];
int len = R - L;
if (len > mid) {
f = false;
break;
}
int x = (mid - len);
if (x >= len) x = len;
t1 += x;
t1 += (len - x) * 2;
L = g[i];
}
if (t1 > t) f = false;
if (f) {
res = m;
r = m - 1;
} else {
l = m + 1;
}
}
if (res == 1e9) {
cout << -1;
return 0;
}
ans = a[res].second;
for (int i = 0; i < n; i++) {
if (a[i].first >= a[res].first) ans = min(ans, a[i].second);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int p, v;
} c[200005];
int a[200005];
int n, k, s, t;
int cmp(node x, node y) {
if (x.v == y.v) return x.p < y.p;
return x.v < y.v;
}
int make(int rode, int x) {
if (rode > x) return 0;
if (x >= rode * 2) return rode;
int ans = x - rode;
return ans + (rode - ans) * 2;
}
int vj(int mid) {
int time = 0;
int now = 0;
for (int i = 0; i < k; i++) {
int fl = make(a[i] - now, mid);
now = a[i];
if (fl)
time += fl;
else
return 0;
}
if (time <= t) return 1;
return 0;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) scanf("%d%d", &c[i].p, &c[i].v);
for (int i = 0; i < k; i++) scanf("%d", a + i);
a[k++] = s;
sort(a, a + k);
int r = 1000000000, l = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (vj(mid)) {
r = mid - 1;
} else
l = mid + 1;
}
r++;
sort(c, c + n, cmp);
int minn = 1000000009;
for (int i = 0; i < n; i++) {
if (c[i].v >= l) {
if (c[i].p < minn) minn = c[i].p;
}
}
if (minn == 1000000009)
cout << -1 << endl;
else
cout << minn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int n = 2 * 1e5 + 500;
const int m = 1 * 1e2 + 50;
int N;
int K;
int S;
int T;
int optimal_cap, best = -1;
int cost[n], cap[n], gas[n];
bool ok(int op) {
int ind = 1, mn_T = 0, last = 0;
while (ind <= K + 1) {
int d = gas[ind] - last;
if (d > op) return 0;
int inc = 2 * d;
int rem = op - d;
inc -= min(d, rem);
mn_T += inc;
last = gas[ind];
ind++;
}
return (mn_T <= T);
}
int main() {
scanf("%d%d%d%d", &N, &K, &S, &T);
for (int i = 1; i <= N; i++) {
scanf("%d%d", cost + i, cap + i);
}
for (int i = 1; i <= K; i++) {
scanf("%d", gas + i);
}
sort(gas, gas + K + 1);
gas[K + 1] = S;
int l = 1, r = 2e9;
while (l < r) {
int m = l + (r - l) / 2;
if (ok(m)) {
r = m;
} else {
l = m + 1;
}
}
optimal_cap = r;
for (int i = 1; i <= N; i++) {
if (cap[i] >= optimal_cap) {
if (best == -1)
best = cost[i];
else
best = min(best, cost[i]);
}
}
printf("%d", best);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[222222], v[222222], a[222222];
int main() {
int n, k, s, t;
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) {
scanf("%d %d", c + i, v + i);
}
for (int i = 0; i < k; i++) {
scanf("%d", a + i);
}
sort(a, a + k);
a[k] = s;
for (int i = k; i; i--) a[i] -= a[i - 1];
int st = 0, ed = 0x7fffffff, mid;
while (ed - st > 1) {
mid = (st + ed) >> 1;
long long T = 0;
for (int i = 0; i <= k; i++) {
if (a[i] > mid) {
T = 0x7fffffff;
break;
} else if (mid < 2 * a[i]) {
T += (3LL * a[i] - mid);
} else
T += a[i];
}
if (T <= t)
ed = mid;
else
st = mid;
}
int ans = 0x7fffffff;
for (int i = 0; i < n; i++) {
if (v[i] >= ed) ans = min(ans, c[i]);
}
printf("%d\n", ans == 0x7fffffff ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> vc[200010];
int gas[200010];
int n, k, s, t;
int excess;
bool sort_cmp(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) return a.second < b.second;
return a.first < b.first;
}
bool can(int idx) {
int curexcess = excess;
for (int i = 0; i <= k; i++) {
int jarak;
if (!i) {
jarak = gas[0];
} else if (i == k) {
jarak = s - gas[k - 1];
} else {
jarak = gas[i] - gas[i - 1];
}
int lebih = vc[idx].first - jarak;
if (lebih < 0) return false;
curexcess -= min(curexcess, min(lebih, jarak));
}
if (curexcess > 0) return false;
return true;
}
int main(void) {
scanf("%d", &n);
scanf("%d", &k);
scanf("%d", &s);
scanf("%d", &t);
for (int i = 0; i < n; i++) {
scanf("%d", &vc[i].second);
scanf("%d", &vc[i].first);
}
for (int i = 0; i < k; i++) {
scanf("%d", &gas[i]);
}
excess = max(0, s * 2 - t);
sort(gas, gas + k);
sort(vc, vc + n);
int lo, hi;
lo = 0;
hi = n - 1;
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (can(mid)) {
hi = mid;
} else {
lo = mid + 1;
}
}
if (!can(lo)) {
printf("-1");
} else {
int mini = 1000000000;
for (int i = lo; i < n; i++) {
mini = min(mini, vc[i].second);
}
printf("%d\n", mini);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long double PI = 4 * atan((long double)1);
const long long INF = 1e18;
const long long NINF = -1e18;
long long get_hash(string s) {
long long N = 1000001;
long long base[N], A = 11, MD = 1110111110111;
base[0] = 1;
for (long long i = (1); i < (N); ++i) base[i] = (base[i - 1] * A) % MD;
long long hs = 0;
for (long long i = (0); i < (s.size()); ++i) {
hs += (s[i] * base[i]);
hs %= MD;
}
return hs;
}
long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2) res *= a;
a *= a;
n /= 2;
}
return res;
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while (!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(vector<string> __attribute__((unused)) args,
__attribute__((unused)) long long idx,
__attribute__((unused)) long long LINE_NUM) {
cerr << endl;
}
template <typename Head, typename... Tail>
void debug_out(vector<string> args, long long idx, long long LINE_NUM, Head H,
Tail... T) {
if (idx > 0)
cerr << ", ";
else
cerr << "Line(" << LINE_NUM << ") ";
stringstream ss;
ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k, s, t;
cin >> n >> k >> s >> t;
long long cst[n], cap[n];
for (long long i = (0); i < (n); ++i) cin >> cst[i] >> cap[i];
vector<long long> pp(k + 2);
pp[0] = 0;
for (long long i = (0); i < (k); ++i) cin >> pp[i + 1];
pp[k + 1] = s;
sort(pp.begin(), pp.end());
long long lo = 1, hi = 2 * s;
long long f = 0;
while (lo < hi) {
long long mid = lo + (hi - lo) / 2;
long long time = 0;
long long e = 0;
for (long long i = (0); i < (k + 1); ++i) {
long long dist = pp[i + 1] - pp[i];
if (dist > mid) {
e = 1;
break;
}
long long tspd = mid - dist;
if (tspd > dist) tspd = dist;
time += tspd + 2 * (dist - tspd);
}
if (time > t || e == 1)
lo = mid + 1;
else {
f = 1;
hi = mid;
}
}
if (f == 0) {
cout << -1;
return 0;
}
long long min = lo;
long long mincst = INF;
for (long long i = (0); i < (n); ++i) {
if (cap[i] >= min && cst[i] < mincst) mincst = cst[i];
}
if (mincst != INF)
cout << mincst;
else
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200009;
int n, k;
long long s, t;
struct car {
long long c, v;
car() {}
bool operator<(const car& o) const {
if (v != o.v) return v < o.v;
return c < o.c;
}
} C[MAX];
long long g[MAX];
bool check(long long cap) {
long long ti = 0;
for (int i = 1; i < k; i++) {
long long dist = g[i] - g[i - 1];
if (dist > cap) return false;
if (2 * dist <= cap) {
ti += dist;
continue;
}
ti += (cap - dist) + (dist - (cap - dist)) * 2LL;
}
return ti <= t;
}
long long Min[MAX];
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
cin >> C[i].c >> C[i].v;
}
sort(C, C + n);
reverse(C, C + n);
for (int i = 1; i <= k; i++) cin >> g[i];
g[0] = 0;
g[k + 1] = s;
k += 2;
sort(g, g + k);
Min[0] = C[0].c;
for (int i = 1; i < n; i++) Min[i] = min(Min[i - 1], C[i].c);
int l = 0, r = n - 1, ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (check(C[mid].v)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
if (ans == -1)
cout << -1 << endl;
else
cout << Min[ans] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1LL << 60);
int n, k;
long long s, t;
long long c[200005], v[200005];
long long g[200005];
long long d[200005];
long long d2[200005];
long long sum[200005];
int tot;
bool check(int x) {
int pos = upper_bound(d2, d2 + tot, v[x]) - 1 - d2;
long long tim = sum[pos];
tim = tim + (3LL * (sum[tot - 1] - sum[pos]) - v[x] * (tot - 1 - pos));
return tim <= t;
}
int main() {
scanf("%d%d%I64d%I64d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%I64d%I64d", &c[i], &v[i]);
long long ans = inf;
for (int i = 0; i < k; i++) scanf("%I64d", &g[i]);
sort(g, g + k);
d[0] = g[0];
for (int i = 1; i < k; i++) d[i] = g[i] - g[i - 1];
d[k] = s - g[k - 1];
tot = k + 1;
sort(d, d + tot);
for (int i = 0; i < tot; i++) d2[i] = d[i] * 2;
sum[0] = d[0];
for (int i = 1; i < tot; i++) sum[i] = sum[i - 1] + d[i];
for (int i = 0; i < n; i++) {
if (v[i] < d[tot - 1]) continue;
if (check(i)) ans = min(ans, c[i]);
}
printf("%I64d\n", ans == inf ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, K, s, t, c[200010], v[200010], g[200010];
bool check(long long fuel) {
int i;
long long time = 0;
for (i = 1; i <= K; i++) {
long long d = g[i] - g[i - 1];
long long b = fuel - d;
if (b < 0) return 0;
b = min(b, d);
time += 2 * (d - b) + b;
}
return time <= t;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N >> K >> s >> t;
int i;
for (i = 1; i <= N; i++) cin >> c[i] >> v[i];
for (i = 1; i <= K; i++) cin >> g[i];
g[++K] = s;
sort(g + 1, g + K + 1);
long long l = 1, r = (1LL << 34), mid;
while (l < r) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
int ind = -1;
for (i = 1; i <= N; i++)
if (v[i] >= r) {
if (ind == -1 || c[ind] > c[i]) ind = i;
}
if (ind == -1)
cout << -1 << "\n";
else
cout << c[ind] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
const long long N = 300010;
long long n, k, s, tot, l, r, mid, pos[N], Time;
struct lr {
long long v, c;
bool operator<(const lr &a) const { return c != a.c ? c < a.c : v > a.v; }
} a[N], b[N];
bool check(long long x) {
long long t = 0, s, del;
for (long long i = 1; i <= k; ++i) {
if (t > Time) return 0;
s = pos[i] - pos[i - 1];
if (b[x].v < s) return 0;
del = b[x].v - s;
if (del >= s) {
t += s;
} else {
t += s * 2 - del;
}
}
if (t <= Time) return 1;
return 0;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &k, &s, &Time);
for (long long i = 1; i <= n; ++i) scanf("%I64d%I64d", &a[i].c, &a[i].v);
for (long long i = 1; i <= k; ++i) scanf("%I64d", pos + i);
pos[++k] = s;
std::sort(pos + 1, pos + 1 + k);
std::sort(a + 1, a + 1 + n);
for (long long i = 1; i <= n; ++i)
if (a[i].v <= b[tot].v)
continue;
else
b[++tot] = a[i];
l = 1;
r = tot;
while (l != r) {
mid = l + r >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (l >= tot && !check(l)) return puts("-1"), 0;
printf("%I64d\n", b[l].c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4e18;
const long long N = 2e5 + 10;
void testCase() {
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<long long> cost(n), cap(n), f(k);
for (long long i = 0; i < n; i++) cin >> cost[i] >> cap[i];
for (long long &i : f) cin >> i;
f.push_back(0);
f.push_back(s);
sort(begin(f), end(f));
auto isPos = [&](long long lim) {
long long totslow = t - s;
for (long long i = 1; i <= k + 1; i++) {
long long diff = f[i] - f[i - 1];
long long fast = lim - diff;
if (fast < 0) return false;
long long slow = max(0ll, diff - fast);
totslow -= slow;
if (totslow < 0) return false;
}
return true;
};
long long mi = 0, ma = inf;
while (mi + 1 < ma) {
long long mid = (mi + ma) / 2;
if (isPos(mid))
ma = mid;
else
mi = mid;
}
long long ans = inf;
for (long long i = 0; i < n; i++) {
if (cap[i] >= ma) ans = min(ans, cost[i]);
}
cout << (ans == inf ? -1 : ans) << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
long long t_c = 1;
while (t_c--) testCase();
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void smax(T &first, T second) {
first = max((first), (second));
}
template <class T>
inline void smin(T &first, T second) {
first = min((first), (second));
}
const int maxn = 2e5 + 100, inf = 1e9 + 7;
int c[maxn], v[maxn];
vector<int> first;
long long ps[maxn];
inline long long sm(int l, int r) {
if (r < l) return 0;
return ps[r] - (l ? ps[l - 1] : 0);
}
int main() {
int n, k, s, t;
scanf("%d %d %d %d", &n, &k, &s, &t);
int mx = 0;
for (int(i) = (0); (i) < (n); ++(i)) scanf("%d %d", c + i, v + i);
for (int(i) = (0); (i) < (k); ++(i)) {
int a;
scanf("%d", &a);
first.push_back(a);
}
first.push_back(s);
first.push_back(0);
sort(first.begin(), first.end());
vector<int> second;
for (int(i) = (1); (i) < (first.size()); ++(i)) {
smax(mx, first[i] - first[i - 1]);
second.push_back(first[i] - first[i - 1]);
}
sort(second.begin(), second.end());
long long sum = 0;
for (int(i) = (0); (i) < (second.size()); ++(i)) {
sum += second[i];
ps[i] = sum;
}
int ans = inf;
for (int(i) = (0); (i) < (n); ++(i)) {
if (v[i] < mx) continue;
int e = upper_bound(second.begin(), second.end(), v[i] / 2) -
second.begin() - 1;
long long g = sm(0, e);
long long cnt = max(0, (int)second.size() - e - 1);
g += cnt * v[i] - sm(e + 1, (int)second.size() - 1);
long long T = 2LL * sum - g;
if (T <= t) smin(ans, c[i]);
}
cout << (ans == inf ? -1 : ans) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const long long oo = 1000000000000LL;
long long g[N], c[N], v[N], n, k, s, t;
bool check(long long M) {
long long T = t;
for (int i = 1; i < k; ++i) {
long long len = g[i + 1] - g[i];
long long x = max(0LL, len * 2 - M);
long long y = len - x;
if (y < 0 || T < x * 2 + y || x + 2 * y > M) return false;
T -= x * 2 + y;
}
return T >= 0;
}
long long solve() {
long long L = 0, R = s * 5, res = oo;
while (L <= R) {
long long M = (L + R) >> 1;
if (check(M)) {
res = M;
R = M - 1;
} else
L = M + 1;
}
return res;
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &k, &s, &t);
for (int i = 1; i <= n; ++i) scanf("%I64d%I64d", &c[i], &v[i]);
for (int i = 1; i <= k; ++i) scanf("%I64d", &g[i]);
g[++k] = 0;
g[++k] = s;
sort(g + 1, g + k + 1);
long long G = solve();
long long res = oo;
for (int i = 1; i <= n; ++i)
if (v[i] >= G) res = min(res, c[i]);
if (res == oo)
cout << -1 << endl;
else
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, t, i;
long long a[200010], b[200010], c[200010];
bool node(long long mid) {
long long t1 = 0;
long long s1 = c[0];
if (s1 > mid) {
return 0;
} else if (s1 <= mid && s1 > (mid / (2.0))) {
t1 += 3 * s1 - mid;
} else {
t1 += s1;
}
for (i = 1; i < k; i++) {
s1 = c[i] - c[i - 1];
if (s1 > mid) {
return 0;
} else if (s1 <= mid && s1 > (mid / (2.0))) {
t1 += 3 * s1 - mid;
} else {
t1 += s1;
}
}
s1 = s - c[k - 1];
if (s1 > mid) {
return 0;
} else if (s1 <= mid && s1 > (mid / (2.0))) {
t1 += 3 * s1 - mid;
} else {
t1 += s1;
}
if (t1 <= t) {
return 1;
} else {
return 0;
}
}
int main() {
long long r, l;
r = -1;
l = 1000000000000;
cin >> n >> k >> s >> t;
for (i = 0; i < n; i++) {
cin >> a[i] >> b[i];
r = max(r, b[i]);
l = min(l, b[i]);
}
for (i = 0; i < k; i++) {
cin >> c[i];
}
if (k > 1) {
sort(c, c + k);
}
long long mid;
while (r >= l) {
mid = (r + l) / 2;
if (node(mid) == 1) {
r = mid - 1;
} else {
l = mid + 1;
}
}
long long ans = 0;
if (node(r) == 1) {
ans = r;
} else if (node(l) == 1) {
ans = l;
} else {
ans = 0x3f3f3f3f;
}
long long ans1 = 0x3f3f3f3f;
for (i = 0; i < n; i++) {
if (b[i] >= ans) {
ans1 = min(ans1, a[i]);
}
}
if (ans1 == 0x3f3f3f3f) {
cout << -1 << endl;
} else {
cout << ans1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXNK = 2e5 + 10;
const long long INF = 1e18;
struct abc {
int c, v;
};
abc a[MAXNK];
int p[MAXNK];
int n, k, s;
long long t;
long long fi = INF;
bool cmp1(abc a, abc b) { return a.v < b.v; }
bool ok(int w) {
long long temp = 0;
for (int i = 1; i <= k; i++) {
int cost = (p[i] - p[i - 1]) * 2;
if (cost <= w)
temp += p[i] - p[i - 1];
else {
int ds = p[i] - p[i - 1];
int x, y;
if (w > ds) {
y = w - ds;
x = 2 * (ds - y);
cost = y * 2 + x / 2;
temp += (x + y);
} else {
if (ds == w)
temp += 2 * ds;
else if (w < ds)
return false;
}
}
if (temp > t) return false;
}
return true;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].c, &a[i].v);
p[0] = 0;
for (int i = 1; i <= k; i++) scanf("%d", &p[i]);
sort(a + 1, a + 1 + n, cmp1);
sort(p + 1, p + 1 + k);
k++;
p[k] = s;
int l = 1, r = n, ans = -1;
while (l <= r) {
int m = (l + r) >> 1;
if (ok(a[m].v)) {
ans = m;
r = m - 1;
} else
l = m + 1;
}
if (ans == -1) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
if (a[i].v >= a[ans].v && a[i].c < fi) fi = a[i].c;
}
cout << fi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cout.precision(9);
cout << fixed;
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<long long, long long> > cars(n);
for (int i = 0; i < n; ++i) cin >> cars[i].first >> cars[i].second;
vector<long long> fuels(k);
for (int i = 0; i < k; ++i) {
cin >> fuels[i];
}
sort(fuels.begin(), fuels.end());
while (!fuels.empty() && fuels.back() >= s) {
fuels.pop_back();
--k;
}
fuels.push_back(s);
++k;
vector<long long> f(k);
f[0] = fuels[0];
for (int i = 1; i < k; ++i) f[i] = fuels[i] - fuels[i - 1];
sort(f.begin(), f.end());
vector<long long> sums(k + 1);
sums[0] = 0;
for (int i = 1; i <= k; ++i) sums[i] = sums[i - 1] + f[i - 1];
long long mx = f[k - 1];
long long mnCost = 2000000000;
for (int i = 0; i < n; ++i) {
long long c = cars[i].first;
long long v = cars[i].second;
if (v < mx) continue;
std::vector<long long>::iterator it =
lower_bound(f.begin(), f.end(), v / 2 + (v & 1));
long long time = 0;
if (it == f.end()) {
time = sums[k];
} else {
int num = it - f.begin();
time = 3 * (sums[k] - sums[num]) - (k - num) * v + sums[num];
}
if (time > t) continue;
mnCost = min(mnCost, c);
}
if (mnCost == 2000000000) mnCost = -1;
cout << mnCost << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, ln, ti, a[200069], cp[200069], pst[200069], dis[200069],
ps[200069];
int main() {
long long i, p, sm, z = 1e18;
scanf("%lld%lld%lld%lld", &n, &m, &ln, &ti);
for (i = 1; i <= n; i++) {
scanf("%lld%lld", a + i, cp + i);
}
for (i = 1; i <= m; i++) {
scanf("%lld", pst + i);
}
sort(pst + 1, pst + m + 1);
m++;
pst[m] = ln;
for (i = 1; i <= m; i++) {
dis[i] = pst[i] - pst[i - 1];
}
sort(dis + 1, dis + m + 1);
for (i = 1; i <= m; i++) {
ps[i] = ps[i - 1] + dis[i];
}
for (i = 1; i <= n; i++) {
if (cp[i] >= dis[m]) {
p = upper_bound(dis + 1, dis + m + 1, cp[i] / 2) - dis - 1;
sm = ps[p] + (ps[m] - ps[p]) * 3 - cp[i] * (m - p);
if (sm <= ti) {
z = min(z, a[i]);
}
}
}
if (z == 1000000000000000000) {
z = -1;
}
cout << z;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t;
vector<int> coor;
bool can(int w) {
int tm = 0;
if (coor[0] > w) return 0;
int x = coor[0];
tm += min(x, w - x);
x -= min(x, w - x);
tm += 2 * x;
for (int i = 0; i < k; i++) {
int x = coor[i + 1] - coor[i];
if (x > w) return 0;
tm += min(x, w - x);
x -= min(x, w - x);
tm += 2 * x;
}
if (tm > t) return 0;
return 1;
}
int bin_search() {
int l = -1, r = 1e9 + 1;
while (r - l > 1) {
int m = (r + l) / 2;
if (can(m))
r = m;
else
l = m;
}
return l;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s >> t;
vector<pair<int, int> > car(n);
for (int i = 0; i < n; i++) cin >> car[i].first >> car[i].second;
coor.resize(k);
for (int i = 0; i < k; i++) cin >> coor[i];
coor.push_back(s);
sort(coor.begin(), coor.end());
int w = bin_search();
w++;
int ans = 1e9 + 1;
for (int i = 0; i < n; i++)
if (car[i].second >= w) ans = min(ans, car[i].first);
if (ans == 1e9 + 1)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 10;
int n, m, len, tim;
struct node {
int p, w;
} car[N];
int sta[N];
bool judge(int temp) {
int x = 0, y;
for (int i = 1; i <= m; i++) {
y = sta[i] - sta[i - 1];
if (y > temp) return false;
x += (y * 2 - (temp - y > y ? y : temp - y));
}
y = len - sta[m];
if (y > temp) return false;
x += (y * 2 - (temp - y > y ? y : temp - y));
if (x <= tim) return true;
return false;
}
int solve(int temp) {
int ans = 1e9 + 10, s = -1;
for (int i = 0; i < n; i++)
if (car[i].w >= temp && car[i].p < ans) {
ans = car[i].p;
s = i;
}
return s;
}
int main() {
cin >> n >> m >> len >> tim;
for (int i = 0; i < n; i++) scanf("%d%d", &car[i].p, &car[i].w);
for (int i = 1; i <= m; i++) scanf("%d", &sta[i]);
sta[0] = 0;
sort(sta + 1, sta + m + 1);
int high = 1e9 + 1, low = 0;
while (high > low) {
int mid = (high + low) >> 1;
if (judge(mid))
high = mid;
else
low = mid + 1;
}
int temp = solve(high);
printf("%d\n", temp == -1 ? temp : car[temp].p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long time_estim(const vector<long long> &x, long long t, long long s,
long long cand) {
long long ans = 0;
long long cur = 0;
long long k = x.size();
for (long long i = 0; i <= k && x[i] <= s; i++) {
long long next;
if (i == k || x[i] >= s) {
next = s;
} else {
next = x[i];
}
long long diff = next - cur;
if (cand < diff) return -1;
long long fast = min(cand - diff, diff);
long long slow = diff - fast;
long long total_time = fast + slow * 2;
ans += total_time;
cur = next;
}
if (cur != s) {
long long diff = s - cur;
if (cand < diff) return -1;
long long fast = min(cand - diff, diff);
long long slow = diff - fast;
long long total_time = fast + slow * 2;
ans += total_time;
}
if (ans > t) {
return -1;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<long long, long long> > c(n);
vector<long long> x(k);
long long min_c = 1e9 + 1;
long long max_c = -1;
for (long long i = 0; i < n; i++) {
cin >> c[i].first >> c[i].second;
if (c[i].second > max_c) max_c = c[i].second;
if (c[i].second < min_c) min_c = c[i].second;
}
for (long long i = 0; i < k; i++) {
cin >> x[i];
}
sort(x.begin(), x.end());
long long l = min_c;
long long r = max_c;
long long mid;
while (l < r) {
mid = (l + r) / 2;
if (time_estim(x, t, s, mid) == -1) {
l = mid + 1;
} else {
r = mid;
}
}
if (time_estim(x, t, s, l) == -1) {
cout << -1 << endl;
return 0;
}
long long min_p = 1e12;
for (long long i = 0; i < n; i++) {
if (c[i].second >= l && c[i].first < min_p) {
min_p = c[i].first;
}
}
if (min_p == 1e12)
cout << -1 << endl;
else
cout << min_p << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, u, v, q, r, ql, qr, k, l, s, w, z, x, y, d, p, c, b;
const int N = 2e5 + 500;
const int SN = 300;
const int NN = 1e4 + 4;
const long long mod = 10007;
const long long INF = 1LL << 52LL;
long long C[N], V[N], G[N];
vector<long long> S;
vector<long long> SS;
long long ss[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; ++i) cin >> C[i] >> V[i];
for (int i = 0; i < k; ++i) {
cin >> G[i];
}
sort(G, G + k);
S.push_back(G[0]);
S.push_back(s - G[k - 1]);
long long fn = max(G[0], s - G[k - 1]);
for (int i = 0; i < k - 1; ++i) {
S.push_back(G[i + 1] - G[i]);
fn = max(fn, G[i + 1] - G[i]);
}
sort(S.begin(), S.end());
SS.resize(S.size());
SS[0] = S[0];
for (int i = 1; i < S.size(); ++i) SS[i] = SS[i - 1] + S[i];
long long sol = INF;
for (int i = 1; i <= n; ++i) {
if (fn > V[i]) continue;
long long sum = 2 * SS.back();
int x = (upper_bound(S.begin(), S.end(), V[i] / 2) - S.begin() - 1);
sum -= x >= 0 ? SS[x] : 0;
sum -= (SS.size() - x - 1) * V[i] - (SS.back() - (x >= 0 ? SS[x] : 0));
if (sum > t)
continue;
else
sol = min(sol, C[i]);
}
if (sol == INF) sol = -1;
cout << sol << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[200010], v[200010], k;
long long int g[200010];
long long int fun(long long int f) {
long long int ret = 0, prev = 0, temp;
for (int i = 0; i < k; i++) {
if (f < g[i] - prev) return INT_MAX;
temp = min(f - (g[i] - prev), (g[i] - prev));
ret += 2 * ((g[i] - prev) - temp) + temp;
prev = g[i];
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
int n, ans = INT_MAX;
long long int s, t, start, end, mid;
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) cin >> c[i] >> v[i];
for (int i = 0; i < k; i++) cin >> g[i];
sort(g, g + k);
g[k++] = s;
start = 1;
end = 2 * s;
while (start < end) {
mid = start + (end - start) / 2;
if (fun(mid) > t)
start = mid + 1;
else
end = mid;
}
if (fun(start) > t)
cout << "-1\n";
else {
for (int i = 0; i < n; i++)
if (v[i] >= start) ans = min(ans, c[i]);
if (ans == INT_MAX)
cout << "-1\n";
else
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, L, T, ans;
int car[200010][2], gas[200010];
bool check(int fuel) {
int i, d, t = 0;
for (i = 1; i <= K; i++) {
d = gas[i] - gas[i - 1];
if (d * 2 <= fuel)
t += d;
else if (d > fuel)
return false;
else
t += (fuel - d) + 2 * (2 * d - fuel);
}
return t <= T;
}
int work() {
int head = 1, tail = 1e9 + 7, mid;
while (head < tail) {
mid = (head + tail) >> 1;
if (check(mid))
tail = mid;
else
head = mid + 1;
}
return head;
}
int main() {
int i, lim;
scanf("%d%d%d%d", &n, &K, &L, &T);
for (i = 1; i <= n; i++) scanf("%d%d", &car[i][0], &car[i][1]);
for (i = 1; i <= K; i++) scanf("%d", &gas[i]);
sort(gas + 1, gas + 1 + K);
gas[++K] = L;
lim = work();
ans = 1e9 + 7;
for (i = 1; i <= n; i++)
if (car[i][1] >= lim) ans = min(ans, car[i][0]);
printf("%d", ans < 1e9 + 7 ? ans : -1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1e6 + 5;
long long int wynik[max_n];
int main() {
int(n), (k);
scanf("%d%d", &(n), &(k));
;
int(s), (t);
scanf("%d%d", &(s), &(t));
;
vector<pair<int, int> > cars;
for (int i = (0); i < (n); ++i) {
int(a), (b);
scanf("%d%d", &(a), &(b));
;
cars.push_back(make_pair(b, a));
}
vector<int>(v);
for (int i = (0); i < ((k)); ++i) {
int(a);
scanf("%d", &(a));
;
(v).push_back(a);
};
sort((v).begin(), (v).end());
int start = 0, meta = s;
vector<int> x;
for (int i = (0); i < (k); ++i) {
if (i == 0)
x.push_back(v[i]);
else
x.push_back(v[i] - v[i - 1]);
}
x.push_back(meta - v[k - 1]);
sort((x).begin(), (x).end());
sort((cars).begin(), (cars).end());
int best = 1e9 + 5;
for (int i = (0); i < (cars.size()); ++i) {
if (cars[i].first < x.back()) continue;
wynik[i] = 3LL * s - cars[i].first * 1LL * x.size();
}
long long int minus = 0;
int ile = 0;
int xpos = 0;
for (int i = (0); i < (cars.size()); ++i) {
if (cars[i].first < x.back()) continue;
while (xpos < x.size() && cars[i].first >= 2 * x[xpos]) {
ile++;
minus += 2 * x[xpos];
xpos++;
}
wynik[i] += cars[i].first * 1LL * ile - minus;
if (wynik[i] <= t) {
best = min(best, cars[i].second);
}
}
if (best == 1e9 + 5)
printf("-1\n");
else
printf("%d\n", best);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
const int INF = 0x63636363;
int n, k, s, t;
int c[N], v[N];
int g[N];
bool ok(int fuel) {
int pos = 0;
long long total_time = 0;
for (int i = 0; i <= k; i++) {
if (g[i] - pos > fuel) {
return false;
}
if (fuel >= 2 * (g[i] - pos)) {
total_time += g[i] - pos;
} else {
long long rem = fuel % (g[i] - pos);
total_time += rem + 2 * (g[i] - pos - rem);
}
pos = g[i];
}
return total_time <= t;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
vector<int> tanks;
for (int i = 0; i < n; i++) {
scanf("%d%d", &c[i], &v[i]);
tanks.push_back(v[i]);
}
for (int i = 0; i < k; i++) {
scanf("%d", &g[i]);
}
sort(g, g + k);
g[k] = s;
sort(tanks.begin(), tanks.end());
int begin = 0, end = tanks.size() - 1;
if (ok(tanks[end])) {
while (begin != end) {
int mid = (begin + end) / 2;
if (ok(tanks[mid])) {
end = mid;
} else {
begin = mid + 1;
}
}
int minimum = INF;
for (int i = 0; i < n; i++) {
if (v[i] >= tanks[begin] && c[i] < minimum) {
minimum = c[i];
}
}
printf("%d\n", minimum == INF ? -1 : minimum);
} else {
printf("-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, t, g[2 * 100005], l, r, mid, ans = 1e9 + 7;
pair<long long, long long> c[2 * 100005];
bool ck(long long x) {
unsigned long long str = 1, tim = 0;
for (int i = 0; i < k + 1; i++) {
if (x < (g[i] - str) + 1 || tim > t)
return false;
else {
long long q = (g[i] - str) + 1;
tim += min(x - q, q) + ((q - min(x - q, q)) * (long long)2);
str = g[i] + 1;
}
}
if (tim <= t)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) cin >> c[i].second >> c[i].first;
for (int i = 0; i < k; i++) cin >> g[i];
sort(g, g + k);
g[k] = s;
l = 1, r = 1e9 + 3;
while (l < r) {
mid = (l + r) / 2;
if (ck(mid) == false)
l = mid + 1;
else
r = mid;
}
for (int i = 0; i < n; i++) {
if (c[i].first >= l && ans > c[i].second) ans = c[i].second;
}
if (ans != 1e9 + 7)
cout << ans;
else
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<long long, long long> > vec;
for (int i = 0; i < n; i++) {
long long a, b;
cin >> a >> b;
vec.push_back({a, b});
}
sort(vec.begin(), vec.end());
long long dis[k + 2];
dis[0] = 0;
for (int i = 1; i <= k; i++) {
cin >> dis[i];
}
dis[k + 1] = s;
sort(dis, dis + k + 2);
long long mx = 0;
vector<long long> re;
for (int i = 1; i < k + 2; i++) {
mx = max(mx, dis[i] - dis[i - 1]);
re.push_back(dis[i] - dis[i - 1]);
}
sort(re.begin(), re.end());
if (t < s * 2) {
long long num = (s * 2) - t;
long long st = 0, en = 1e9, m, ans = -1;
while (st <= en) {
m = (st + en) / 2;
long long v = 0;
for (int i = 0; i < re.size(); i++) {
long long f = (m - re[i]);
if (f > re[i])
v += (re[i]);
else if (f >= 0)
v += ((re[i] - f) * 2 + f);
else
v += (1e9);
}
if (v <= t) {
ans = m;
en = m - 1;
} else
st = m + 1;
}
mx = ans;
}
if (mx == -1) return cout << -1, 0;
for (int i = 0; i < vec.size(); i++) {
if (vec[i].second >= mx) return cout << vec[i].first, 0;
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct car {
long long c, v;
} a[200005];
long long b[200005];
vector<long long> vc;
int main() {
int n, k;
long long s, t;
scanf("%d%d%lld%lld", &n, &k, &s, &t);
for (int i = 0; i < n; i++) {
long long c, v;
scanf("%lld%lld", &c, &v);
a[i] = {c, v};
}
for (int i = 1; i <= k; i++) scanf("%lld", b + i);
b[k + 1] = s;
sort(b + 1, b + k + 1);
long long accels = max(s + s - t, 0LL);
if (accels > s) {
printf("-1");
return 0;
}
for (int i = 0; i <= k; i++) {
vc.push_back(b[i + 1] - b[i]);
}
sort(vc.begin(), vc.end());
long long p = vc.back(), q = s + 1;
while (p <= q) {
long long mid = (p + q) / 2, boosts = 0;
bool valid = true;
for (long long x : vc) {
boosts += min(mid - x, x);
}
if (boosts < accels)
p = mid + 1;
else
q = mid - 1;
}
long long fuels = p;
if (q >= s + 1) {
printf("-1");
return 0;
}
long long ans = (1LL << 62);
for (int i = 0; i < n; i++) {
if (a[i].v >= fuels) ans = min(ans, a[i].c);
}
if (ans == (1LL << 62))
printf("-1");
else
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 200200;
using namespace std;
int n, k, s, t;
int c[N];
int v[N];
vector<int> g;
bool f(int x) {
long long cnt = s + s;
for (int i = 0; i + 1 < g.size(); i++) {
if (g[i + 1] - g[i] > x) return false;
int l = x - (g[i + 1] - g[i]);
cnt -= min(g[i + 1] - g[i], l);
}
return cnt <= t;
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%d%d", &c[i], &v[i]);
g.push_back(0);
g.push_back(s);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
g.push_back(x);
}
sort(g.begin(), g.end());
int l = 0, r = 1e9 + 1;
while (l < r) {
int m = (l + r) / 2;
if (f(m))
r = m;
else
l = m + 1;
}
int ans = 1e9 + 1;
for (int i = 1; i <= n; i++)
if (v[i] >= l) ans = min(ans, c[i]);
if (ans == 1e9 + 1) ans = -1;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxv = 1000000000;
const int maxn = 200000 + 10;
const int maxk = 200000 + 10;
struct Car {
int c, v;
bool operator<(const Car &x) const { return c < x.c; }
};
Car cars[maxn];
int p[maxk], d[maxk];
bool ok(int v, int k, int t) {
int r = 0;
for (int i = k; i >= 0; i--) {
if (d[i] > v) return false;
if (v / 2 >= d[i])
r += d[i];
else
r += d[i] + d[i] - v + d[i];
}
return r <= t;
}
int main() {
int n, k, s, t;
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%d%d", &cars[i].c, &cars[i].v);
sort(cars + 1, cars + 1 + n);
p[0] = 0;
for (int i = 1; i <= k; i++) scanf("%d", &p[i]);
sort(p + 1, p + 1 + k);
p[k + 1] = s;
for (int i = 0; i <= k; i++) d[i] = p[i + 1] - p[i];
sort(d, d + k + 1);
int L = 1, R = maxv, M, c = maxv + 1;
while (L <= R) {
M = (L + R) / 2;
if (ok(M, k, t)) {
c = M;
R = M - 1;
} else
L = M + 1;
}
for (int i = 1; i <= n; i++) {
if (cars[i].v >= c) {
printf("%d\n", cars[i].c);
return 0;
}
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t, c[200005], v[200005], g[200005], mg, ans = 1e9 + 1, mv;
bool ck(int v) {
if (v < mg) return 0;
int tol = 0;
for (int i = 1; i <= k + 1; i++) {
tol += max(g[i], 3 * g[i] - v);
if (tol > t) return 0;
}
return 1;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%d%d", c + i, v + i);
for (int i = 1; i <= k; i++) scanf("%d", g + i);
sort(g + 1, g + k + 1);
g[k + 1] = s;
mg = 0;
for (int i = k + 1; i; i--) mg = max(mg, g[i] -= g[i - 1]);
int l = 0, r = 1e9, m;
while (l <= r) {
m = (l + r) / 2;
if (ck(m)) {
r = m - 1;
mv = m;
} else {
l = m + 1;
}
}
if (mv)
for (int i = 1; i <= n; i++)
if (v[i] >= mv) ans = min(ans, c[i]);
if (ans > 1e9) ans = -1;
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, k, w, need, ans, tmp, s, t;
int A[200005], B[200005], G[200005];
int high, low, mid;
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = (0); i < (n); i++) scanf("%d %d", &A[i], &B[i]);
for (int i = (0); i < (k); i++) scanf("%d", &G[i]);
sort(G, G + k);
high = 1000000001;
low = 0;
need = s * 2 - t;
if (need <= 0) need = 0;
G[k] = s;
while (high - low > 1) {
mid = (high + low) / 2;
x = 0;
y = 1;
tmp = 0;
for (int i = (0); i < (k + 1); i++) {
if ((G[i] - x) * 2 <= mid)
tmp += (G[i] - x);
else if ((G[i] - x) > mid) {
y = 0;
break;
} else
tmp += (mid - (G[i] - x));
x = G[i];
}
if (y == 0)
low = mid;
else if (tmp >= need)
high = mid;
else
low = mid;
}
ans = 1234567890;
for (int i = (0); i < (n); i++)
if (B[i] >= high) ans = min(ans, A[i]);
if (ans == 1234567890) ans = -1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = (int)2e5 + 10;
pair<int, int> v[maxn];
int pos[maxn];
int n, k, s, t;
bool check(int sp) {
int now = 0;
long long tm = 0;
for (int i = 0; i < k; i++) {
int x = pos[i] - now;
int b = sp - x;
int a = 0;
if (sp < x) {
return false;
}
if (b < 0) {
b = 0;
a = x;
} else if (b > x) {
b = x;
} else {
a = x - b;
}
tm += 2 * a + b;
now = pos[i];
}
return tm <= t;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
scanf("%d %d", &v[i].second, &v[i].first);
}
sort(v, v + n);
for (int i = 0; i < k; i++) {
scanf("%d", &pos[i]);
}
sort(pos, pos + k);
pos[k] = s;
k++;
int l = 0;
int r = n;
while (l != r) {
int m = (l + r) / 2;
if (check(v[m].first)) {
r = m;
} else {
l = m + 1;
}
}
if (l == n) {
cout << -1 << endl;
return 0;
}
int ans = v[l].second;
for (int i = l + 1; i < n; i++) {
ans = min(ans, v[i].second);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
inline unsigned long long bit(int num) { return 1ull << num; }
long long T;
vector<int> ds;
bool Can(long long v) {
if (ds.back() > v) return false;
long long t = 0;
for (int i = 0; i < int(ds.size()); ++i) {
long long d = ds[i];
long long t1 = 4 * d - 2 * v;
long long t2 = v - d;
if (t1 < 0) {
t += d;
} else {
t += t1 + t2;
}
}
return t <= T;
}
long long Bins(long long l, long long r) {
while (l < r) {
long long m = (l + r) / 2;
if (!Can(m)) {
l = m + 1;
} else {
r = m;
}
}
return l;
}
int main() {
long long n, k, s;
cin >> n >> k >> s >> T;
vector<pair<long long, long long> > cars(n);
vector<long long> pts(k);
ds.resize(k + 1);
for (int i = 0; i < int(n); ++i) {
cin >> cars[i].first >> cars[i].second;
}
for (int i = 0; i < int(k); ++i) {
cin >> pts[i];
}
sort((pts).begin(), (pts).end());
pts.push_back(s);
ds[0] = pts[0];
for (int i = 0; i < int(k); ++i) {
ds[i + 1] = pts[i + 1] - pts[i];
}
sort((ds).begin(), (ds).end());
long long l = 0;
long long r = 1e14;
long long minV = Bins(l, r);
long long res = LLONG_MAX;
for (int i = 0; i < int(n); ++i) {
long long cost = cars[i].first;
long long v = cars[i].second;
if (v >= minV) {
res = min(res, cost);
}
}
if (res == LLONG_MAX) res = -1;
cout << res << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.