text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
void read(vector<long long> &v) {
for (int i = 0; i < v.size(); i++) cin >> v[i];
}
void print(vector<long long> v) {
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
}
long long n, m, a, b, temp, x, y;
string str;
vector<long long> stations;
vector<pair<long long, long long> > cars;
long long t, k, s;
bool car(int mid) {
long long dist = 0;
long long time = 0;
for (int i = 0; i < m; i++) {
if (stations[i] - dist <= (cars[mid].first) / 2) {
time += stations[i] - dist;
dist = stations[i];
continue;
} else if (stations[i] - dist > cars[mid].first)
return 0;
else {
temp = cars[mid].first;
time += 2 * (stations[i] - dist);
temp -= (stations[i] - dist);
time -= temp;
dist = stations[i];
continue;
}
}
if (time <= t) return 1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> s >> t;
cars.resize(n);
for (int i = 0; i < n; i++) {
cin >> cars[i].second >> cars[i].first;
}
sort(cars.begin(), cars.end());
stations.resize(k);
read(stations);
sort(stations.begin(), stations.end());
stations.push_back(s);
m = stations.size();
int l = 0;
int r = n - 1;
int mid;
while (l <= r) {
mid = (l + r) / 2;
if (car(mid))
r = mid - 1;
else
l = mid + 1;
}
if (!car(n - 1)) {
cout << -1;
return 0;
}
long long mi = 1000000000000000000;
for (int i = l; i < n; i++) {
mi = min(mi, cars[i].second);
}
cout << mi;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k, s, m;
cin >> n >> k >> s >> m;
vector<pair<long long, long long> > a(n);
for (long long i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a.begin(), a.end());
for (long long i = 1; i < n; i++)
a[i].second = max(a[i].second, a[i - 1].second);
vector<long long> b(k);
for (long long i = 0; i < k; i++) cin >> b[i];
b.push_back(0);
b.push_back(s);
k += 2;
sort(b.begin(), b.end());
long long l = 0, r = n;
while (l != r) {
long long t = (l + r) / 2;
long long v = a[t].second;
long long q = 0;
bool good = true;
for (long long i = 0; i < k - 1; i++) {
long long d = b[i + 1] - b[i];
if (d > v) {
good = false;
break;
}
q += max(d, d * 2 - (v - d));
}
if (good && q <= m)
r = t;
else
l = t + 1;
}
if (l == n)
cout << -1;
else
cout << a[l].first;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 10;
long long n, k, s, t, a[N], b[N], p[N];
bool ok(long long x) {
if (p[0] > x || s - p[k - 1] > x) return false;
long long num = 0;
num += min(p[0], x - p[0]);
num += min(s - p[k - 1], x - (s - p[k - 1]));
for (int i = 1; i <= k - 1; i++) {
if (p[i] - p[i - 1] > x) return false;
num += min(p[i] - p[i - 1], x - (p[i] - p[i - 1]));
}
if (2 * s - num <= t) return true;
return false;
}
long long bs(long long s, long long e) {
if (e - s < 2) return s;
long long mid = (s + e) / 2;
if (ok(mid - 1)) return bs(s, mid);
return bs(mid, e);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (int i = 0; i <= n - 1; i++) cin >> a[i] >> b[i];
for (int i = 0; i <= k - 1; i++) cin >> p[i];
sort(p, p + k);
long long v = bs(0, (1000 * 1000 * 1000) + 10);
long long ind = -1;
for (int i = 0; i <= n - 1; i++)
if (b[i] >= v && (ind == -1 || a[ind] > a[i])) ind = i;
if (ind == -1)
cout << -1 << endl;
else
cout << a[ind] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 3e5;
vector<int> g[N];
int a[N];
long long c[N], f[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i, k, j, s, n;
long long t;
cin >> n >> k >> s >> t;
for (i = 0; i < n; i++) cin >> c[i] >> f[i];
vector<int> A(k, 0);
for (i = 0; i < k; i++) {
cin >> A[i];
}
A.push_back(0);
A.push_back(s);
sort(A.begin(), A.end());
multiset<pair<long long, long long> > my, fin;
map<long long, long long> id;
map<long long, int> no;
long long mx = 0;
for (i = 0; i < k + 1; i++) {
long long val = A[i + 1] - A[i];
mx = max(mx, val);
my.insert({val, 2 * val});
no[val]++;
}
int T = 1;
long long pre = 0;
for (auto x : no) pre += x.second, id[x.first] = pre;
pre = 0;
my.insert({0, 0});
for (auto &cur : my) {
pre += cur.second;
fin.insert({cur.first, pre});
}
long long ans = mod * 1LL * mod;
long long inf = ans;
fin.insert({inf, inf});
for (i = 0; i < n; i++) {
if (f[i] < mx) continue;
long long fuel = f[i];
long long cur = 3 * s - (k + 1) * fuel;
long long key = fuel / 2;
auto it = fin.lower_bound({key, inf});
if (it == fin.begin() or it == fin.end()) {
if (cur <= t) ans = min(ans, c[i] + 0LL);
continue;
}
if (it->first != key) it--;
pair<long long, long long> add = *it;
cur -= add.second;
cur += fuel * id[add.first];
if (cur <= t) ans = min(ans, c[i] + 0LL);
}
ans = ans == inf ? -1 : ans;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long max_ull = 18446744073709551615ull;
const long long max_ll = 9223372036854775807ll;
unsigned long long nextInt() {
unsigned long long sum = 0;
char a;
while (true) {
a = getchar();
if (a < '0' || a > '9') return sum;
sum = sum * 10 + (unsigned long long)(a - '0');
}
}
vector<pair<long long, long long> > g, g2;
long long n, k, s, t, ans = -1, mxb = 0, gas[200050], l, r, m;
int main() {
n = nextInt();
k = nextInt();
s = nextInt();
t = nextInt();
g.resize(n);
for (int i = 0; i < n; i++) {
g[i].first = nextInt();
g[i].second = nextInt();
}
for (int i = 0; i < k; i++) gas[i] = nextInt();
gas[k] = s;
sort(gas, gas + k);
k++;
sort(g.begin(), g.end());
for (int i = 0; i < n; i++)
if (g[i].second > mxb) {
g2.push_back(g[i]);
mxb = g[i].second;
}
l = 0;
r = g2.size() - 1;
while (l <= r) {
m = (l + r) / 2;
long long time = 0, hg = g2[m].second, lst_x = 0;
for (int i = 0; i < k; i++) {
if (hg < gas[i] - lst_x) {
time = t + 2;
break;
}
hg -= gas[i] - lst_x;
time += (gas[i] - lst_x) * 2;
time -= min(hg, gas[i] - lst_x);
hg = g2[m].second;
lst_x = gas[i];
}
if (time <= t) {
ans = g2[m].first;
r = m - 1;
} else
l = m + 1;
}
printf("%d\n", (int)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Car {
long long cost, cap;
bool operator<(const Car& rhs) const {
return cap < rhs.cap || (cap == rhs.cap && cost > rhs.cost);
}
};
const long long N = 1e6;
long long n, K, s, t;
long long gas[N];
bool check(long long cap) {
long long spent = 0;
for (long long i = 1; i < K; i++) {
long long dist = gas[i] - gas[i - 1];
if (dist > cap) return false;
long long acc = min(cap - dist, dist);
spent += acc + (dist - acc) * 2;
}
return spent <= t;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> K >> s >> t;
vector<Car> cars(n);
for (long long i = 0; i < n; i++) {
cin >> cars[i].cost >> cars[i].cap;
}
gas[0] = 0;
for (long long i = 1; i <= K; i++) cin >> gas[i];
K++;
sort(gas, gas + K);
gas[K++] = s;
long long l = 0, r = 1e9 + 7;
while (l < r) {
long long mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (l == 1e9 + 7)
cout << -1 << endl;
else {
long long ans = 1e9 + 7;
for (long long i = 0; i < n; i++)
if (cars[i].cap >= l) ans = min(ans, cars[i].cost);
if (ans == 1e9 + 7)
cout << -1 << endl;
else
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 9, INF = 1e9 + 2;
long long ar[MAX], par[MAX], c[MAX], v[MAX], n, k, s, t, ans = INF;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
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 >> ar[i];
sort(ar, ar + k), ar[k] = s;
for (int i = k - 1; i >= 0; i--) ar[i + 1] -= ar[i];
sort(ar, ar + k + 1);
for (int i = 1; i <= k + 1; i++) par[i] = par[i - 1] + ar[i - 1];
for (int i = 0; i < n; i++)
if (ar[k] <= v[i]) {
long long pos = upper_bound(ar, ar + k + 1, v[i] / 2) - ar;
long long tmp =
2 * s - par[pos] - (k + 1 - pos) * v[i] + (par[k + 1] - par[pos]);
if (tmp <= t) ans = min(ans, c[i]);
}
if (ans == INF)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
int n, k, s, t, pr[N + 2], cp[N + 2], gs[N + 2];
bool ok(int cc) {
int tm = 0;
for (int i = 1; i <= k; i++) {
int ds = gs[i] - gs[i - 1];
tm += ds * 2 - min(ds, cc - ds);
}
return tm <= t;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) cin >> pr[i] >> cp[i];
for (int i = 1; i <= k; i++) cin >> gs[i];
sort(gs + 1, gs + k + 1);
int lo = 0, hi = 1e9, md;
++k;
gs[k] = s;
for (int i = 1; i <= k; i++) lo = max(lo, gs[i] - gs[i - 1]);
while (hi - lo > 1) {
md = (lo + hi) / 2;
if (ok(md))
hi = md;
else
lo = md;
}
for (md = lo; md <= hi; md++)
if (ok(md)) break;
int ans = 2e9;
for (int i = 1; i <= n; i++) {
if (cp[i] >= md) ans = min(ans, pr[i]);
}
if (ans > 1e9) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t;
vector<pair<int, int> > vec;
vector<int> gas;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> k >> s >> t;
vec.resize(n);
gas.resize(k + 1);
gas[0] = 0;
for (int i = 0; i < n; i++) cin >> vec[i].second >> vec[i].first;
sort(vec.begin(), vec.end());
for (int i = 1; i <= k; i++) cin >> gas[i];
gas.push_back(s);
sort(gas.begin(), gas.end());
int s = 0, e = n - 1, ans = n + 1;
while (s <= e) {
int mid = (s + e) / 2;
int tank = vec[mid].first, tim = 0;
bool flag = 0;
for (int i = 0; i < gas.size() - 1; i++) {
int dis = gas[i + 1] - gas[i];
if (tank < dis) {
flag = 1;
break;
}
if (dis * 2 <= tank) {
tim += dis;
if (tim > t) {
flag = 1;
break;
}
continue;
}
int z = tank - dis;
tim += z;
tim += 2 * (dis - z);
if (tim > t) {
flag = 1;
break;
}
}
if (flag)
s = mid + 1;
else
e = mid - 1, ans = min(ans, mid);
}
if (ans == n + 1) return cout << -1, 0;
int mi = 1e9;
for (int i = ans; i < n; i++) {
mi = min(mi, vec[i].second);
}
cout << mi;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t;
int c[300000], v[300000], g[300000];
int check(int p) {
int d = g[0], cost = 0;
if (p < d) return 0;
if (p >= 2 * d)
cost += d;
else
cost += 2 * (2 * d - p) + p - d;
for (int i = 1; i <= k; i++) {
d = g[i] - g[i - 1];
if (p < d) return 0;
if (p >= 2 * d)
cost += d;
else
cost += 2 * (2 * d - p) + p - d;
}
return cost <= 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);
for (int i = 0; i < k; i++) scanf("%d", g + i);
sort(g, g + k);
g[k] = s;
long long l = 0, r = 2 * s, mid;
while (l + 1 < r) {
mid = (l + r) / 2;
if (check((int)mid))
r = mid;
else
l = mid;
}
if (!check(r)) {
printf("-1\n");
} else {
int minv = (int)r, ans = -1;
for (int i = 0; i < n; i++)
if (v[i] >= minv && (ans == -1 || (ans > 0 && c[i] < ans))) ans = c[i];
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e14 + 10;
long long n, k, s, t, maxV = 0;
long long temp1, temp2;
map<long long, long long> cars;
vector<long long> stops;
vector<long long> dis;
bool check(long long v) {
double time = 0;
for (long long j = 0; j < dis.size(); j++) {
if (1.0 * v / 2 >= dis[j]) {
time += 1.0 * dis[j] / 2;
} else {
time += 1.0 * (3 * dis[j] - v) / 2;
}
if (time * 2 > t) {
return false;
}
}
return true;
}
long long search(long long start, long long end) {
if (start > end) {
return -1;
}
long long mid = (start + end) / 2;
if (check(mid)) {
long long next = search(start, mid - 1);
if (next != -1) {
return next;
} else {
return mid;
}
} else {
return search(mid + 1, end);
}
}
int main() {
scanf("%I64d %I64d %I64d %I64d", &n, &k, &s, &t);
for (long long i = 0; i < n; i++) {
scanf("%I64d %I64d", &temp1, &temp2);
if (cars[temp1] <= temp2) {
cars[temp1] = temp2;
}
maxV = max(maxV, temp2);
}
stops.push_back(0);
for (long long i = 0; i < k; i++) {
scanf("%I64d", &temp1);
stops.push_back(temp1);
}
stops.push_back(s);
sort(stops.begin(), stops.end());
long long maxD = 0;
for (long long i = 1; i < stops.size(); i++) {
temp1 = stops[i] - stops[i - 1];
dis.push_back(temp1);
maxD = max(temp1, maxD);
}
long long v = search(0, maxV);
if (v == -1) {
cout << -1;
return 0;
} else {
v = max(maxD, v);
}
long long currentV = 0;
for (auto i : cars) {
if (i.second >= v) {
cout << i.first;
return 0;
}
}
cout << -1;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int cars_cnt, fs_cnt, distance, til_time;
cin >> cars_cnt >> fs_cnt >> distance >> til_time;
vector<pair<int, int>> cars;
cars.reserve(cars_cnt);
for (int i = 0; i < cars_cnt; i++) {
int ci, vi;
cin >> ci >> vi;
cars.push_back(make_pair(vi, ci));
}
vector<int> gas_stations;
gas_stations.reserve(fs_cnt);
for (int i = 0; i < fs_cnt; i++) {
int tmp;
cin >> tmp;
gas_stations.push_back(tmp);
}
gas_stations.push_back(distance);
sort(gas_stations.begin(), gas_stations.end());
sort(cars.begin(), cars.end());
int l = -1, r = cars_cnt, m;
while (r - l > 1) {
m = l + (r - l) / 2;
int t = 0;
int fuel_max = cars[m].first;
int p = 0;
int dist = 0;
bool ok = true;
while (p < gas_stations.size()) {
int travel = gas_stations[p] - dist;
if (travel > fuel_max) {
ok = false;
break;
}
t += 2 * travel - min(travel, fuel_max - travel);
dist = gas_stations[p];
p++;
}
if (t <= til_time && ok) {
r = m;
} else {
l = m;
}
}
int mm = 1000000001;
for (int i = r; i < cars_cnt; i++) {
if (cars[i].second < mm) {
mm = cars[i].second;
}
}
if (mm == 1000000001) {
cout << -1 << endl;
} else {
cout << mm << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t N = 1e6, M = 1e10;
int64_t c[N], v[N], g[N], d[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int64_t n, k, s, t, h, l, m, r = M;
cin >> n >> k >> s >> t;
for (int64_t i = 0; i < n; i++) cin >> c[i] >> v[i];
for (int64_t i = 1; i <= k; i++) cin >> g[i];
g[k + 1] = s;
sort(g, g + k + 2);
for (int64_t i = 1; i < k + 2; i++) d[i] = g[i] - g[i - 1];
sort(d + 1, d + k + 2);
h = 2 * (l = d[k + 1]) + 1;
while (l < h) {
m = (l + h) / 2, s = 0;
for (int64_t i = 1; i < k + 2; i++) s += 3 * d[i] - min(m, 2 * d[i]);
if (s > t)
l = m + 1;
else
h = m;
}
if (l == 2 * d[k + 1] + 1) return cout << -1, 0;
for (int64_t i = 0; i < n; i++)
if (v[i] >= l) r = min(r, c[i]);
cout << (r == M ? -1 : r);
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::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> > a(n);
for (long long i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort((a).begin(), (a).end());
vector<long long> b(k);
for (long long i = 0; i < k; i++) cin >> b[i];
b.push_back(0);
b.push_back(s);
sort((b).begin(), (b).end());
vector<long long> pref(n + 1, 0);
for (long long i = 0; i < n; i++) pref[i + 1] = max(pref[i], a[i].second);
long long l = -1, r = n;
while (l + 1 < r) {
long long m = (l + r) / 2;
long long ttime = 0, tmp = pref[m + 1];
for (long long j = 1; j < b.size(); j++) {
long long c = b[j] - b[j - 1];
if (tmp < c) {
ttime = 1e18;
break;
}
long long z = min(c, tmp - c);
ttime += z * 1 + (c - z) * 2;
}
if (ttime <= t)
r = m;
else
l = m;
}
cout << (r == n ? -1 : a[r].first);
}
|
#include <bits/stdc++.h>
int cmp(const void *a, const void *b) { return *(int *)a - *(int *)b; }
long long n, k, s, t;
struct data {
long long price;
long long fuel;
} x[200005];
long long g[200005];
int judge(int f) {
int i;
long long time = 0, len = 0;
for (i = 1; i <= k + 1; i++) {
long long d = g[i] - g[i - 1];
if (f < d) return 0;
if (len + d < s) {
len += d;
long long a1 = f - d > d ? d : f - d;
long long a2 = d - a1;
time += (a1 + 2 * a2);
} else {
d = s - len;
long long a1 = f - d > d ? d : f - d;
long long a2 = d - a1;
time += (a1 + 2 * a2);
break;
}
}
return time <= t ? 1 : 0;
}
int bs(int left, int right) {
int mid = (left + right) / 2;
while (left <= right) {
if (judge(mid) == 0)
left = mid + 1;
else
right = mid - 1;
mid = (left + right) / 2;
}
return left;
}
int main() {
scanf("%I64d %I64d %I64d %I64d", &n, &k, &s, &t);
int i;
long long min = INT_MAX;
for (i = 0; i < n; i++) scanf("%I64d %I64d", &x[i].price, &x[i].fuel);
for (i = 1; i <= k; i++) scanf("%I64d", &g[i]);
g[k + 1] = s;
qsort(g, k + 1, sizeof(long long), cmp);
int line = bs(1, 1000000000);
for (i = 0; i < n; i++) {
if (x[i].fuel >= line)
if (x[i].price < min) min = x[i].price;
}
if (min != INT_MAX)
printf("%d", min);
else
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k;
long long s, t, c[N], v[N], g[N], f[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> s >> t;
for (auto i = 1; i <= n; i++) cin >> c[i] >> v[i];
for (auto i = 1; i <= k; i++) cin >> g[i];
sort(g + 1, g + k + 1);
g[++k] = s;
for (auto i = 1; i <= n; i++) f[i] = v[i];
sort(f + 1, f + n + 1);
f[0] = unique(f + 1, f + n + 1) - f - 1;
int l = 1, r = f[0], x = 0;
while (l <= r) {
int m = (l + r) >> 1, p = f[m], ok = 1;
long long tm = 0ll;
for (auto i = 1; i <= k; i++) {
long long d = g[i] - g[i - 1];
if (d > p) {
ok = 0;
break;
}
if (d * 2ll <= p)
tm += 1ll * d;
else
tm += 3ll * d - p;
}
if (tm > 1ll * t) ok = 0;
if (ok)
x = m, r = m - 1;
else
l = m + 1;
}
if (x == 0) return puts("-1");
long long ans = LONG_MAX;
for (auto i = 1; i <= n; i++)
if (v[i] >= f[x]) ans = min(ans, c[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, t, a[300000];
struct car {
long long c, v;
};
car z[300000];
bool f(long long i) {
long long tek = 0, buck = z[i].v, ans = 0;
for (long long j = 0; j < k; j++) {
long long _time = 0, litrs = buck;
if ((a[j] - tek) * 2 > litrs) {
long long delta = (a[j] - tek) * 2;
long long q1 = (a[j] - tek);
long long q2 = buck - q1;
if (q2 < 0) return false;
delta -= q2;
_time = delta;
} else
_time = a[j] - tek;
ans += _time;
tek = a[j];
}
return ans <= t;
}
bool cmp(car a, car b) {
if (a.v != b.v) return a.v < b.v;
return a.c < b.c;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (long long i = 0; i < n; i++) cin >> z[i].c >> z[i].v;
for (long long i = 0; i < k; i++) cin >> a[i];
sort(a, a + k);
k++;
a[k - 1] = s;
sort(z, z + n, cmp);
long long l = 0, r = n;
while (l < r - 1) {
long long m = (l + r) / 2;
if (f(m))
r = m;
else
l = m;
}
long long mn = 999999999999999, mn1 = 999999999999;
if (f(l)) mn = z[l].v;
if (f(r)) mn = min(mn, z[r].v);
if (mn == 999999999999999) {
cout << -1;
return 0;
}
for (long long i = 0; i < n; i++) {
if (z[i].v >= mn) {
mn1 = min(z[i].c, mn1);
}
}
cout << mn1;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, T;
int g[500010];
struct dian {
int c;
int v;
} node[500010];
int cmp1(dian a, dian b) { return a.v < b.v; }
int cmp2(dian a, dian b) { return a.c < b.c; }
bool judge(int sum) {
int t = 0;
for (int i = 2; i <= k; i++) {
int dis = g[i] - g[i - 1];
if (sum < dis) return false;
if (sum >= 2 * dis)
t += dis;
else
t += 3 * dis - sum;
if (t > T) return false;
}
return true;
}
int main() {
while (~scanf("%d %d %d %d", &n, &k, &s, &T)) {
for (int i = 1; i <= n; i++) {
scanf("%d %d", &node[i].c, &node[i].v);
}
for (int i = 1; i <= k; i++) {
scanf("%d", &g[i]);
}
g[++k] = 0;
g[++k] = s;
sort(g + 1, g + 1 + k);
sort(node + 1, node + 1 + n, cmp1);
int ans = -1;
int l = 1;
int r = n;
while (l <= r) {
int mid = (l + r) / 2;
if (judge(node[mid].v)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (ans == -1) {
printf("-1\n");
} else {
int min = 1000000000;
for (int i = 1; i <= n; i++) {
if (node[i].v >= node[ans].v && node[i].c < min) {
min = node[i].c;
}
}
cout << min << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
int n, k, s, t;
scanf("%d %d %d %d", &n, &k, &s, &t);
if (t < s) {
cout << -1;
return 0;
}
std::vector<std::pair<int, int> > var(n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &var[i].first, &var[i].second);
}
std::vector<int> g(k);
for (int i = 0; i < k; i++) {
scanf("%d", &g[i]);
}
g.push_back(0);
g.push_back(s);
sort((g).begin(), (g).end());
std::vector<int> d;
for (int i = 0; i < k + 1; i++) {
d.push_back(g[i + 1] - g[i]);
}
sort((d).begin(), (d).end());
long long l = 0;
long long r = 2000000000;
while (r - l > 1) {
long long m = (r + l) / 2;
long long cur = 0;
for (long long x : d) {
if (x > m)
cur = t + 1;
else {
cur += 2 * x - min(m - x, x);
}
}
if (cur <= t)
r = m;
else
l = m;
}
int ans = 1000000001;
for (auto x : var) {
if (x.second >= r) ans = min(x.first, ans);
}
if (ans == 1000000001) ans = -1;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const bool print = false;
const int MAXN = 200111;
int n, k, s, t;
vector<pair<int, int> > cars;
vector<int> stations;
int chk(int tank) {
int pop = 0;
int ans = 0;
if (print) printf("CHK %d::", tank);
for (auto it : stations) {
int odl = it - pop;
int time = 2 * odl;
int left = tank - odl;
if (print) printf("%d %d ", odl, left);
if (left < 0) return t + 69;
time -= left;
if (time < odl) time = odl;
if (print) printf("%d;; ", time);
ans += time;
pop = it;
}
if (print) printf("%d\n", ans);
return ans;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = (1); i <= (n); i++) {
int c, v;
scanf("%d%d", &c, &v);
cars.emplace_back(c, v);
}
for (int i = (1); i <= (k); i++) {
int a;
scanf("%d", &a);
stations.push_back(a);
}
stations.push_back(s);
sort((cars).begin(), (cars).end());
sort((stations).begin(), (stations).end());
int pop = 0;
for (auto& it : cars) {
if (pop > it.second) it.second = pop;
pop = it.second;
}
cars.emplace_back(-1, (int)1e9);
int lw = 1, pw = n + 1;
while (lw < pw) {
int sr = (lw + pw) / 2;
int time69 = chk(cars[sr - 1].second);
if (time69 <= t)
pw = sr;
else
lw = sr + 1;
}
printf("%d\n", cars[lw - 1].first);
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, S, T;
int C[201010], V[201010], G[201010];
bool check(int f) {
long long t = 0;
int pre = 0;
for (int i = 0; i < K; i++) {
int d = G[i] - pre;
if (f < d) return false;
t += d * 2LL;
int fd = f - d;
t -= min(d, fd);
if (T < t) return false;
pre = G[i];
}
return true;
}
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", &G[i]);
G[K] = S;
K++;
sort(G, G + K);
int l = 0, r = INT_MAX / 2;
while (l + 1 != r) {
int c = (l + r) / 2;
if (check(c))
r = c;
else
l = c;
}
int ans = INT_MAX / 2;
for (int i = 0; i < N; i++) {
if (r <= V[i]) ans = min(ans, C[i]);
}
if (ans == INT_MAX / 2) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 5;
int ans, c[N], v[N], g[N], n, k, s, t;
struct Node {
int pri, cap;
void Read() { scanf("%d%d", &pri, &cap); }
bool operator<(const Node& b) const {
if (pri == b.pri) return cap > b.cap;
return pri < b.pri;
}
} a[N];
int Check2(int l, int r, int d, int v) {
int ret = -1;
while (l <= r) {
int mid = l + r >> 1;
int x = mid;
int y = d - x;
if (x * 2 + y <= v) {
ret = x + 2 * y;
l = mid + 1;
} else
r = mid - 1;
}
return ret;
}
bool Check(int v) {
int sum = 0;
for (int i = 1; i <= k + 1; i++) {
int d = g[i] - g[i - 1];
int cur = Check2(0, d, d, v);
if (cur < 0) return 0;
sum += cur;
}
return sum <= t;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) a[i].Read();
sort(a, a + n);
int m = 0;
for (int i = 1; i < n; i++) {
if (a[i].cap <= a[m].cap) continue;
a[++m] = a[i];
}
n = ++m;
for (int i = 1; i <= k; i++) scanf("%d", g + i);
sort(g + 1, g + k + 1);
g[0] = 0;
g[k + 1] = s;
int l = 0, r = n - 1, ans = -1;
while (l <= r) {
int mid = l + r >> 1;
if (Check(a[mid].cap)) {
ans = a[mid].pri;
r = mid - 1;
} else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using DD = long double;
using pii = pair<int, int>;
const LL INFLL = 0x7f7f7f7f7f7f7f7fLL;
const int INFint = 0x7f7f7f7f;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(16);
int n, k, s, t;
cin >> n >> k >> s >> t;
vector<pii> tank_cost(n);
for (int i = 0; i < int(n); ++i)
cin >> tank_cost[i].second >> tank_cost[i].first;
vector<int> stations(k);
for (int i = 0; i < int(k); ++i) cin >> stations[i];
stations.push_back(0);
stations.push_back(s);
sort((stations).begin(), (stations).end());
LL low = 1;
LL high = LL(2e9);
while (high - low >= 2) {
LL mid = (low + high) / 2;
bool fail = false;
LL minutes = 0;
for (int i = int(1); i < int((int((stations).size()))); ++i) {
int span = stations[i] - stations[i - 1];
if (span > int(mid)) {
fail = true;
break;
}
int extra_litres = int(mid) - span;
int at_1min_per_km = min(extra_litres, span);
minutes += at_1min_per_km + 2 * (span - at_1min_per_km);
}
if (minutes > t) fail = true;
if (!fail)
high = mid;
else
low = mid;
}
LL rr = INFLL;
for (int i = 0; i < int((int((tank_cost).size()))); ++i) {
if (tank_cost[i].first >= high) rr = min(rr, LL(tank_cost[i].second));
}
if (rr == INFLL)
cout << "-1\n";
else
cout << rr << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 2e5 + 10;
long long n, k, s, t, Time;
long long cnt[MXN];
vector<pair<long long, long long>> Car;
vector<long long> dis, gas;
long long cal(long long x) {
long long sum = 0;
for (int i = 0; i < dis.size(); i++) {
if (dis[i] > x) return -1383;
sum += min(x - dis[i], dis[i]);
}
return sum;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s >> t;
Time = s * 2;
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
Car.emplace_back(x, y);
}
sort(Car.begin(), Car.end());
for (int i = 0; i < k; i++) {
long long x;
cin >> x;
gas.push_back(x);
}
gas.push_back(0);
gas.push_back(s);
sort(gas.begin(), gas.end());
for (int i = 0; i < gas.size() - 1; i++) {
dis.push_back(gas[i + 1] - gas[i]);
}
sort(dis.begin(), dis.end());
long long p = 0;
Time -= t;
while (Time > 0 && p < dis.size()) {
if (Time >= dis[p]) {
cnt[p] = dis[p];
Time -= dis[p];
} else {
cnt[p] += Time;
Time = 0;
}
p++;
}
if (Time > 0) return cout << -1, 0;
long long l = 0, r = 1e9 + 7, maxi;
while (r - l > 1) {
long long mid = (l + r) / 2;
if (cal(mid) >= s * 2 - t)
r = mid;
else
l = mid;
}
if (r == 1e9 + 7) return cout << -1, 0;
maxi = r;
for (int i = 0; i < n; i++) {
if (Car[i].second >= maxi) {
cout << Car[i].first;
return 0;
}
}
cout << -1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char _;
const int maxN = 200 * 1000 + 5;
const int mod = 1000 * 1000 * 1000 + 7;
const int maxL = 20;
pair<int, int> a[maxN];
int g[maxN];
long long cn[maxN];
long long cnt[maxN];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, k, s, t;
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) cin >> a[i].second >> a[i].first;
sort(a, a + n);
for (int i = 1; i <= k; i++) cin >> g[i];
g[k + 1] = s;
k += 2;
sort(g, g + k);
for (int i = 1; i < k; i++) {
int dis = g[i] - g[i - 1];
int ps = lower_bound(a, a + n, make_pair(dis, -1)) - a;
cn[0] += -mod;
cn[ps] -= -mod;
int ps1 = lower_bound(a, a + n, make_pair(dis * 2, -1)) - a;
cn[ps1] += dis;
cnt[ps]++;
cnt[ps1]--;
cn[ps] -= dis;
cn[ps1] += dis;
}
long long sum = 0, ted = 0;
int ans = mod;
for (int i = 0; i < n; i++) {
sum += cn[i];
ted += cnt[i];
long long res = ted * a[i].first + sum;
if (2 * s - res <= t) ans = min(ans, a[i].second);
}
if (ans == mod)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 400000 + 5;
int n, k, s, t;
int g[NMAX];
vector<pair<int, int> > cars;
bool works(int cap) {
long long int tmp = 0;
for (int i = 2; i <= k; ++i) {
long long int dst = g[i] - g[i - 1];
if (cap < dst) return false;
if (cap >= 2 * dst)
tmp += dst;
else
tmp += (dst * 2LL - (cap - dst));
}
return tmp <= t;
}
int main() {
ios_base ::sync_with_stdio(false);
cin >> n >> k >> s >> t;
cars.resize(n + 1);
for (int i = 1; i <= n; ++i) cin >> cars[i].second >> cars[i].first;
sort(cars.begin() + 1, cars.end());
for (int i = 2; i <= k + 1; ++i) cin >> g[i];
g[k + 2] = s;
k += 2;
sort(g + 1, g + k + 1);
int st = 1;
int dr = n;
int ans = n + 1;
int mid;
while (st <= dr) {
mid = (st + dr) >> 1;
if (works(cars[mid].first)) {
ans = mid;
dr = mid - 1;
} else
st = mid + 1;
}
if (ans == n + 1) {
cout << "-1\n";
return 0;
}
int yay = cars[ans].second;
for (int i = ans + 1; i <= n; ++i) yay = min(yay, cars[i].second);
cout << yay << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> all[200005];
int l[200005];
int n, k;
long long calc(long long v) {
long long res = 0;
for (int i = 0; i < k; i++)
if (l[i] > v)
return 1ll << 62;
else if (2 * l[i] < v)
res += l[i];
else
res += 3ll * l[i] - v;
return res;
}
bool can(long long test, long long tim) { return calc(test) <= tim; }
int solve(int t) {
long long lo = 0, hi = 1ll << 60;
while (lo + 1 < hi) {
long long mid = (lo + hi) >> 1;
if (can(mid, t))
hi = mid;
else
lo = mid;
}
int bst = -1;
for (int i = 0; i < n; i++)
if (all[i].second >= hi) {
if (bst == -1) bst = i;
if (all[i].first < all[bst].first) bst = i;
}
return bst != -1 ? all[bst].first : -1;
}
int main() {
int s, t;
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%d%d", &all[i].first, &all[i].second);
for (int i = 0; i < k; i++) scanf("%d", l + i);
l[k] = s;
k++;
sort(l, l + k);
for (int i = k - 1; i > 0; i--) l[i] -= l[i - 1];
printf("%d\n", solve(t));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t, pos[200005];
struct thing {
int c, v;
friend bool operator<(thing a, thing b) { return a.c > b.c; }
} car[200005];
bool check(int num) {
int vol = car[num].v;
int time = 0, Pos = 0;
for (int i = 1; i <= k; i++) {
if (pos[i] - Pos > vol) return false;
if (2 * (pos[i] - Pos) <= vol)
time += pos[i] - Pos;
else
time += vol - (pos[i] - Pos) + 2 * (2 * (pos[i] - Pos) - vol);
Pos = pos[i];
}
if (time > t) return false;
return true;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%d%d", &car[i].c, &car[i].v);
for (int i = 1; i <= k; i++) scanf("%d", &pos[i]);
sort(pos + 1, pos + 1 + k);
pos[++k] = s;
sort(car + 1, car + 1 + n);
vector<thing> st;
for (int i = 1; i <= n; i++) {
while (!st.empty() && st[st.size() - 1].v <= car[i].v)
st.erase(st.end() - 1);
st.push_back(car[i]);
}
n = st.size();
for (int i = 1; i <= n; i++) car[i] = st[n - i];
int l = 1, r = n;
while (l != r) {
int mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (check(l))
printf("%d\n", car[l].c);
else
printf("-1\n");
}
|
/* !ya khoda! */#include <bits/stdc++.h>
using namespace std;
long long n,k,s,t , l,mid,r=100000000000 , ans=100000000000 , m , c[2001000],v[2001000],g[2001000];
bool check(long long x) { m=0;
for(int i=0;i<k;i++) {
if(g[i]>x) return 0;
if(2*g[i]<=x) { m+=g[i]; continue; }
m+=3*g[i]-x; }
return(m<=t); }
int main() {
ios_base::sync_with_stdio(false) , cin.tie(0) , cout.tie(0);
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 , k++;
for(int i=k-1;i>0;i--) g[i]-=g[i-1];
while(r-l>1) {
mid=(l+r)/2;
if(check(mid)) r=mid;
else l=mid; }
for(int i=0;i<n;i++)
if(v[i]>=r)
ans=min(ans,c[i]);
return cout<<(ans==100000000000?-1:ans),0; }
|
#include <bits/stdc++.h>
using namespace std;
inline void file() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
if (0) {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
}
const int px[5] = {0, 0, 1, -1}, py[5] = {-1, 1, 0, 0}, N = 2e5 + 100,
INF = 2e9, MOD = 1e9 + 7;
const long double eps = 1e-6, PI = 3.14159265358979323846;
int n, k, s, maxt, l, r, mid, ans, now;
int a[N], c[N], v[N];
char flag;
inline void read(int &n) {
n = 0;
char h = getchar();
while (h < '0' || h > '9') h = getchar();
while (h >= '0' && h <= '9') {
n = (n * 10) + h - '0';
h = getchar();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
read(n);
read(k);
read(s);
read(maxt);
for (int i = 0; i < n; ++i) {
read(c[i]);
read(v[i]);
}
for (int i = 0; i < k; ++i) read(a[i]);
a[++k] = s;
sort(a, a + k);
l = 0;
r = INF;
while (r - l > 1) {
mid = (r + l) >> 1;
flag = 0;
now = 0;
for (int i = 1; i <= k; ++i) {
if (a[i] - a[i - 1] > mid) {
flag = 1;
break;
}
int q = a[i] - a[i - 1];
now += q * 2 - min(q, mid - q);
}
if (!flag && now <= maxt)
r = mid;
else
l = mid;
}
ans = INF;
for (int i = 0; i < n; ++i)
if (c[i] < ans && v[i] >= r) ans = c[i];
if (ans == INF) ans = -1;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long s, t, g[200007], c, v;
pair<long long, long long> car[200007];
int check(int x) {
long long sum = 0, dis = 0, cur = 0, val = car[x].first;
for (int i = 1; i <= k + 1; i++) {
long long pl = g[i];
if (i == 1)
dis = pl - 0;
else
dis = pl - g[i - 1];
if (dis > val) return 0;
cur = dis * 2;
if (cur <= val)
sum += dis;
else {
sum += dis + (cur - val);
}
}
if (sum <= t)
return 1;
else
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) {
cin >> c >> v;
car[i] = make_pair(v, c);
}
for (int i = 1; i <= k; i++) {
cin >> g[i];
}
sort(g + 1, g + 1 + k);
g[k + 1] = s;
sort(car + 1, car + 1 + n);
int start = 1, en = n;
int mid = (start + en) / 2;
if (check(n) == 0) {
cout << -1;
return 0;
}
int cnp = 500;
while (cnp--) {
if (check(mid) == 1)
en = mid;
else
start = mid + 1;
mid = (start + en) / 2;
}
long long ans = 1e16;
for (int i = mid; i <= n; i++) {
ans = min(ans, car[i].second);
}
cout << ans;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, ”/ STACK : 38777216“
using namespace std;
const int N = 200005;
const int inf = 2 * 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
int n, k;
long long s, t;
pair<long long, long long> p[N];
long long g[N];
int main() {
scanf("%d%d%lld%lld", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%lld%lld", &p[i].first, &p[i].second);
sort(p + 1, p + n + 1);
for (int i = 2; i <= n; i++) p[i].second = max(p[i].second, p[i - 1].second);
for (int i = 1; i <= k; i++) scanf("%lld", &g[i]);
sort(g + 1, g + k + 1);
g[0] = 0;
g[k + 1] = s;
int ina = 1, inb = n;
long long answ = -1;
while (ina <= inb) {
int mid = (ina + inb) / 2;
long long T = 0;
long long S = p[mid].second;
bool flag = true;
for (int i = 0; i <= k; i++) {
long long d = g[i + 1] - g[i];
if (d > S) {
flag = false;
break;
}
long long delta = S - d;
delta = min(delta, d);
T += delta + (d - delta) * (2ll);
}
if (T > t) flag = false;
if (flag) {
answ = p[mid].first;
inb = mid - 1;
} else
ina = mid + 1;
}
cout << answ << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 100, M = 20, LG = 30, base = 2;
const int MOD = 1e9 + 7, mod = 1e9 + 9;
const long long INF = 1e13, inf = 1e18;
long long n, k, s, t, l, mid, r = INF, ans = INF, m;
long long c[N], v[N], g[N];
bool check(long long x) {
m = 0;
for (int i = 0; i < k; i++) {
if (g[i] > x) return 0;
if (2 * g[i] <= x) {
m += g[i];
continue;
}
m += 3 * g[i] - x;
}
return (m <= t);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
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, k++;
for (int i = k - 1; i > 0; i--) g[i] -= g[i - 1];
while (r - l > 1) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
for (int i = 0; i < n; i++)
if (v[i] >= r) ans = min(ans, c[i]);
return cout << (ans == INF ? -1 : ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int g[200001];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, t, s, el;
cin >> n >> k >> s >> t;
vector<pair<int, int>> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
}
for (int i = 0; i < k; i++) {
cin >> g[i + 1];
}
g[k + 1] = s;
sort(g, g + k + 2);
int l = 0, r = 2e9 + 2;
while (r - l > 1) {
int m = (l + (r - l) / 2);
bool f = 1;
long long curt = 0;
for (int i = 0; i < k + 1; i++) {
if (g[i + 1] - g[i] > m) {
f = 0;
break;
} else
curt +=
2 * (g[i + 1] - g[i]) - min(m - g[i + 1] + g[i], g[i + 1] - g[i]);
}
if (curt <= t && f) {
r = m;
} else {
l = m;
}
}
int mn = 2e9 + 2;
for (int i = 0; i < n; i++) {
if (v[i].second >= r) {
mn = min(mn, v[i].first);
}
}
if (mn == 2e9 + 2)
cout << -1;
else
cout << mn;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 7;
void rd(long long &x) {
x = 0;
char s;
s = getchar();
long long f = 1;
while (!isdigit(s)) {
if (s == '-') f -= 1;
s = getchar();
}
while (isdigit(s)) {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
bool isp(long long x) {
long long tt = sqrt(x * 1.0);
for (long long i = 2; i <= tt; i++) {
if (x % i == 0) return 0;
}
return 1;
}
long long quick_mod(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res = res * a;
res %= mod;
}
b >>= 1;
a = a * a;
a %= mod;
}
return res;
}
long long n, k, s, t;
struct node {
long long cost, cap;
} a[212345];
long long pos[212345];
int main() {
cin >> n >> k >> s >> t;
if (t < s) {
return cout << -1 << '\n', 0;
}
for (long long i = 1; i <= n; i++) {
rd(a[i].cost), rd(a[i].cap);
}
for (long long i = 1; i <= k; i++) {
rd(pos[i]);
}
sort(pos + 1, pos + k + 1);
pos[0] = 0;
pos[k + 1] = s;
long long l = 1, r = 0x3f3f3f3f3f3f3f3f;
;
while (l < r) {
long long mid = l + r;
mid >>= 1;
long long tem = 0;
for (long long i = 0; i <= k; i++) {
tem += pos[i + 1] - pos[i];
if (mid < (pos[i + 1] - pos[i])) {
tem = 0x3f3f3f3f3f3f3f3f;
break;
} else
tem += max((long long)0,
(pos[i + 1] - pos[i]) - (mid - (pos[i + 1] - pos[i])));
}
if (tem <= t) {
r = mid;
} else {
l = mid + 1;
}
}
long long ans = 0x3f3f3f3f3f3f3f3f;
for (long long i = 1; i <= n; i++) {
if (a[i].cap >= l) {
ans = min(ans, a[i].cost);
}
}
if (ans == 0x3f3f3f3f3f3f3f3f) {
cout << -1 << '\n';
} else {
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> m;
vector<int> z;
int T;
int n, k;
int bin1(int s, int v) {
int l = 0;
int r = s + 1;
while (l + 1 < r) {
int m = (l + r) / 2;
if (m * 2 + (s - m) > v)
r = m;
else
l = m;
}
if (l * 2 + (s - l) <= v) return (s - l) * 2 + l;
return -1;
}
int ask(int v) {
int t = 0;
for (int i = z.size() - 1; i >= 0; --i) {
int a = bin1(z[i], v);
if (a == -1) return 0;
t += a;
if (t > T) return 0;
}
return 1;
}
int bin() {
int l = -1;
int r = n - 1;
while (l + 1 < r) {
int mi = (l + r) / 2;
if (ask(m[mi].first))
r = mi;
else
l = mi;
}
if (ask(m[r].first)) return r;
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int s;
cin >> n >> k >> s >> T;
int c, v;
for (int i = 0; i < n; ++i) {
cin >> c >> v;
m.push_back({v, c});
}
sort(m.begin(), m.end());
int z1, z2;
z1 = 0;
vector<int> z3(k);
for (int i = 0; i < k; ++i) {
cin >> z3[i];
}
sort(z3.begin(), z3.end());
for (int i = 0; i < k; ++i) {
z.push_back(z3[i] - z1);
z1 = z3[i];
}
z.push_back(s - z1);
sort(z.begin(), z.end());
int a = bin();
if (a == -1)
cout << -1;
else {
int minn = 1e9 + 8;
for (int i = a; i < n; ++i) {
minn = min(minn, m[i].second);
}
cout << minn << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, S, T, p[200200], canget[200200];
pair<int, int> c[200200];
bool check(long long v) {
long long tot = 0;
for (int i = (0); i < (K + 1); i++) {
long long l = (i == K ? S : p[i]) - (i == 0 ? 0 : p[i - 1]);
if (v - l < 0) return 0;
tot += 2 * l - min(l, v - l);
}
return tot <= (long long)T;
}
int main() {
scanf("%d %d %d %d", &N, &K, &S, &T);
for (int i = (0); i < (N); i++) scanf("%d %d", &c[i].first, &c[i].second);
sort(c, c + N);
for (int i = (0); i < (K); i++) {
scanf("%d", &p[i]);
}
sort(p, p + K);
long long lo = 0, hi = 1e9, mid, ans = -1;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (check(mid))
ans = mid, hi = mid - 1;
else
lo = mid + 1;
}
if (ans == -1) return puts("-1"), 0;
for (int i = (0); i < (N); i++)
if (c[i].second >= int(ans)) return printf("%d\n", c[i].first), 0;
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct TCar {
int c, v;
};
struct TVolComp {
bool operator()(const TCar &a, const TCar &b) { return a.v < b.v; }
};
struct TPriceComp {
bool operator()(const TCar &a, const TCar &b) { return a.c < b.c; }
};
bool check(const vector<int> &gas, int v, int s, int t) {
if (gas[0] > v) {
return false;
}
int res = max(0, 2 * gas[0] - v) + gas[0];
for (int i = 1; i <= gas.size() - 1; ++i) {
int l = gas[i] - gas[i - 1];
if (l > v) {
return false;
}
res += max(0, 2 * l - v) + l;
}
int l = s - gas.back();
if (l > v) {
return false;
}
res += max(0, 2 * l - v) + l;
return res <= t;
}
int main() {
ios_base::sync_with_stdio(false);
int n, k, s, t;
cin >> n >> k >> s >> t;
vector<TCar> car(n);
for (auto &x : car) {
cin >> x.c >> x.v;
}
sort(car.begin(), car.end(), TVolComp());
vector<int> gas(k);
for (int &x : gas) {
cin >> x;
}
sort(gas.begin(), gas.end());
if (!check(gas, car.back().v, s, t)) {
cout << -1;
return 0;
}
int l = 0, r = n - 1;
while (l < r) {
int m = (l + r) / 2;
if (check(gas, car[m].v, s, t)) {
r = m;
} else {
l = m + 1;
}
}
int v = car[l].v;
sort(car.begin(), car.end(), TPriceComp());
cout << find_if(car.begin(), car.end(), [v](const TCar &x) -> bool {
return x.v >= v;
})->c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x6fffffff;
const int MINF = 0x80000000;
const long long mod = 1000000007;
const int cons = 100001;
const double pi = 3.141592653589793;
vector<int> pos;
bool isOk(int x, int t) {
double res = 0;
for (int i = 1; i < pos.size(); i++) {
int diff = pos[i] - pos[i - 1];
int l = -1;
int r = x + 1;
while (l + 1 < r) {
int mid = l + r >> 1;
int y = x - mid;
double avail = (double)y / 2 + mid;
if (avail >= (double)diff)
r = mid;
else
l = mid;
}
if (r == x + 1) return false;
diff -= r;
res += (double)r * 2;
res += min((double)diff, ((double)x - r) / 2);
}
return res <= (double)t;
}
int main() {
int n, k, s, t;
cin >> n >> k >> s >> t;
map<int, int> M;
for (int i = 0; i < n; i++) {
int c, v;
scanf("%d%d", &c, &v);
M[c] = max(M[c], v);
}
int cur = 0;
vector<pair<int, int> > dat;
for (auto it : M) {
if (cur < it.second) {
cur = it.second;
dat.push_back(it);
}
}
pos.resize(k);
for (int i = 0; i < k; i++) {
scanf("%d", &pos[i]);
}
pos.push_back(0);
pos.push_back(s);
sort(pos.begin(), pos.end());
int L = -1;
int R = dat.size();
while (L + 1 < R) {
int mid = L + R >> 1;
if (isOk(dat[mid].second, t))
R = mid;
else
L = mid;
}
if (R == dat.size())
puts("-1");
else
printf("%d\n", dat[R].first);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void in(int &a) { scanf("%d", &a); }
const int MAX = 2e5 + 5;
pair<int, int> cars[MAX];
int gas[MAX];
int n, k, s, t;
bool check(int fuelTank, int time) {
int currTime = 0;
for (int i = 1; i < k + 2; i++) {
int now = gas[i] - gas[i - 1];
if (fuelTank < now) return false;
int a = fuelTank - now;
int b = 2 * now - fuelTank;
if (b < 0) {
a = now;
b = 0;
}
currTime += a + 2 * b;
}
return currTime <= time;
}
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%d %d", &cars[i].first, &cars[i].second);
for (int i = 1; i < k + 1; i++) scanf("%d", &gas[i]);
sort(gas + 1, gas + k + 1);
gas[k + 1] = s;
if (t < s) {
puts("-1");
return 0;
}
int left = 0, right = s, curr, ans = 3 * s - t;
while (left <= right) {
curr = (left + right) >> 1;
if (check(curr, t)) {
ans = curr;
right = curr - 1;
} else {
left = curr + 1;
}
}
int mn = INT32_MAX;
for (int i = 0; i < n; i++) {
if (cars[i].second >= ans) {
mn = min(mn, cars[i].first);
}
}
puts(mn == INT32_MAX ? "-1" : to_string(mn).c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t, gas[200005], mx, mn = -1, mncap = 2e9, idb, idf, idm, d;
pair<int, int> car[200005];
map<int, int> mmap;
map<int, int>::iterator it, it2;
long long ut;
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = 0; i < n; ++i) scanf("%d %d", &car[i].first, &car[i].second);
for (int i = 1; i <= k; ++i) scanf("%d", &gas[i]);
sort(car, car + n);
sort(gas + 1, gas + k + 1);
gas[k + 1] = s;
idf = 1;
idb = s;
while (idf <= idb) {
idm = (idf + idb) / 2;
ut = 0;
for (int i = 1; i <= k + 1; ++i) {
d = gas[i] - gas[i - 1];
if (idm < d) {
ut = 2e9 + 1;
break;
}
if (2 * d <= idm)
ut += d;
else
ut += 3LL * d - idm;
}
if (ut <= t) {
mncap = min(mncap, idm);
idb = idm - 1;
} else
idf = idm + 1;
}
for (int i = 0; i < n; ++i)
if (car[i].second >= mncap) {
printf("%d\n", car[i].first);
return 0;
}
printf("-1\n");
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
mt19937 gen(time(0));
mt19937_64 gen64(228);
long double ans(long long x1, long long x2, long long v) {
long double len = x2 - x1;
if (v < len) return 2e9 + 5;
long double l = max((long double)0, v - len);
l = min(l, len);
return l + 2 * (len - l);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<int, int>> a(n);
for (int i = 0; i < n; ++i) cin >> a[i].first >> a[i].second;
vector<long double> b(k);
for (int i = 0; i < k; ++i) {
long long x;
cin >> x;
b[i] = x;
}
b.insert(b.begin(), 0);
b.emplace_back(s);
k += 2;
sort((b).begin(), (b).end());
long double l = 0, r = 2e9 + 5;
for (int z = 0; z < 100; ++z) {
long double m = (l + r) / 2;
long double timeTotal = 0;
for (int i = 0; i + 1 < k; ++i) {
timeTotal += ans(b[i], b[i + 1], m);
}
if (timeTotal <= t) {
r = m;
} else {
l = m;
}
}
long long cost = 2e9 + 5;
for (auto &elem : a) {
if (elem.second >= r) {
cost = min(cost, (long long)elem.first);
}
}
if (cost == 2e9 + 5)
cout << -1 << '\n';
else
cout << cost << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
long long int n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<long long int, long long int> > car(n);
vector<long long int> zp(k);
for (long long int i = 0; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
car[i].first = (long long int)(x);
car[i].second = (long long int)(y);
}
long long int mlen = 0;
for (long long int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
zp[i] = (x);
}
sort(zp.begin(), zp.end());
for (long long int i = 0; i < k; i++) {
if (i == 0)
mlen = max(mlen, zp[i]);
else
mlen = max(mlen, zp[i] - zp[i - 1]);
}
mlen = max(mlen, s - zp[k - 1]);
long long int l = 0, r = mlen * 2 + 1;
while (r - l > 1) {
long long int m = (l + r) / 2;
int f = 1, time = 0;
for (int i = 0; i < k; i++) {
long long int x, y;
if (i == 0) {
x = min(zp[i], m - zp[i]);
y = zp[i] - x;
} else {
x = min(zp[i] - zp[i - 1], m - (zp[i] - zp[i - 1]));
y = zp[i] - zp[i - 1] - x;
}
if (x < 0 || y < 0) f = 0;
time += y * 2 + x;
}
long long int x, y;
x = min(s - zp[k - 1], m - s + zp[k - 1]);
y = s - zp[k - 1] - x;
if (x < 0 || y < 0) f = 0;
time += y * 2 + x;
if (time <= t && f == 1)
r = m;
else
l = m;
}
if (r == mlen * 2 + 1) {
cout << -1 << "\n";
return 0;
}
long long int ans = 2000000001;
for (int i = 0; i < n; i++) {
if (car[i].second >= r) ans = min(ans, car[i].first);
}
if (ans == 2000000001)
cout << -1;
else
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, t, c[200005], v[200005], g[200005];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.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 >> g[i];
sort(g, g + k);
g[k] = s;
long long L = -1;
long long R = 2e9 + 7;
while (R - L > 1) {
long long M = (L + R) / 2;
long long T = 0;
for (long long i = -1; i < k; i++) {
long long x;
if (i != -1)
x = g[i + 1] - g[i];
else
x = g[0];
long long y = max(0ll, 2 * x - M);
if (y > x)
T = 2e9 + 7;
else
T += x + y;
}
if (T <= t)
R = M;
else
L = M;
}
long long Min = 2e9 + 7;
for (long long i = 0; i < n; i++) {
if (v[i] >= R) Min = min(Min, c[i]);
}
if (Min == 2e9 + 7)
cout << -1;
else
cout << Min;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:32000000")
using namespace std;
inline bool read(int& val) { return scanf("%d", &val) != -1; }
inline bool read(long long& val) { return scanf("%I64d", &val) != -1; }
inline bool read(double& val) { return scanf("%lf", &val) != -1; }
inline bool read(char* val) { return scanf("%s", val) != -1; }
template <class T1, class T2>
inline bool read(T1& a, T2& b) {
return read(a) && read(b);
}
template <class T1, class T2, class T3>
inline bool read(T1& a, T2& b, T3& c) {
return read(a) && read(b) && read(c);
}
template <class T1, class T2, class T3, class T4>
inline bool read(T1& a, T2& b, T3& c, T4& d) {
return read(a) && read(b) && read(c) && read(d);
}
template <class T1, class T2, class T3, class T4, class T5>
inline bool read(T1& a, T2& b, T3& c, T4& d, T5& e) {
return read(a) && read(b) && read(c) && read(d) && read(e);
}
const int N = 1111111;
struct car {
int c;
long long v;
friend bool operator<(car a, car b) { return a.c < b.c; }
};
long long G[N];
car cars[N];
long long n, k, s, t;
long long get(long long v, long long s) {
if (s * 2 < v) return s;
if (v < s) return -1;
int a = v - s, b = s - a;
return a + 2 * b;
}
long long f(int x) {
long long v = cars[x].v;
long long ret = get(v, G[0]);
if (ret == -1) return 0;
G[k] = s;
for (int i = 0, _ = (k); i < _; ++i) {
long long val = get(v, G[i + 1] - G[i]);
if (val == -1) return 0;
ret += val;
}
return ret <= t;
}
template <class F, class T, class V>
T lower_bound(F f, T l, T r, V val) {
while (l < r) {
T m = l + (r - l) / 2;
if (f(m) < val)
l = m + 1;
else
r = m;
}
return l;
}
int main() {
read(n, k, s, t);
for (int i = 0, _ = (n); i < _; ++i) read(cars[i].c, cars[i].v);
for (int i = 0, _ = (k); i < _; ++i) read(G[i]);
sort(G, G + k);
sort(cars, cars + n);
int m = 0;
int maxv = 0;
for (int i = 0, _ = (n); i < _; ++i)
if (cars[i].v > maxv) {
cars[m++] = cars[i];
maxv = cars[i].v;
}
int x = lower_bound(f, 0, m, 1);
printf("%d\n", x == m ? -1 : cars[x].c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 300000;
struct Node {
int c, v;
} a[maxN + 1];
bool comp(Node x, Node y) {
if (x.v != y.v) return x.v < y.v;
return x.c < y.c;
}
int n, s, k, t, oil[maxN + 1], ans = -1, final = 2147483647;
bool check(int);
inline int read();
int main() {
n = read();
k = read();
s = read();
t = read();
for (int i = 1; i <= n; i++) {
a[i].c = read();
a[i].v = read();
}
sort(a + 1, a + n + 1, comp);
for (int i = 1; i <= k; i++) oil[i] = read();
sort(oil + 1, oil + k + 1);
k++;
oil[k] = s;
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (ans == -1)
printf("-1");
else {
for (int i = ans; i <= n; i++) final = min(final, a[i].c);
printf("%d", final);
}
return 0;
}
inline int read() {
int num = 0, f = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
num = num * 10 + ch - '0';
ch = getchar();
}
return num * f;
}
bool check(int num) {
int ti = 0, loca = 0;
for (int i = 1; i <= k; i++) {
int dis = oil[i] - oil[i - 1];
if (dis > a[num].v) return false;
if (dis * 2 <= a[num].v)
ti += dis;
else {
int rest = a[num].v - dis;
ti = ti + dis * 2 - rest;
}
loca += dis;
}
if (ti > t) return false;
return true;
}
|
#include <bits/stdc++.h>
using namespace std;
long long k;
long long c[200100];
long long b[200100];
long long aw[200100];
long long i, n, s, t, answer, d;
long long check(long long v, long long ti) {
long long t, i, a, d;
t = 0;
for (i = 1; i <= k; i++) {
d = aw[i] - aw[i - 1];
if (d > v) {
return 0;
}
if (d * 2 <= v) {
t += d;
} else {
a = (2 * d) - v;
t += (2 * a) + (d - a);
}
if (t > ti) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
ios_base::sync_with_stdio(false);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin.tie(NULL);
cout.tie(NULL);
cout.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> s >> t;
for (i = 1; i <= n; i++) {
cin >> c[i] >> b[i];
}
for (i = 1; i <= k; i++) {
cin >> aw[i];
}
ios_base::sync_with_stdio(false);
k++;
aw[k] = s;
sort(aw + 1, aw + 1 + k);
long long l = 1;
long long r = 3ll * s;
while (l + 1 < r) {
long long mid = (l + r) / 2;
if (check(mid, t) == 0)
l = mid;
else
r = mid;
}
d = -1;
if (check(l, t) == 1)
d = l;
else if (check(r, t) == 1)
d = r;
if (d == -1)
cout << "-1";
else {
answer = -1;
for (i = 1; i <= n; i++) {
if (b[i] >= d) {
if ((answer == -1) || (answer > c[i])) answer = c[i];
}
}
cout << answer;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s, t, c[200200], v[200200], g[200200];
bool ok(long long k) {
long long rlt = 0;
for (int i = 0; i <= m; i++) {
long long dist = g[i + 1] - g[i];
if (k < dist) return 0;
long long y = min(dist, k - dist), x = dist - y;
rlt += 2 * x + y;
}
return rlt <= t;
}
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", &g[i]);
sort(g + 1, g + m + 1);
g[0] = 0, g[m + 1] = s;
long long st = -1, en = 1ll << 40;
while (en - st > 1) {
long long mid = st + en >> 1;
if (ok(mid))
en = mid;
else
st = mid;
}
int ans = 1e9 + 7;
for (int i = 1; i <= n; i++)
if (v[i] >= en) ans = min(ans, c[i]);
if (ans == 1e9 + 7) ans = -1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
pair<long long, long long> a[maxn];
long long b[maxn], ans = 2e9 + 10, st[maxn], n, k, s, t;
long long f(long long x) {
long long cap = a[x].first, tim = 0;
for (int i = 0; i <= k; i++) {
if (st[i] > cap) return 2e9 + 10;
tim += max(3 * st[i] - cap, st[i]);
}
return tim;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) cin >> a[i].second >> a[i].first;
long long pre = 0;
for (int i = 0; i < k; i++) cin >> b[i];
sort(b, b + k);
for (int i = 0; i < k; i++) st[i] = b[i] - pre, pre = b[i];
st[k] = s - pre;
sort(a, a + n);
int lo = -1, hi = n;
while (hi - lo > 1) {
int mid = (hi + lo) / 2;
if (f(mid) <= t)
hi = mid;
else
lo = mid;
}
if (lo + 1 == n) return cout << -1, 0;
for (int i = lo + 1; i < n; i++) ans = min(ans, a[i].second);
cout << ans;
}
|
#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, k;
long long s, t;
vector<pair<long long, long long>> a;
vector<long long> maxV;
vector<long long> g;
bool Check(const long long v) {
long long ct = 0;
long long pos = 0;
for (int i = 0; i < (int)g.size(); ++i) {
long long dist = g[i] - pos;
if (dist > v) {
return false;
}
long long v2 = (v - dist);
v2 = min(v2, dist);
long long v1 = dist - v2;
ct += (v1 * 2 + v2);
if (ct > t) {
return false;
}
pos = g[i];
}
return true;
}
void Solve() {
sort(g.begin(), g.end());
g.push_back(s);
sort(a.begin(), a.end());
maxV.resize(n);
maxV[0] = a[0].second;
for (int i = 1; i < n; ++i) {
maxV[i] = max(maxV[i - 1], a[i].second);
}
int bl = 0;
int br = n - 1;
int ba = -1;
while (bl <= br) {
int bm = (bl + br) >> 1;
if (Check(maxV[bm])) {
ba = bm;
br = bm - 1;
} else {
bl = bm + 1;
}
}
cout << (ba == -1 ? -1 : a[ba].first) << endl;
exit(0);
}
bool Read() {
if (!(cin >> n >> k >> s >> t)) {
return false;
}
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
}
g.resize(k);
for (int i = 0; i < k; ++i) {
cin >> g[i];
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (Read()) {
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> car[200005];
int gas[200005];
vector<int> dist;
long long tree[200005];
constexpr int TSIZE = 200004;
void add(int p, int val) {
for (; p <= TSIZE; p += p & -p) tree[p] += val;
}
long long query(int p) {
long long ret = 0;
for (; p >= 1; p -= p & -p) ret += tree[p];
return ret;
}
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", &car[i].first, &car[i].second);
}
for (int i = 1; i <= k; i++) {
scanf("%d", &gas[i]);
}
sort(gas + 1, gas + 1 + k);
gas[k + 1] = s;
for (int i = 1; i <= k + 1; i++) {
dist.push_back(gas[i] - gas[i - 1]);
}
sort(dist.begin(), dist.end());
for (int i = 0; i < dist.size(); i++) {
add(i + 1, dist[i]);
}
int ans = 2e9;
for (int i = 0; i < n; i++) {
if (dist.back() > car[i].second) continue;
int idx =
upper_bound(dist.begin(), dist.end(), car[i].second / 2) - dist.begin();
long long sum1 = query(idx);
long long sum2 = query(dist.size()) - sum1;
if (sum1 + sum2 * 3 - car[i].second * 1ll * (dist.size() - idx) <= t)
ans = min(ans, car[i].first);
}
if (ans > 1.5e9)
printf("-1");
else
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 4;
const long long INF = 1e16;
int n, k;
long long s, t, g[N];
long long mint(long long first, long long dis) {
if (dis > first) return INF;
if (2 * dis <= first) return dis;
int del = first - dis;
return max(2 * dis - del, dis);
}
bool check(long long first) {
long long tot = 0;
for (int i = 1; i <= k + 1; i++) {
long long curr = mint(first, g[i] - g[i - 1]);
if (curr == INF) return false;
tot += curr;
if (tot > t) return false;
}
return tot <= t;
}
long long findmin() {
long long lo = 0, hi = INF;
while (lo < hi) {
long long mid = (lo + hi) / 2;
if (check(mid))
hi = mid;
else
lo = mid + 1;
}
return lo;
}
pair<long long, long long> cars[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
cin >> cars[i].second >> cars[i].first;
}
sort(cars, cars + n);
for (int i = 1; i <= k; i++) cin >> g[i];
sort(g + 1, g + k + 1);
g[0] = 0;
g[k + 1] = s;
long long mcap = findmin();
long long ans = INF;
for (int i = 0; i < n; i++) {
if (cars[i].first >= mcap) {
ans = min(ans, cars[i].second);
}
}
if (ans == INF) ans = -1;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename t>
t read() {
t x = 0;
int f = 1, c = getchar();
while (c > '9' || c < '0') f = c == '-' ? -1 : 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = getchar();
return x * f;
}
template <typename t>
void write(t x) {
if (x < 0) {
putchar('-'), write(-x);
return;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
const int maxn = 2e5 + 10;
const int maxv = 1e9 + 10;
struct Car {
int c, v;
} car[maxn];
int n, k, s, t, g[maxn], mxg, mxv, ans;
bool jud(int x) {
if (x < mxg) return 0;
int tot = 0;
for (int i = 1; i <= k + 1; i++) {
tot += max(g[i] * 3 - x, g[i]);
if (tot > t) return 0;
}
return 1;
}
int main() {
n = read<int>(), k = read<int>(), s = read<int>(), t = read<int>();
for (int i = 1; i <= n; i++) car[i].c = read<int>(), car[i].v = read<int>();
for (int i = 1; i <= k; i++) g[i] = read<int>();
sort(g + 1, g + k + 1);
g[k + 1] = s;
for (int i = k + 1; i >= 1; i--) mxg = max(mxg, g[i] -= g[i - 1]);
mxv = maxv;
for (int l = 0, r = maxv, m; l <= r;
jud(m = l + r >> 1) ? r = m - 1, mxv = m : l = m + 1)
;
ans = maxv;
for (int i = 1; i <= n; i++)
if (car[i].v >= mxv) ans = min(ans, car[i].c);
ans = (ans == maxv || mxv == maxv) ? -1 : ans;
write(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int c[N], v[N];
int g[N];
int n, k, s, t;
bool check(int v) {
long long cnt = 0;
for (int i = 1; i <= k + 1; i++) {
int len = g[i] - g[i - 1];
if (len > v) return false;
int tmp = v - len;
if (tmp <= len)
cnt += tmp + (len - tmp) * 2;
else
cnt += len;
}
if (cnt <= t)
return true;
else
return false;
}
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[0] = 0;
g[k + 1] = s;
int l = 0, r = 1e9;
if (!check(r))
puts("-1");
else {
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid;
}
int ans = 2e9;
for (int i = 1; i <= n; i++)
if (v[i] >= r) ans = min(ans, c[i]);
if (ans == 2e9)
puts("-1");
else
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2e5 + 100;
long long n, m, d, t, g[Maxn], r, l, T, f, mid;
pair<long long, long long> cv[Maxn];
vector<pair<long long, long long> > vec;
bool valid(long long x) {
t = 0;
for (int i = 1; i <= m + 1; i++) {
f = g[i] - g[i - 1];
if (f > x) return false;
t += min(f, x - f);
f = max(1ll * 0, f - (x - f));
t += 2 * f;
}
if (t <= T) return true;
return false;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> m >> d >> T;
for (int i = 0, a, b; i < n; i++) {
cin >> a >> b;
cv[i] = make_pair(a, b);
}
for (int i = 1; i <= m; i++) cin >> g[i];
g[m + 1] = d;
sort(g + 1, g + m + 1);
sort(cv, cv + n);
for (int i = 0; i < n; i++) {
if (vec.empty() || cv[i].second > vec.back().second)
vec.push_back(make_pair(cv[i].first, cv[i].second));
}
r = (int)vec.size() - 1;
while (r - l > 1) {
mid = (r + l) / 2;
if (valid(vec[mid].second))
r = mid;
else
l = mid;
}
if (!valid(vec.back().second))
cout << -1;
else if (valid(vec[0].second))
cout << vec[0].first;
else
cout << vec[r].first;
}
|
#include <bits/stdc++.h>
using namespace std;
int getX(int d, int v) {
int l = 0;
int r = d;
int sol = -1;
while (l <= r) {
int x = (l + r) / 2;
int y = d - x;
if (2 * x + y <= v) {
sol = x;
l = x + 1;
} else {
r = x - 1;
}
}
return sol;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(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].first >> cars[i].second;
}
vector<int> g(k + 2);
g[0] = 0;
g[k + 1] = s;
for (int i = 1; i <= k; i++) {
cin >> g[i];
}
sort(g.begin(), g.end());
k++;
int sol = -1;
int l = 1, r = 1000000010;
while (l <= r) {
int mid = (l + r) / 2;
int id = -1;
for (int i = 0; i < n; i++) {
if (cars[i].first <= mid) {
if (id == -1 || cars[id].second < cars[i].second) {
id = i;
}
}
}
bool ok = (id != -1);
int time = 0;
for (int i = 1; ok && i <= k; i++) {
int x = getX(g[i] - g[i - 1], cars[id].second);
ok &= x != -1;
if (ok) {
time += x + (g[i] - g[i - 1] - x) * 2;
ok &= (time <= t);
}
}
if (ok) {
r = mid - 1;
sol = mid;
} else {
l = mid + 1;
}
}
cout << sol << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct car {
int c, v;
};
bool operator<(car a, car b) { return a.v < b.v; }
int main() {
ios::sync_with_stdio(false);
int n, k, s, t;
cin >> n >> k >> s >> t;
vector<car> arr(n);
for (int i = 0; i < n; i++) cin >> arr[i].c >> arr[i].v;
vector<int> g(k + 2);
g[0] = 0;
for (int i(1); i <= k; i++) cin >> g[i];
k += 2;
g[k - 1] = s;
sort(arr.begin(), arr.end());
sort(g.begin(), g.end());
int l = -1, r = n;
int cnt = 0;
while (r - l > 1) {
cnt++;
int m = (r + l) / 2;
int time = 0;
for (int i(1); i < k; i++) {
int d = g[i] - g[i - 1];
int a = min(arr[m].v - d, d);
int norm = d - a;
if (arr[m].v < d) {
time = 2000000007;
break;
}
time += a + 2 * norm;
}
if (time > t)
l = m;
else
r = m;
}
if (r == n)
cout << -1 << endl;
else {
int ans = 1000000007;
for (int i = r; i < n; ++i) ans = min(ans, arr[i].c);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t, sol, i, crt, p;
int v[200003], c[200003], g[200003], sum[200003];
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
for (i = 1; i <= n; i++) scanf("%d %d", &c[i], &v[i]);
for (i = 1; i <= k; i++) scanf("%d", &g[i]);
sort(g + 1, g + k + 1);
k++;
g[k] = s;
for (i = k; i >= 1; i--) g[i] -= g[i - 1];
sort(g + 1, g + k + 1);
for (i = 1; i <= k; i++) sum[i] = sum[i - 1] + g[i];
sol = 2000000005;
for (i = 1; i <= n; ++i) {
if (v[i] < g[k]) continue;
p = upper_bound(g + 1, g + k + 1, v[i] / 2) - g;
int total = (k - p + 1) * v[i], acc = total - (sum[k] - sum[p - 1]);
crt = sum[p - 1] + acc + 2 * (sum[k] - sum[p - 1] - acc);
if (crt <= t)
if (c[i] < sol) sol = c[i];
}
if (sol == 2000000005)
printf("-1\n");
else
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t;
long long d[200010];
int v[200010], c[200010], b[200010], g[200010];
bool check(int x) {
int i;
long long tt = 0;
for (i = 1; i <= k + 1; i++) {
if (x < d[i]) return 0;
if (x >= 2 * d[i])
tt += d[i];
else
tt += 3 * d[i] - x;
}
if (tt <= t) return 1;
return 0;
}
int main() {
int i;
scanf("%d%d%d%d", &n, &k, &s, &t);
for (i = 1; i <= n; i++) {
scanf("%d%d", &c[i], &v[i]);
}
for (i = 1; i <= k; i++) {
scanf("%d", &g[i]);
}
sort(g + 1, g + k + 1);
g[0] = 0;
g[k + 1] = s;
for (i = 1; i <= k + 1; i++) {
d[i] = g[i] - g[i - 1];
}
int l = 1, r = 1e9 + 1, mn = 1e9 + 1;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
mn = mid;
r = mid - 1;
} else
l = mid + 1;
}
int ans = 1e9 + 1;
for (i = 1; i <= n; i++) {
if (v[i] >= mn && c[i] < ans) ans = c[i];
}
if (ans > 1e9) ans = -1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000000 + 7;
vector<long long> g(200007);
long long n, k, s, t;
vector<long long> c(200008), v(200008);
long long check(long long mid) {
long long tm = 0, dist = 0;
dist = g[0];
if (mid < dist)
return 0;
else if (mid >= (2 * dist)) {
tm += dist;
} else {
long long add = 3 * dist - mid;
if (add < 0)
return 0;
else
tm += add;
}
for (long long i = 1; i < k; i++) {
dist = g[i] - g[i - 1];
if (mid < dist)
return 0;
else if (mid >= (2 * dist)) {
tm += dist;
} else {
long long add = 3 * dist - mid;
if (add < 0)
return 0;
else
tm += add;
}
}
dist = s - g[k - 1];
if (mid < dist)
return 0;
else if (mid >= (2 * dist))
tm += dist;
else {
long long add = 3 * dist - mid;
if (add < 0)
return 0;
else
tm += add;
}
if (tm > t)
return 0;
else
return 1;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
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 >> g[i];
sort(g.begin(), g.begin() + k);
long long st = 1, ed = 1000000000, mid, prevmid = -1, midans = -1;
while (st <= ed) {
mid = st + (ed - st) / 2;
if (check(mid) == 1) {
ed = mid - 1;
midans = mid;
} else
st = mid + 1;
}
if (midans == -1) {
cout << -1;
return 0;
} else {
mid = midans;
}
long long ans = LONG_MAX, idx = -1;
for (long long i = 0; i < n; i++) {
if (v[i] >= mid) {
idx = 1;
ans = min(ans, c[i]);
}
}
if (idx == -1)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const int N = 2e5 + 10;
pair<int, int> a[N];
int g[N];
int n, m, s, t;
bool check(int cap) {
long long sum = 0;
for (int i = 1; i < m; ++i) {
int dis = g[i] - g[i - 1];
if (dis > cap) return false;
if (dis * 2 <= cap) {
sum += dis;
} else {
int x = cap - dis;
int y = dis - x;
sum += x + 2LL * y;
}
}
return sum <= t;
}
int main() {
scanf("%d%d%d%d", &n, &m, &s, &t);
for (int i = 0; i < n; ++i) {
scanf("%d%d", &a[i].first, &a[i].second);
}
sort(a, a + n);
for (int i = 1; i < n; ++i) {
a[i].second = max(a[i].second, a[i - 1].second);
}
g[0] = 0;
for (int i = 1; i <= m; ++i) {
scanf("%d", g + i);
}
sort(g + 1, g + m + 1);
g[m + 1] = s;
m += 2;
int low = 0, high = n;
while (low != high) {
int mid = (low + high) / 2;
if (check(a[mid].second)) {
high = mid;
} else {
low = mid + 1;
}
}
int ret = high == n ? -1 : a[high].first;
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mm = 500050;
int n, ss, tt, kk, m;
int c[1001001], v[1001001];
int g[1001001];
int xx[1001001], yy[1001001], minvv = 0, initi = 0;
long long sum[500500], ti[500500];
vector<int> num[500500];
inline void solve() {
int i = 0;
while (i <= m) {
if (initi - ti[i] <= tt) break;
initi -= ti[i];
minvv += mm;
++i;
}
memset(xx, 0, sizeof(xx));
int j = 0;
while (j < num[i].size()) {
int vv = num[i][j];
++xx[1];
--xx[vv + 1];
++j;
}
int now = i;
i = 1;
while (i <= mm) {
xx[i] += xx[i - 1];
++i;
}
i = 1;
while (i <= mm) {
++minvv;
if (initi - xx[i] - sum[now] <= tt) break;
initi -= xx[i] + sum[now];
++i;
}
}
int main() {
scanf("%d%d%d%d", &n, &kk, &ss, &tt);
int i = 1;
while (i <= n) {
scanf("%d%d", &c[i], &v[i]);
++i;
}
g[0] = 0;
i = 1;
while (i <= kk) {
scanf("%d", &g[i]);
++i;
}
g[kk + 1] = ss;
++kk;
sort(g + 1, g + kk + 1);
i = 1;
while (i <= kk) {
minvv = max(minvv, g[i] - g[i - 1]);
++i;
}
i = 1;
while (i <= kk) {
int x = minvv - (g[i] - g[i - 1]), y = 2 * (g[i] - g[i - 1]) - minvv;
if (y <= 0) {
initi += g[i] - g[i - 1];
} else {
initi += x + 2 * y;
num[y / mm].push_back(y % mm);
ti[y / mm] += y % mm;
;
}
++i;
}
m = 2000000000 / mm;
sum[m + 1] = 0;
i = m;
while (i >= 0) {
sum[i] = sum[i + 1] + num[i + 1].size();
ti[i] += 1ll * sum[i] * mm;
--i;
}
if (initi > tt) solve();
int ans = 2000000000;
i = 1;
while (i <= n) {
if (v[i] >= minvv) ans = min(ans, c[i]);
++i;
}
if (ans == 2000000000) ans = -1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 200100;
const long long TOP = 2e9;
long long N, K, S, T;
long long C[MAX], V[MAX];
long long G[MAX], lo, hi;
long long g(long long v, long long d) {
if (d > v) return TOP + 10;
long long f = min(v - d, d);
return f + (d - f) * 2;
}
bool p(long long v) {
long long t = 0;
t += g(v, G[0]);
for (long long I = 0; I < K - 1; I++) t += g(v, G[I + 1] - G[I]);
t += g(v, S - G[K - 1]);
return t <= T;
}
int main() {
ios_base::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 >> G[I];
sort(G, G + K);
if (S > T) {
cout << -1 << endl;
return 0;
}
lo = 1;
hi = 2 * S;
while (lo < hi) {
long long mi = (lo + hi) / 2;
if (p(mi))
hi = mi;
else
lo = mi + 1;
}
long long sol = TOP + 10;
for (long long I = 0; I < N; I++)
if (V[I] >= lo) sol = min(sol, C[I]);
if (sol > TOP) sol = -1;
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 100000, maxk = 2 * 100000, inf = 0x3f3f3f3f;
int n, k, s, t;
struct car {
int c, v;
} a[maxn + 10];
int d[maxk + 10];
int ans = inf;
void init() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].c, &a[i].v);
for (int i = 1; i <= k; i++) scanf("%d", &d[i]);
d[k + 1] = s;
}
bool cmp(car x, car y) { return x.v < y.v; }
bool check(int x) {
double time = 0;
for (int i = 1; i <= k + 1; i++) {
double x1, x2;
int tmp = d[i] - d[i - 1];
x1 = (double)(max(0, 2 * tmp - a[x].v));
x2 = 2 * (tmp - x1);
if (x2 < 0) return false;
time += 2 * x1 + x2 / 2;
if (time > t) return false;
}
return true;
}
void solve() {
sort(a + 1, a + 1 + n, cmp);
sort(d + 1, d + 1 + k + 1);
int l = 1, r = n;
int mm = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid))
mm = mid, r = mid - 1;
else
l = mid + 1;
}
if (mm == 0)
printf("-1");
else {
for (int i = mm; i <= n; i++) ans = min(ans, a[i].c);
printf("%d\n", ans);
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, k;
long long int 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<long long int> d(k);
for (int i = 0; i < k; i++) {
cin >> d[i];
}
d.push_back(0);
sort(d.begin(), d.end());
d.push_back(s);
int ans = 2e9;
int l = 0, r = 2e9 + 5;
while (r - l > 1) {
long long int mid = (l + r) / 2;
bool ok = 1;
long long int ti = 0;
for (int i = 1; i < (int)d.size(); i++) {
long long int di = d[i] - d[i - 1];
if (di * 2 <= mid) {
ti += di;
} else if (di > mid) {
ok = 0;
} else {
ti += (mid - di) + 2 * (di - (mid - di));
}
}
if (ti > t) ok = 0;
if (ok) {
r = mid;
} else {
l = mid;
}
}
for (int i = 0; i < n; i++) {
if (r <= v[i]) {
ans = min(ans, c[i]);
}
}
if (ans == 2e9) {
printf("-1\n");
} else {
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int INF = 1e9 + 7;
long long x[N];
long long sum[N];
long long c[N], v[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 >> c[i] >> v[i];
for (int i = 0; i < k; i++) cin >> x[i];
sort(x, x + k);
x[k] = s;
for (int i = k; i > 0; i--) x[i] -= x[i - 1];
sort(x, x + k + 1);
for (int i = 0; i <= k; i++) sum[i + 1] = sum[i] + x[i];
long long ans = INF;
for (int i = 0; i < n; i++) {
if (x[k] > v[i]) continue;
long long tm = 2 * s;
long long pos = upper_bound(x, x + k + 1, v[i] / 2) - x;
tm -= sum[pos];
tm -= (k + 1 - pos) * v[i] - (sum[k + 1] - sum[pos]);
if (tm <= t) ans = min(ans, c[i]);
}
if (ans == INF)
cout << "-1\n";
else
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> a[250001];
long long b[250001], n, i, k, s, t, l, r, mid, sum, big, nom, ans;
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.second < b.second) return 1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> s >> t;
for (i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
for (i = 1; i <= k; i++) cin >> b[i];
sort(b + 1, b + 1 + k);
for (i = 1; i <= k; i++) big = max(big, b[i] - b[i - 1]);
big = max(big, s - b[k]);
sort(a + 1, a + 1 + n, comp);
l = 1;
r = n;
while (l <= r) {
mid = (l + r) / 2;
if (a[mid].second < big) {
l = mid + 1;
continue;
}
sum = 0;
for (i = 1; i <= k; i++)
sum += min(a[mid].second - (b[i] - b[i - 1]), b[i] - b[i - 1]);
sum += min(a[mid].second - (s - b[k]), s - b[k]);
sum = s * 2 - sum;
if (sum <= t) {
r = mid - 1;
nom = mid;
} else
l = mid + 1;
}
if (nom == 0) {
cout << "-1" << '\n';
return 0;
}
ans = 9000000000000000000LL;
for (i = nom; i <= n; i++) ans = min(ans, a[i].first);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
static const int INF = 1000000010;
int main() {
ios_base::sync_with_stdio(false);
int n, k, s, t;
cin >> n >> k >> s >> t;
vector<pii> cars(n);
for (int i = 0; i < n; ++i) {
cin >> cars[i].second >> cars[i].first;
}
sort(cars.begin(), cars.end());
vector<int> g(k);
for (int i = 0; i < k; ++i) {
cin >> g[i];
}
sort(g.begin(), g.end());
g.push_back(s);
++k;
vector<int> f(k);
for (int i = 0, p = 0; i < k; ++i) {
f[i] = g[i] - p;
p = g[i];
}
sort(f.begin(), f.end());
vector<int> integral(k + 1);
for (int i = 0; i < k; ++i) {
integral[i + 1] = integral[i] + f[i];
}
int answer = INF;
for (const auto& car : cars) {
const int c = car.second, v = car.first;
if (f.back() > v) {
continue;
}
int score = 0;
const int p = upper_bound(f.begin(), f.end(), v / 2) - f.begin();
const int q = integral[k] - integral[p];
score += integral[p] - integral[0];
score += 2 * q - ((v * (k - p)) - q);
if (score <= t) {
answer = min(answer, c);
}
}
if (answer >= INF) {
answer = -1;
}
cout << answer << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i, j, n, k, s, t, pre = 0;
cin >> n >> k >> s >> t;
long long c[n], v[n];
vector<long long> vec;
for (i = 0; i < n; i++) {
cin >> c[i];
cin >> v[i];
}
long long dv[k];
for (i = 0; i < k; i++) cin >> dv[i];
sort(dv, dv + k);
for (i = 0; i < k; i++) {
long long cur;
cur = dv[i];
vec.push_back(cur - pre);
pre = cur;
}
vec.push_back(s - pre);
long long str = 0, end = 1e11, ans = 1e10;
for (i = 0; i < 200; i++) {
long long mid = (str + end) / 2;
long long t1 = 0, ok = 0;
for (auto d : vec) {
long long cc = mid;
if (cc < d) {
ok = -1;
break;
} else if (cc >= 2 * d) {
t1 += d;
} else {
long long x1 = 2 * d - cc;
t1 += d + x1;
}
}
if (ok == -1 || t1 > t) {
str = mid;
} else {
end = mid;
ans = mid;
}
}
long long res = 1e10, fc = -1;
for (i = 0; i < n; i++) {
if (v[i] >= ans && res >= c[i]) {
res = c[i];
fc = v[i];
}
}
if (fc == -1) {
cout << -1 << endl;
} else {
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dX[8] = {1, 0, 0, -1, -1, -1, 1, 1};
int dY[8] = {0, 1, -1, 0, -1, 1, -1, 1};
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};
long double EPS = 1e-9;
long long int mod = 1e9 + 7;
const int N = 1e3 + 10, M = 1e4, OO = 0x3f3f3f3f;
int n, g, second, x;
bool globalAns = 0;
long long int c[200010], p[200010], gs[200010];
long long int l, h, mid, prvMid = -1, mx;
long long int e3mlElSa7() {
h += 20;
while (l < h) {
mid = (l + h) / 2;
if (mid == prvMid) ++mid;
prvMid = mid;
bool v = 1;
long long int curr = 0, t = 0;
for (int i = 0; i < g && v; i++) {
long long int d = gs[i] - curr;
if (d > mid) v = 0;
t += d * 2;
long long int rem = mid - d;
t -= min(rem, d);
curr = gs[i];
}
if (v && t <= x) {
globalAns = 1;
h = mid;
} else
l = mid + 1;
}
return l;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> n >> g >> second >> x;
for (int i = 0; i < n; i++) {
cin >> p[i] >> c[i];
h = max(h, c[i]);
}
mx = h;
for (int i = 0; i < g; i++) cin >> gs[i];
sort(gs, gs + g);
++g;
gs[g - 1] = second;
long long int ans = e3mlElSa7();
if (!globalAns || ans > mx) return cout << -1 << endl, 0;
long long int pr = 1e9 + 1000;
for (int i = 0; i < n; i++)
if (c[i] >= ans) pr = min(pr, p[i]);
cout << pr << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t;
pair<int, int> cars[200111];
int g[200111];
long long mustacc;
int distances[200111];
int L = 0;
bool Okay(int capacity) {
int i;
long long speed = 0;
for (i = 1; i <= L; i++) {
if (distances[i] > capacity) return false;
if ((long long)capacity >= (long long)distances[i] * 2LL) {
speed += (long long)distances[i];
} else {
speed += (long long)(capacity - distances[i]);
}
}
if (speed >= mustacc)
return true;
else
return false;
}
int main() {
int i, j;
int last = 0;
long long toadd;
long long largest;
int l, r, mid, best;
int mincost;
scanf("%d %d %d %d", &n, &k, &s, &t);
for (i = 1; i <= n; i++) {
scanf("%d %d", &cars[i].first, &cars[i].second);
}
for (i = 1; i <= k; i++) {
scanf("%d", &g[i]);
}
sort(g + 1, g + 1 + k);
g[0] = 0;
g[k + 1] = s;
for (i = 1; i <= k + 1; i++) {
L++;
distances[L] = g[i] - g[i - 1];
}
mustacc = (long long)2 * s - (long long)t;
l = 1;
r = 1000000000;
best = -1;
while (l <= r) {
mid = (l + r) / 2;
if (Okay(mid)) {
best = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (best == -1) {
printf("-1\n");
return 0;
}
mincost = -1;
for (i = 1; i <= n; i++) {
if (cars[i].second >= best) {
if (mincost == -1 || mincost > cars[i].first) {
mincost = cars[i].first;
}
}
}
if (mincost == -1) {
printf("-1\n");
return 0;
}
printf("%d\n", mincost);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18 + 1;
long long c[200010], v[200010], g[200010], cum[200010];
vector<long long> d;
int main() {
long long n, k, s, t, ans = 1000000007, val, x;
scanf("%lld%lld%lld%lld", &n, &k, &s, &t);
for (int i = 0; i < n; ++i) scanf("%lld%lld", &c[i], &v[i]);
for (int i = 0; i < k; ++i) scanf("%lld", &g[i]);
g[k] = 0;
g[k + 1] = s;
sort(g, g + k + 2);
for (int i = 0; i < k + 1; ++i) d.push_back(g[i + 1] - g[i]);
sort(d.begin(), d.end());
cum[0] = d[0];
for (int i = 1; i < k + 1; ++i) cum[i] = cum[i - 1] + d[i];
for (int i = 0; i < n; ++i) {
if (v[i] >= d[k]) {
if (v[i] <= 2 * d[0])
val = 3 * cum[k] - (k + 1) * v[i];
else {
x = upper_bound(d.begin(), d.end(), v[i] / 2) - d.begin();
if (x == k + 1)
val = cum[k];
else
val = 3 * cum[k] - 2 * cum[x - 1] - (k + 1 - x) * v[i];
}
if (val <= t) ans = min(ans, c[i]);
}
}
if (ans == 1000000007)
printf("-1\n");
else
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t;
vector<pair<int, int> > inf_car;
vector<int> fuel_stop;
bool f(int x) {
unsigned long long ans = 0;
for (int i = 0; i < k + 1; i++) {
int len = fuel_stop[i + 1] - fuel_stop[i];
if (x < len) {
return 0;
}
if (x >= 2 * len) {
ans += len;
continue;
}
ans += 3 * len - x;
}
if (ans > t) {
return 0;
} else {
return 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
inf_car.resize(n);
for (int i = 0; i < n; i++) {
cin >> inf_car[i].first >> inf_car[i].second;
}
fuel_stop.resize(k + 2);
for (int i = 1; i < k + 1; i++) {
cin >> fuel_stop[i];
}
fuel_stop[k + 1] = s;
sort(fuel_stop.begin(), fuel_stop.end());
unsigned long long l = -1, r = 2 * 1e9 + 1;
while (r - l > 1) {
unsigned long long mid = (r + l) / 2;
if (f(mid)) {
r = mid;
} else {
l = mid;
}
}
unsigned long long min_fuel;
if (r == 2 * 1e9 + 1) {
min_fuel = l;
} else {
min_fuel = r;
}
int ans = -1;
for (auto c : inf_car) {
if (c.second < min_fuel) {
continue;
}
if (ans == -1) {
ans = c.first;
continue;
}
ans = min(ans, c.first);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, k;
long long s, t;
long long c[MAXN], v[MAXN];
long long g[MAXN];
vector<long long> vs;
void init() {
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &c[i], &v[i]);
vs.push_back(v[i]);
}
sort(vs.begin(), vs.end());
vs.push_back(1e9 + 7);
g[0] = 0;
for (int i = 1; i <= k; i++) {
scanf("%lld", &g[i]);
}
sort(g + 1, g + k + 1);
g[k + 1] = s;
}
bool check(long long V) {
long long sum = 0;
for (int i = 0; i <= k; i++) {
long long d = g[i + 1] - g[i];
if (V < d) return 0;
if (V > 2LL * d)
sum += d;
else
sum += 3LL * d - V;
}
return sum <= t;
}
void solve() {
int l = 0, r = n;
while (l != r) {
int mid = (l + r) >> 1;
if (check(vs[mid]))
r = mid;
else
l = mid + 1;
}
long long ans = 1e9 + 7;
for (int i = 0; i < n; i++) {
if (v[i] >= vs[r]) ans = min(ans, c[i]);
}
if (ans == 1e9 + 7 || r == n) {
puts("-1");
return;
}
cout << ans << '\n';
}
int main() {
init();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long to, cost;
edge() {}
edge(long long a, long long b) { to = a, cost = b; }
};
const long long dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
const long long mod = 1000000007;
struct mint {
long long x = 0;
mint(long long y = 0) {
x = y;
if (x < 0 || x >= mod) x = (x % mod + mod) % mod;
}
mint(const mint& ope) { x = ope.x; }
mint operator-() { return mint(-x); }
mint operator+(const mint& ope) { return mint(x) += ope; }
mint operator-(const mint& ope) { return mint(x) -= ope; }
mint operator*(const mint& ope) { return mint(x) *= ope; }
mint operator/(const mint& ope) { return mint(x) /= ope; }
mint& operator+=(const mint& ope) {
x += ope.x;
if (x >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint& ope) {
x += mod - ope.x;
if (x >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint& ope) {
x *= ope.x, x %= mod;
return *this;
}
mint& operator/=(const mint& ope) {
long long n = mod - 2;
mint mul = ope;
while (n) {
if (n & 1) *this *= mul;
mul *= mul;
n >>= 1;
}
return *this;
}
mint inverse() { return mint(1) / *this; }
bool operator==(const mint& ope) { return x == ope.x; }
bool operator!=(const mint& ope) { return x != ope.x; }
};
mint modpow(mint a, long long n) {
if (n == 0) return mint(1);
if (n % 2)
return a * modpow(a, n - 1);
else
return modpow(a * a, n / 2);
}
istream& operator>>(istream& is, mint& ope) {
long long t;
is >> t, ope.x = t;
return is;
}
ostream& operator<<(ostream& os, mint& ope) { return os << ope.x; }
ostream& operator<<(ostream& os, const mint& ope) { return os << ope.x; }
bool exceed(long long x, long long y, long long m) { return x >= m / y + 1; }
void mark() { cout << "*" << endl; }
void yes() { cout << "YES" << endl; }
void no() { cout << "NO" << endl; }
long long sgn(long long x) {
if (x > 0) return 1;
if (x < 0) return -1;
return 0;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long digitnum(long long x, long long b = 10) {
long long ret = 0;
for (; x; x /= b) ret++;
return ret;
}
long long digitsum(long long x, long long b = 10) {
long long ret = 0;
for (; x; x /= b) ret += x % b;
return ret;
}
string lltos(long long x) {
string ret;
for (; x; x /= 10) ret += x % 10 + '0';
reverse(ret.begin(), ret.end());
return ret;
}
long long stoll(string& s) {
long long ret = 0;
for (auto c : s) ret *= 10, ret += c - '0';
return ret;
}
template <typename T>
void uniq(T& vec) {
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& vec) {
for (int i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T>
ostream& operator<<(ostream& os, deque<T>& deq) {
for (int i = 0; i < deq.size(); i++)
os << deq[i] << (i + 1 == deq.size() ? "" : " ");
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, pair<T, U>& pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, map<T, U>& map_var) {
for (typename map<T, U>::iterator itr = map_var.begin(); itr != map_var.end();
itr++) {
os << "(" << itr->first << ", " << itr->second << ")";
itr++;
if (itr != map_var.end()) os << ",";
itr--;
}
return os;
}
template <typename T>
ostream& operator<<(ostream& os, set<T>& set_var) {
for (typename set<T>::iterator itr = set_var.begin(); itr != set_var.end();
itr++) {
os << *itr;
++itr;
if (itr != set_var.end()) os << " ";
itr--;
}
return os;
}
template <typename T>
ostream& operator<<(ostream& os, multiset<T>& set_var) {
for (typename multiset<T>::iterator itr = set_var.begin();
itr != set_var.end(); itr++) {
os << *itr;
++itr;
if (itr != set_var.end()) os << " ";
itr--;
}
return os;
}
template <typename T>
void outa(T a[], long long s, long long t) {
for (long long i = s; i <= t; i++) {
cout << a[i];
if (i < t) cout << " ";
}
cout << endl;
}
void dump_func() { cout << endl; }
template <class Head, class... Tail>
void dump_func(Head&& head, Tail&&... tail) {
cout << head;
if (sizeof...(Tail) > 0) cout << " ";
dump_func(std::move(tail)...);
}
long long n, k, s, t;
long long c[200005], v[200005];
long long g[200005];
bool check(long long x) {
long long tm = 0;
for (long long(i) = (1); (i) <= (k + 1); (i)++) {
long long d = g[i] - g[i - 1];
if (d > x) return false;
tm += 2 * d - min(d, x - d);
}
return tm <= t;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> s >> t;
for (long long(i) = (1); (i) <= (n); (i)++) cin >> c[i] >> v[i];
for (long long(i) = (1); (i) <= (k); (i)++) cin >> g[i];
sort(g + 1, g + k + 1);
g[k + 1] = s;
long long ub = 2e9, lb = 0, mid;
while (ub - lb > 1) {
mid = (ub + lb) / 2;
if (check(mid))
ub = mid;
else
lb = mid;
}
long long ans = 1e18;
for (long long(i) = (1); (i) <= (n); (i)++)
if (v[i] >= ub) (ans) = min((ans), (c[i]));
if (ans > 1e18 / 2) ans = -1;
dump_func(ans);
return 0;
}
|
#include <bits/stdc++.h>
struct information {
long long c;
long long v;
} car[200000], tempcar[200000];
long long n;
long long k;
long long s;
long long t;
long long tol = 0;
long long l[200000];
long long lt[200000];
long long temp[200000];
long long ltmax;
long long minprice;
int flag = 0;
void merge(long long l[], long long temp[], int start, int mid, int end) {
int i, j, k;
i = start;
j = mid + 1;
k = start;
while (i != mid + 1 && j != end + 1) {
if (l[i] > l[j]) {
temp[k] = l[j];
k++;
j++;
} else {
temp[k] = l[i];
k++;
i++;
}
}
while (i != mid + 1) {
temp[k] = l[i];
k++;
i++;
}
while (j != end + 1) {
temp[k] = l[j];
k++;
j++;
}
for (i = start; i <= end; i++) {
l[i] = temp[i];
}
}
void mergesort(long long l[], long long temp[], int start, int end) {
int mid;
if (start < end) {
mid = (start + end) / 2;
mergesort(l, temp, start, mid);
mergesort(l, temp, mid + 1, end);
merge(l, temp, start, mid, end);
}
}
void mergecar(struct information car[200000],
struct information tempcar[200000], int start, int mid, int end) {
int i, j, k;
i = start;
j = mid + 1;
k = start;
while (i != mid + 1 && j != end + 1) {
if (car[i].v > car[j].v) {
tempcar[k] = car[j];
k++;
j++;
} else {
tempcar[k] = car[i];
k++;
i++;
}
}
while (i != mid + 1) {
tempcar[k] = car[i];
k++;
i++;
}
while (j != end + 1) {
tempcar[k] = car[j];
k++;
j++;
}
for (i = start; i <= end; i++) {
car[i] = tempcar[i];
}
}
void mergesortcar(struct information car[200000],
struct information tempcar[200000], int start, int end) {
int mid;
if (start < end) {
mid = (start + end) / 2;
mergesortcar(car, tempcar, start, mid);
mergesortcar(car, tempcar, mid + 1, end);
mergecar(car, tempcar, start, mid, end);
}
}
int check(long long v) {
long long i;
if (v < ltmax) return 0;
for (i = 0; i <= k; i++) {
if (v > 2 * lt[i])
tol = tol + lt[i];
else
tol = tol + 3 * lt[i] - v;
if (tol > t) return 0;
}
flag = 1;
return 1;
}
int main() {
long long i, j;
scanf("%lld%lld%lld%lld", &n, &k, &s, &t);
for (i = 0; i < n; i++) {
scanf("%lld%lld", &car[i].c, &car[i].v);
}
for (i = 0; i < k; i++) {
scanf("%lld", &l[i]);
}
mergesort(l, temp, 0, k - 1);
l[k] = s;
for (i = k; i > 0; i--) {
lt[i] = l[i] - l[i - 1];
}
lt[0] = l[0];
ltmax = l[0];
for (i = 0; i <= k; i++) {
if (ltmax < lt[i]) ltmax = lt[i];
}
mergesortcar(car, tempcar, 0, n - 1);
long long left, right, mid;
left = 0;
right = n;
flag = 0;
while (left < right) {
tol = 0;
mid = (left + right) / 2;
if (check(car[mid].v) == 1)
right = mid;
else
left = mid + 1;
}
if (flag == 0)
printf("%d", -1);
else {
minprice = car[left].c;
for (i = left; i < n; i++) {
if (car[i].c < minprice) minprice = car[i].c;
}
printf("%lld", minprice);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long oo = 0x3f3f3f3f3f3f3f3f;
long long check(long long tank, vector<long long> dist) {
long long ans = 0, cur = 0;
for (auto p : dist) {
long long d = p - cur;
cur = p;
if (tank < d) return oo;
ans += 2 * d - min(d, tank - d);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<long long, long long> > car(n), good;
for (long long i = 0; i < n; ++i) {
long long c, v;
cin >> c >> v;
car[i] = pair<long long, long long>(c, v);
}
sort(car.begin(), car.end());
for (long long i = 0; i < n; ++i) {
if (i == 0 || car[i].second > good.back().second) good.push_back(car[i]);
}
vector<long long> dist(k + 1);
for (long long i = 0; i < k; ++i) cin >> dist[i];
dist[k] = s;
sort(dist.begin(), dist.end());
long long l = -1, h = (int)good.size() - 1;
if (check(good[h].second, dist) > t)
cout << -1 << '\n';
else {
while (l + 1 < h) {
long long m = (l + h) >> 1;
if (check(good[m].second, dist) <= t)
h = m;
else
l = m;
}
cout << good[h].first << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int n, k, s, t, flag = 0;
struct node {
int c, v;
node(int c = 0, int v = 0) : c(c), v(v) {}
bool operator<(const node &a) const { return v < a.v; }
};
node car[maxn];
int ki[maxn], del[maxn];
void init() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 1; i <= n; ++i) {
int c, v;
scanf("%d%d", &c, &v);
car[i] = node(c, v);
}
for (int i = 1; i <= k; ++i) scanf("%d", &ki[i]);
sort(ki + 1, ki + k + 1);
del[0] = ki[1];
for (int i = 1; i <= k - 1; ++i) del[i] = ki[i + 1] - ki[i];
del[k] = s - ki[k];
}
bool check(int nw) {
int l = car[nw].v, tim = 0;
for (int i = 0; i <= k; ++i) {
if (2 * del[i] <= l)
tim += del[i];
else if (del[i] > l / 2 && del[i] <= l)
tim += (3 * del[i] - l);
else
return 0;
}
if (tim <= t) {
flag = 1;
return 1;
} else
return 0;
}
int py = 0;
node ys[maxn];
int main() {
init();
sort(car + 1, car + n + 1);
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) / 2;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
int std = car[l].v;
for (int i = 1; i <= n; ++i)
if (car[i].v >= std) ys[++py] = car[i];
if (!flag) {
printf("-1");
return 0;
}
int ans = 2147483647;
for (int i = 1; i <= py; ++i) ans = min(ans, ys[i].c);
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2 * 1e5 + 100;
long long n, k, s, t, c[N], v[N], g[N], d[N], sum[N];
inline long long read() {
long long f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
signed main() {
n = read();
k = read();
s = read();
t = read();
for (long long i = 1; i <= n; i++) c[i] = read(), v[i] = read();
for (long long i = 1; i <= k; i++) g[i] = read();
sort(g + 1, g + 1 + k);
for (long long i = 1; i <= k; i++) d[i] = g[i] - g[i - 1];
d[k + 1] = s - g[k];
k++;
sort(d + 1, d + 1 + k);
for (long long i = 1; i <= k; i++) sum[i] = sum[i - 1] + d[i];
if (t < s) {
printf("-1\n");
return 0;
}
long long MIN = 0x3f3f3f3f;
for (long long i = 1; i <= n; i++) {
if (v[i] < d[k]) continue;
long long pos = upper_bound(d + 1, d + 1 + k, v[i] / 2) - d - 1;
long long all = sum[pos] + (sum[k] - sum[pos]) * 3 - (k - pos) * v[i];
if (all <= t) MIN = min(MIN, c[i]);
}
if (MIN == 0x3f3f3f3f)
printf("-1\n");
else
printf("%lld\n", MIN);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, gas, lis[200005], s, t, cost, cap;
pair<long long, long long> p[200005];
vector<pair<long long, long long> > v;
bool check(int x) {
cap = v[x].second;
long long tot = 0;
for (int i = (0); i <= (gas); i++) {
long long tmp = lis[i + 1] - lis[i];
if (tmp > cap) return false;
tot += tmp * 2;
tot -= min(tmp, cap - tmp);
}
return tot <= t;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> gas >> s >> t;
for (int i = (0); i <= ((n)-1); i++) {
cin >> cost >> cap;
p[i] = {cost, cap};
}
for (int i = (1); i <= (gas); i++) cin >> lis[i];
sort(lis + 1, lis + 1 + gas);
lis[gas + 1] = s;
sort(p, p + n);
v.push_back(p[0]);
for (int i = (1); i <= (n - 1); i++) {
cost = v.back().first;
cap = v.back().second;
if (p[i].second < cap) continue;
if (p[i].first == cost) {
v.pop_back();
}
v.push_back(p[i]);
}
int high = v.size();
int low = 0;
while (high > low) {
int chs = (high + low) / 2;
if (check(chs))
high = chs;
else
low = chs + 1;
}
if (high == v.size())
cout << -1;
else
cout << v[high].first;
}
|
#include <bits/stdc++.h>
using namespace std;
int greedy(int L, int F) {
if (F < L) return -1;
int l1 = min(L, F - L);
int l2 = L - l1;
return l1 + l2 * 2;
};
vector<int> g;
bool go(int T, int V) {
int it = 0;
int ret = 0;
for (int x : g) {
int q = greedy(x - it, V);
if (q < 0) return false;
ret += q;
it = x;
}
return ret <= T;
}
int U[222222], V[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", U + i, V + i);
for (int i = 0; i < K; i++) {
int x;
scanf("%d", &x);
g.push_back(x);
}
sort(g.begin(), g.end());
g.push_back(S);
int lo = 1, hi = 1e9 + 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (go(T, mid))
hi = mid;
else
lo = mid + 1;
}
int id = -1;
for (int i = 0; i < N; i++) {
if (V[i] >= lo) {
if (id == -1 || U[i] < U[id]) id = i;
}
}
if (id == -1)
printf("-1");
else
printf("%d", U[id]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long>> c;
vector<pair<long long, long long>> cars;
vector<long long> gas;
vector<long long> dist;
long n, k;
long long s, T;
bool can(long mid) {
long long t = 0;
for (auto d : dist) {
long long temp = min(d, cars[mid].second - d);
if (temp < 0) return false;
t += temp + (d - temp) * 2;
}
return t <= T;
}
int main() {
scanf("%d%d%I64d%I64d", &n, &k, &s, &T);
long long x, y;
for (int i = 0; i < n; ++i) {
scanf("%I64d%I64d", &x, &y);
c.push_back(make_pair(x, y));
}
sort(begin(c), end(c));
cars.push_back(c[0]);
for (int i = 1; i < c.size(); ++i)
if (cars.back().second < c[i].second) cars.push_back(c[i]);
for (int i = 0; i < k; ++i) {
scanf("%I64d", &x);
gas.push_back(x);
}
gas.push_back(0);
gas.push_back(s);
sort(begin(gas), end(gas));
for (int i = 1; i < gas.size(); ++i) dist.push_back(gas[i] - gas[i - 1]);
long ans = -1;
long l = 0, r = cars.size();
while (l < r) {
long mid = (l + r) / 2;
if (can(mid)) {
ans = mid;
r = mid;
} else
l = mid + 1;
}
if (ans == -1)
puts("-1");
else
printf("%I64d", cars[ans].first);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, s, t;
long long ans = 1e15 + 1;
vector<pair<long long, long long> > car;
long long g[200010];
bool check(long long f) {
long long T = 0;
for (int i = 1; i <= k; i++) {
long long delta = g[i] - g[i - 1];
long long a = max(0 * 1LL, 2 * delta - f);
long long b = delta - a;
if (b < 0) return false;
T += 2 * a + b;
}
if (T <= t) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> s >> t;
if (t < s) {
cout << -1;
return 0;
}
for (int i = 1; i <= n; i++) {
long long c, v;
cin >> c >> v;
car.push_back(pair<long long, long long>(c, v));
}
for (int i = 1; i <= k; i++) cin >> g[i];
g[++k] = s;
sort(g + 1, g + k + 1);
int l = 0, r = s + 1, mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
for (int i = 0; i < n; i++) {
if (car[i].second >= r) {
ans = min(ans, car[i].first);
}
}
if (ans == 1e15 + 1)
cout << -1;
else
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 * 5;
struct node {
int c, v;
} sv[MAXN];
bool cmp1(const node &a, const node &b) { return a.v < b.v; }
bool cmp2(const node &a, const node &b) { return a.c < b.c; }
int g[MAXN];
long long n, k, s, t;
bool judge(long long v) {
long long tot = 0, tmp;
for (int i = k; i >= 1; i--) {
tmp = v;
long long dis = g[i] - g[i - 1];
if (dis > v) return false;
tmp -= dis;
tot += 2 * dis;
tot -= min(tmp, dis);
}
return tot <= t;
}
int main() {
scanf("%lld%lld%lld%lld", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &sv[i].c, &sv[i].v);
}
for (int i = 1; i <= k; i++) {
scanf("%d", &g[i]);
}
k++;
g[0] = 0, g[k] = s;
sort(g + 1, g + 1 + k);
long long l = 0, r = 1e9 + 7, ans = 1e9 + 7;
while (l <= r) {
long long m = (l + r) >> 1;
if (judge(m)) {
ans = min(ans, m);
r = m - 1;
} else {
l = m + 1;
}
}
node T;
T.c = 0, T.v = ans;
sort(sv + 1, sv + 1 + n, cmp1);
int pos = lower_bound(sv + 1, sv + 1 + n, T, cmp1) - sv;
sort(sv + pos, sv + 1 + n, cmp2);
if (pos == n + 1) return 0 * printf("-1\n");
printf("%d\n", sv[pos].c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool Can(long long t, const vector<long long>& dists, long long cap) {
if (cap < dists[dists.size() - 1]) {
return false;
}
long long timetaken = 0;
for (long long i = 0; i < dists.size(); ++i) {
timetaken += max(dists[i], dists[i] * 3 - cap);
}
return timetaken <= t;
}
long long MinCap(long long t, const vector<long long>& dists) {
long long LB = 0, UB = 1e9, result = LLONG_MAX;
long long pos = (LB + UB) / 2;
while (LB <= UB) {
if (Can(t, dists, pos)) {
result = pos;
UB = pos - 1;
} else {
LB = pos + 1;
}
pos = (LB + UB) / 2;
}
return result;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
long long c[n], v[n];
for (long long i = 0; i < n; ++i) {
cin >> c[i] >> v[i];
}
vector<long long> gas(k);
for (long long i = 0; i < k; ++i) {
cin >> gas[i];
}
sort(gas.begin(), gas.end());
vector<long long> dists(k + 1);
dists[0] = gas[0];
for (long long i = 1; i < k; ++i) {
dists[i] = gas[i] - gas[i - 1];
}
dists[k] = s - gas[k - 1];
sort(dists.begin(), dists.end());
long long mincap = MinCap(t, dists);
long long ans = LLONG_MAX;
for (long long i = 0; i < n; ++i) {
if (v[i] >= mincap && c[i] < ans) {
ans = c[i];
}
}
if (ans == LLONG_MAX) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int SIZE = 1e6 + 5;
const long long INF = 1LL << 60;
const double eps = 1e-4;
const double PI = 3.1415926535897932;
int x[200009];
pair<int, int> vv[200009];
vector<pair<int, int> > v;
int main() {
int n, k;
scanf("%d%d", &n, &k);
int s, t;
scanf("%d%d", &s, &t);
for (int i = 0; i < (n); ++i) {
scanf("%d%d", &(vv[i].first), &(vv[i].second));
}
sort(vv, vv + n);
for (int i = 0; i < (n); ++i) {
if (i == 0 || vv[i].second > v.back().second) {
v.push_back(vv[i]);
}
}
n = ((int)(v).size());
for (int i = 0; i < (k); ++i) {
scanf("%d", &(x[i]));
}
sort(x, x + k);
x[k] = s;
int st = 0, en = n;
while (st < en) {
int mi = (st + en) / 2;
int ts = v[mi].second;
long long mint = 0;
for (int i = 0; i < (k + 1); ++i) {
int rl = i ? x[i] - x[i - 1] : x[i];
if (rl > ts) {
mint = INF;
break;
}
mint += max(2LL * (long long)rl - (long long)(ts - rl), (long long)rl);
}
if (mint <= t) {
en = mi;
} else {
st = mi + 1;
}
}
if (en == n)
printf("-1");
else
printf("%d", v[st].first);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 200000;
const long long INF = 2e9 + 1;
long long n, m, s, t, c[MAXN + 5], v[MAXN + 5], x[MAXN + 5];
long long calc(long long v) {
long long res = 0, last = 0;
for (int i = 0; i < m; ++i) {
long long dist = x[i] - last;
if (dist > v) return INF;
if (dist * 2 <= v) {
res += x[i] - last;
} else {
long long tmp = v - dist;
res += tmp + (dist - tmp) * 2;
}
last = x[i];
}
return res;
}
long long search() {
long long lef = 0, rig = INF;
while (lef < rig) {
long long mid = (lef + rig) / 2;
if (calc(mid) <= t) {
rig = mid;
} else {
lef = mid + 1;
}
}
return lef;
}
int main() {
scanf("%lld %lld %lld %lld", &n, &m, &s, &t);
for (int i = 0; i < n; ++i) scanf("%lld %lld", c + i, v + i);
for (int i = 0; i < m; ++i) scanf("%lld", x + i);
x[m++] = s;
sort(x, x + m);
long long mn = search();
long long res = -1;
for (int i = 0; i < n; ++i)
if (v[i] >= mn) {
if (res == -1 || c[i] < res) res = c[i];
}
printf("%lld\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
int main() {
std::ios::sync_with_stdio(false);
long long n, k, s, t;
scanf("%lld %lld %lld %lld", &n, &k, &s, &t);
std::vector<long long> shit(n), shit2(n);
for (int i = 0; i < n; ++i) {
scanf("%lld", &shit[i]);
scanf("%lld", &shit2[i]);
}
std::vector<long long> g(k);
for (int i = 0; i < k; ++i) scanf("%lld", &g[i]);
g.push_back(0);
sort(g.begin(), g.end());
g.push_back(s);
long long answ = inf;
long long l = 0, r = inf;
while (r - l > 1) {
long long v = (l + r) / 2;
long long curVR = 0;
for (int j = 0; j < k + 1; ++j) {
long long dist = abs(g[j] - g[j + 1]);
if (dist > v) {
curVR = inf;
break;
}
if (dist > v / 2) {
curVR += 3 * dist - v;
} else {
curVR += dist;
}
}
if (curVR > t) {
l = v;
}
if (curVR <= t) {
r = v;
}
}
for (int i = 0; i < n; ++i) {
if (shit2[i] >= r) {
answ = std::min(answ, shit[i]);
}
}
if (answ == inf)
std::cout << -1;
else
std::cout << answ;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int M = 2e5 + 5, LG = 20, inf = 1e18 + 5, mod = 1e9 + 7;
long long int n, k, s, t;
long long int cc[M], cv[M];
long long int g[M];
bool check(long long int x) {
long long int min = 0;
for (int i = 0; i < k; i++) {
if (g[i] > x) return 0;
if (2 * g[i] <= x) {
min += g[i];
continue;
}
min += 3 * g[i] - x;
}
return (min <= t);
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
cin >> cc[i] >> cv[i];
}
for (int i = 0; i < k; i++) {
cin >> g[i];
}
sort(g, g + k);
g[k] = s;
for (int i = k; i >= 1; i--) g[i] -= g[i - 1];
k++;
long long int l = 0, r = inf;
while (r - l > 1) {
long long int mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
long long int res = inf;
for (int i = 0; i < n; i++) {
if (cv[i] >= r) res = min(res, cc[i]);
}
cout << (res == inf ? -1 : res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXNK = 2e5 + 10;
const long long INF = 1e18;
struct dian {
int c, v;
};
dian node[MAXNK];
int g[MAXNK];
int n, k, s;
long long T;
long long fi = INF;
bool cmp1(dian a, dian b) { return a.v < b.v; }
int cmp2(dian a, dian b) { return a.c < b.c; }
bool judge(int sum) {
int t = 0;
for (int i = 2; i <= k; i++) {
int dis = g[i] - g[i - 1];
if (sum < dis) return false;
if (sum >= 2 * dis)
t += dis;
else
t += 3 * dis - sum;
if (t > T) return false;
}
return true;
}
int main() {
cin >> n >> k >> s >> T;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &node[i].c, &node[i].v);
}
for (int i = 1; i <= k; i++) {
scanf("%d", &g[i]);
}
g[++k] = 0;
g[++k] = s;
sort(g + 1, g + 1 + k);
sort(node + 1, node + 1 + n, cmp1);
int l = 1, r = n, ans = -1;
while (l <= r) {
int m = (l + r) >> 1;
if (judge(node[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 (node[i].v >= node[ans].v && node[i].c < fi) fi = node[i].c;
}
cout << fi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 6;
long long int n, k, s, t;
vector<pair<long long int, long long int> > v;
int g[N];
long long int get(long long int dist, long long int cap) {
if (cap >= 2 * 1LL * dist) {
return (dist);
}
long long int c_minus_d = cap - dist;
if (c_minus_d < 0) return -1;
long long int dist_by_normal = dist * 2 - cap;
long long int dist_by_accel = dist - dist_by_normal;
return (dist_by_normal * 1LL * 2 + dist_by_accel);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
v.push_back(make_pair(x, y));
}
for (int i = 1; i <= k; i++) {
cin >> g[i];
}
g[0] = 0;
g[k + 1] = s;
sort(g, g + k + 2);
long long int lo = 0;
long long int hi = 1234567892345672822;
long long int ans = 1234567892345678222;
while (hi - lo > 2) {
long long int mid = (lo + hi) / 2;
long long int cur_time = 0;
int fl = 0;
for (int i = 1; i <= k + 1; i++) {
long long int dist = g[i] - g[i - 1];
long long int timeTaken = get(dist, mid);
if (timeTaken >= 0) {
cur_time += timeTaken;
} else {
fl = 1;
break;
}
}
if (fl or cur_time > t)
lo = mid;
else
hi = mid;
}
while (lo <= hi) {
long long int cur_time = 0;
int fl = 0;
for (int i = 1; i <= k + 1; i++) {
long long int dist = g[i] - g[i - 1];
long long int timeTaken = get(dist, lo);
if (timeTaken >= 0) {
cur_time += timeTaken;
} else {
fl = 1;
break;
}
}
if (fl or cur_time > t)
lo++;
else
break;
}
int zz = v.size();
for (int i = 0; i < zz; i++) {
if (v[i].second >= lo) {
ans = min(ans, v[i].first);
}
}
if (ans >= 1234567892345678222) ans = -1;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1 << 28;
const long long LINF = 1ll << 61;
inline long long getnum() {
register long long r = 0;
register bool ng = 0;
register char c;
c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') ng = 1, c = getchar();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = getchar();
if (ng) r = -r;
return r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline void putsp() { putchar(' '); }
inline void putendl() { putchar('\n'); }
inline char mygetchar() {
register char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
int n, m;
long long s, t, pos[200111];
long long tc[200111], tv[200111];
bool check(long long x) {
long long ti = 0;
for (int i = 0; i <= m; i++) {
long long len = pos[i + 1] - pos[i];
if (len > x) return false;
if (len <= x / 2) {
ti += len;
} else {
ti += (x - len) + 2 * (len - (x - len));
}
}
return ti <= t;
}
int main() {
n = getnum(), m = getnum();
s = getnum(), t = getnum();
for (int i = 1; i <= n; i++) tc[i] = getnum(), tv[i] = getnum();
for (int i = 1; i <= m; i++) {
pos[i] = getnum();
}
sort(pos + 1, pos + m + 1);
pos[0] = 0;
pos[m + 1] = s;
long long l = 1, r = 1ll << 50;
while (l <= r) {
long long mid = l + r >> 1;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
long long ans = 1ll << 50;
for (int i = 1; i <= n; i++) {
if (tv[i] < l) continue;
ans = min(ans, tc[i]);
}
if (ans == (1ll << 50))
puts("-1");
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s;
long long t;
vector<pair<int, int> > cv;
vector<long long> g, d;
long long fu(long long v, long long dd) {
if (dd > v) return (long long)3e9;
if (dd + dd <= v) return dd;
return (v + v - 3ll * (v - dd));
}
bool ok(long long v) {
long long sum = 0;
for (int i = 0; i < d.size(); ++i) sum += fu(v, d[i]);
return (sum <= t);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
cv.resize(n);
for (int i = 0; i < n; ++i) cin >> cv[i].first >> cv[i].second;
sort(cv.begin(), cv.end());
g.resize(k);
for (int i = 0; i < k; ++i) cin >> g[i];
g.push_back(0);
g.push_back(s);
sort(g.begin(), g.end());
for (int i = 1; i < g.size(); ++i) d.push_back(g[i] - g[i - 1]);
int l = 0;
int r = 1000000000;
if (!ok(r)) {
cout << -1 << endl;
return 0;
}
while (r - l > 1) {
int mid = (r + l) / 2;
(ok(mid) ? r : l) = mid;
}
int res = 2000000000;
for (int i = 0; i < n; ++i) {
if (cv[i].second >= r) res = min(res, cv[i].first);
}
if (res == 2000000000) res = -1;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int GLL(long long& x) { return scanf("%lld", &x); }
int GI(int& x) { return scanf("%d", &x); }
int n, k;
long long s, t;
const int MAXN = 200010;
long long c[MAXN], v[MAXN], g[MAXN];
bool check(long long x) {
long long tm = 0;
long long prev = 0;
for (int i = 0; i < (int)(k + 1); i++) {
long long delta = g[i] - prev;
if (x < delta) return false;
tm += 2 * delta - min(delta, x - delta);
prev = g[i];
}
return (tm <= t);
}
int main() {
GI(n);
GI(k);
GLL(s);
GLL(t);
for (int i = 0; i < (int)(n); i++) {
GLL(c[i]);
GLL(v[i]);
}
for (int i = 0; i < (int)(k); i++) {
GLL(g[i]);
}
g[k] = s;
sort(g, g + k + 1);
long long lo = 0;
long long hi = 2000000000 + 5;
long long res = 2000000000 + 5;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (check(mid)) {
res = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
long long ans = 2000000000;
for (int i = 0; i < (int)(n); i++) {
if (v[i] >= res) {
ans = min(ans, c[i]);
}
}
if (ans == 2000000000) {
printf("-1\n");
} else {
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
constexpr int N = 1e5 + 5;
int n, g, L, t;
vector<pair<int, int>> cars;
vector<int> gas;
vector<int> distances;
bool possible(int v) {
const int capacity = v;
LL T = 0;
for (auto D : distances) {
if (D > capacity) return false;
LL x = min(D, capacity - D);
LL y = D - x;
T += x + 2 * y;
assert(x + y == D);
assert(capacity >= 2 * x + y);
}
if (T > t) return false;
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> g >> L >> t;
cars.resize(n);
gas.resize(g);
for (auto& p : cars) cin >> p.second >> p.first;
for (auto& p : gas) cin >> p;
gas.push_back(0);
gas.push_back(L);
g += 2;
sort(begin(cars), end(cars));
sort(begin(gas), end(gas));
for (int i = 0; i + 1 < g; i++) {
distances.push_back(gas[i + 1] - gas[i]);
}
int v = -1;
int l = 1, r = 1e9;
while (l <= r) {
int m = (l + r) / 2;
if (possible(m)) {
v = m;
r = m - 1;
} else {
l = m + 1;
}
}
if (v == -1)
cout << -1;
else {
int ans = 2e9 + 100;
for (int i = 0; i < n; i++)
if (cars[i].first >= v) ans = min(ans, cars[i].second);
cout << (ans > 1e9 + 7 ? -1 : ans) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int cars_cnt, fs_cnt, distance, til_time;
cin >> cars_cnt >> fs_cnt >> distance >> til_time;
vector<pair<int, int>> cars;
cars.reserve(cars_cnt);
for (int i = 0; i < cars_cnt; i++) {
int ci, vi;
cin >> ci >> vi;
cars.push_back(make_pair(vi, ci));
}
vector<int> gas_stations;
gas_stations.reserve(fs_cnt);
for (int i = 0; i < fs_cnt; i++) {
int tmp;
cin >> tmp;
gas_stations.push_back(tmp);
}
gas_stations.push_back(distance);
sort(gas_stations.begin(), gas_stations.end());
sort(cars.begin(), cars.end());
int l = -1, r = cars_cnt, m;
while (r - l > 1) {
m = l + (r - l) / 2;
int t = 0;
int fuel_max = cars[m].first;
int p = 0;
int dist = 0;
bool ok = true;
while (p < gas_stations.size()) {
int travel = gas_stations[p] - dist;
if (travel > fuel_max) {
ok = false;
break;
}
t += 2 * travel - min(travel, fuel_max - travel);
dist = gas_stations[p];
p++;
}
if (t <= til_time && ok) {
r = m;
} else {
l = m;
}
}
int mm = 1000000001;
for (int i = r; i < cars_cnt; i++) {
if (cars[i].second < mm) {
mm = cars[i].second;
}
}
if (mm == 1000000001) {
cout << -1 << endl;
} else {
cout << mm << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 2e5 + 5;
long long c, d;
int n, k, s, t, i, l, r, a[MN], b[MN], ans = 1 << 30;
pair<int, int> arr[MN];
int main() {
for (scanf("%d%d%d%d", &n, &k, &s, &t), i = 1; i <= n; i++)
scanf("%d%d", &arr[i].first, &arr[i].second);
sort(arr + 1, arr + n + 1,
[](pair<int, int> i, pair<int, int> j) { return i.second < j.second; });
for (i = 1; i <= k; i++) scanf("%d", &b[i]);
sort(b + 1, b + k + 1);
for (i = 1; i <= k; i++) a[i] = b[i] - b[i - 1];
a[k + 1] = s - b[k];
k++;
sort(a + 1, a + k + 1);
for (i = l = r = 1; i <= n; i++) {
while (r <= k && a[r] <= arr[i].second) {
d += 3LL * a[r++];
c++;
}
while (l <= k && 2 * a[l] <= arr[i].second) {
d -= 2LL * a[l++];
c--;
}
if (r == k + 1 && d - 1LL * arr[i].second * c <= t)
ans = min(ans, arr[i].first);
}
printf("%d\n", ans == 1 << 30 ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k, s, t;
int cost[N];
int cap[N];
int g[N];
int f(int x) {
int cur = 0;
for (int i = 0; i <= k; i++) {
int dist;
if (i == 0)
dist = g[i];
else
dist = g[i] - g[i - 1];
if (dist > x) return 0;
int two = min(dist, x - dist);
int one = dist - two;
cur += 2 * one + two;
}
return (cur <= t);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) {
cin >> cost[i] >> cap[i];
}
long long int lo = 1;
long long int hi = INT_MAX;
for (int i = 0; i < k; i++) {
cin >> g[i];
}
g[k] = s;
sort(g, g + k);
int ans = INT_MAX;
while (hi - lo > 2) {
long long int mid = hi + lo;
mid /= 2;
if (!f(mid))
lo = mid;
else
hi = mid;
}
while (!f(lo) and lo <= hi) lo++;
for (int i = 1; i <= n; i++) {
if (cap[i] >= lo) {
ans = min(ans, cost[i]);
}
}
if (ans == INT_MAX) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 5;
const long long INF64 = 1e18;
template <typename T>
string to_string(const vector<T> &v) {
string ret = "<";
for (auto it : v) {
ret += to_string(it) + ", ";
}
ret.pop_back();
ret.pop_back();
ret += ">";
return ret;
}
void debug_print() { cerr << endl; }
template <typename T, typename... U>
void debug_print(T t, U... u) {
cerr << " " << to_string(t);
debug_print(u...);
}
const int N = 1e5 + 5;
vector<pair<long long, long long> > v;
vector<long long> fuel;
bool can(long long cur, long long t) {
long long now = 0ll;
for (int i = 0; i < fuel.size(); i++) {
if (fuel[i] > cur) return false;
long long x = (cur - fuel[i]);
long long y = 2 * fuel[i] - 2 * x;
if (y < 0) {
x = fuel[i];
y = 0;
}
now += x + y;
}
return now <= t;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
v.resize(n);
for (auto &it : v) {
cin >> it.first >> it.second;
}
vector<long long> pos;
for (int i = 0; i < k; i++) {
long long a;
cin >> a;
pos.push_back(a);
}
sort(pos.begin(), pos.end());
for (int i = 0; i < k; i++) {
if (i == 0)
fuel.push_back(pos[i]);
else
fuel.push_back(pos[i] - pos[i - 1]);
}
fuel.push_back(s - pos.back());
long long lo = 0;
long long hi = INF;
while (lo < hi) {
long long mid = lo + (hi - lo) / 2;
if (can(mid, t)) {
hi = mid;
} else
lo = mid + 1;
}
long long ans = INF64;
for (auto it : v) {
if (it.second < hi) continue;
ans = min(ans, it.first);
}
cout << (ans == INF64 ? -1 : ans) << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.