text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
long long dx[4] = {0, -1, 0, 1};
long long dy[4] = {1, 0, -1, 0};
using namespace std;
class pa3 {
public:
long long x, y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
long long x;
long long y, z, w;
pa4(long long x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator>(const pa2 &p) const { return x != p.x ? x > p.x : y > p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < (1e-7) && fabs(y - p.y) < (1e-7);
}
};
struct Segment {
Point p1, p2;
};
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
bool parareru(Point a, Point b, Point c, Point d) {
return abs(cross(a - b, d - c)) < (1e-7);
}
double distance_ls_p(Point a, Point b, Point c) {
if (dot(b - a, c - a) < (1e-7)) return (c - a).absv();
if (dot(a - b, c - b) < (1e-7)) return (c - b).absv();
return abs(cross(b - a, c - a)) / (b - a).absv();
}
bool is_intersected_ls(Segment a, Segment b) {
if (a.p1 == b.p1 || a.p2 == b.p1 || a.p1 == b.p2 || a.p2 == b.p2)
return false;
if (parareru((a.p2), (a.p1), (a.p1), (b.p2)) &&
parareru((a.p2), (a.p1), (a.p1), (b.p1))) {
if (dot(a.p1 - b.p1, a.p1 - b.p2) < (1e-7)) return true;
if (dot(a.p2 - b.p1, a.p2 - b.p2) < (1e-7)) return true;
if (dot(a.p1 - b.p1, a.p2 - b.p1) < (1e-7)) return true;
if (dot(a.p1 - b.p2, a.p2 - b.p2) < (1e-7)) return true;
return false;
} else
return (cross(a.p2 - a.p1, b.p1 - a.p1) * cross(a.p2 - a.p1, b.p2 - a.p1) <
(1e-7)) &&
(cross(b.p2 - b.p1, a.p1 - b.p1) * cross(b.p2 - b.p1, a.p2 - b.p1) <
(1e-7));
}
double segment_dis(Segment a, Segment b) {
if (is_intersected_ls(a, b)) return 0;
double r = distance_ls_p(a.p1, a.p2, b.p1);
r = min(r, distance_ls_p(a.p1, a.p2, b.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2 - b.p1;
double d1 = abs(cross(ba, a.p1 - b.p1));
double d2 = abs(cross(ba, a.p2 - b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2 - a.p1) * t;
}
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
long long beki(long long wa, long long rr, long long warukazu) {
if (rr == 0) return 1ll;
if (rr == 1) return wa % warukazu;
if (rr % 2 == 1) return (beki(wa, rr - 1, warukazu) * wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
unsigned long long randxor() {
static unsigned long long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long long t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
long long n, k, p;
vector<long long> iti, kagi;
vector<pair<long long, long long>> ve;
priority_queue<long long, vector<long long>, greater<long long>> pq;
bool ch(long long r) {
while (pq.size()) pq.pop();
ve.clear();
for (long long i = 0; i < n; i++) {
if (abs(p - iti[i]) > r) {
return 0;
}
long long noko = -abs(p - iti[i]) + r;
long long si = min(p, iti[i]) - noko / 2;
long long ue = max(p, iti[i]) + noko / 2;
long long ur = upper_bound(kagi.begin(), kagi.end(), ue) - kagi.begin();
long long sr = lower_bound(kagi.begin(), kagi.end(), si) - kagi.begin();
if (sr >= ur) return 0;
ve.push_back(make_pair(sr, ur));
}
sort(ve.begin(), ve.end());
ve.push_back(make_pair(1000000007, 1000000007));
long long it = 0;
for (long long i = 0; i < k; i++) {
while (ve[it].first == i) {
pq.push(ve[it].second);
it++;
}
if (pq.size()) {
long long z = pq.top();
pq.pop();
if (z <= i) return 0;
}
}
return pq.size() == 0;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> k >> p;
for (long long i = 0; i < n; i++) {
long long y;
cin >> y;
iti.push_back(y);
}
for (long long i = 0; i < k; i++) {
long long y;
cin >> y;
kagi.push_back(y);
}
sort(kagi.begin(), kagi.end());
if (ch(0)) {
cout << 0 << endl;
return 0;
}
long long si = 0, ue = 100ll * 1000000007, me;
while (ue - si > 1) {
me = (ue + si) / 2;
if (ch(me))
ue = me;
else
si = me;
}
cout << ue << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio("false");
int n, k, p;
cin >> n >> k >> p;
vector<int> a(n);
vector<int> b(k);
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < k; ++i) cin >> b[i];
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
int time = INT_MAX;
int i = 0, j = 0, m = 0;
while (m + n - 1 < k) {
i = m;
j = 0;
int mxl = 0;
while (j < n) {
int l = 0;
if (b[i] <= a[j] && a[j] <= p || p <= a[j] && a[j] <= b[i])
l = abs(a[j] - b[i]) + abs(p - b[i]);
else if (a[j] <= b[i] && b[i] <= p || p <= b[i] && b[i] <= a[j])
l = abs(p - a[j]);
else
l = abs(a[j] - b[i]) + abs(b[i] - p);
if (l > mxl) mxl = l;
++i;
++j;
}
if (mxl < time) time = mxl;
++m;
}
cout << time;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p;
int a[150000];
int b[150000];
bool check(int x) {
int now = 1;
for (int i = 1; i <= k; i++) {
if (abs(b[i] - a[now]) > x)
continue;
else if (abs(b[i] - a[now]) + abs(b[i] - p) <= x)
now++;
}
if (now > n)
return true;
else
return false;
}
int main() {
int i;
scanf("%d%d%d", &n, &k, &p);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= k; i++) scanf("%d", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long l = 0, r = 2e9 + 10;
int ans = 0;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1010];
long long b[2010];
int main() {
long long n, m, k;
scanf("%lld %lld %lld", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
for (int i = 0; i < m; i++) scanf("%lld", &b[i]);
sort(a, a + n);
sort(b, b + m);
long long dap = 999999999999999;
for (int i = 0; i < m; i++) {
int update = 0;
long long gap = 0;
for (int y = 0; y < n; y++) {
if (i + n - 1 > m) {
update = 1;
break;
}
gap = max(gap, abs(a[y] - b[i + y]) + abs(k - b[i + y]));
}
if (!update) {
dap = min(dap, gap);
}
}
printf("%lld", dap);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, p;
int a[2011], b[2011];
int x;
long long f[2011][2011];
long long Abs(long long x) { return x < 0 ? -x : x; }
int main() {
scanf("%d%d%d", &n, &K, &p);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= K; i++) scanf("%d", &b[i]);
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + K);
for (int j = 1; j <= K; j++) f[1][j] = abs(a[1] - b[j]) + abs(b[j] - p);
for (int i = 2; i <= n; i++) {
long long ans = f[i - 1][i - 1];
for (int j = i; j <= K; j++) {
f[i][j] = max(ans, Abs(a[i] - b[j]) + Abs(b[j] - p));
ans = min(ans, f[i - 1][j]);
}
}
long long ans = f[n][n];
for (int i = n + 1; i <= K; i++) ans = min(ans, f[n][i]);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> A, B;
int P;
bool f(long long MAX) {
int n = A.size(), m = B.size();
int pos = 0;
for (int a : A) {
if (abs(a - P) > MAX) return false;
int r = (MAX + a + P) / 2, l = (a + P - MAX + 1) / 2;
while (pos < m && B[pos] < l) pos++;
if (pos == m || B[pos] > r) return false;
pos++;
}
return true;
}
int search(long long begin, long long end) {
while (begin < end) {
long long mid = (begin + end) / 2;
if (f(mid))
end = mid;
else
begin = mid + 1;
}
return end;
}
bool solve(int testNumber) {
int n, k;
if (scanf("%d %d %d", &n, &k, &P) == EOF) return false;
A.resize(n);
for (int &x : A) scanf("%d", &x);
sort(A.begin(), A.end());
B.resize(k);
for (int &x : B) scanf("%d", &x);
sort(B.begin(), B.end());
int ans = search(0, INT_MAX);
printf("%d\n", ans);
return true;
}
void init() {}
int main() {
init();
for (int i = 1; solve(i); i++)
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1ll << 60);
int n, k, p;
int a[2005], b[2005];
long long dp[2005][2005];
long long rec(int pos, int key) {
if (pos == n) {
return 0;
}
if (key == k) return inf;
long long &ret = dp[pos][key];
if (ret != -1) return ret;
long long sum = abs(a[pos] - b[key]) + abs(b[key] - p);
ret = max(sum, rec(pos + 1, key + 1));
ret = min(ret, rec(pos, key + 1));
return ret;
}
int main() {
cin >> n >> k >> p;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < k; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
memset(dp, -1, sizeof dp);
cout << rec(0, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k, p, i, j, max = 0;
cin >> n >> k >> p;
long long a[n + 1];
long long b[k + 1];
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= k; i++) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long x;
long long ans = INT_MAX;
for (i = 1; i <= k - n + 1; i++) {
max = 0;
for (long long l = 1; l <= n; l++) {
x = abs(b[i + l - 1] - p) + abs(a[l] - b[i + l - 1]);
if (x > max) max = x;
}
if (max < ans) ans = max;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, j = 0, k, l, flag = 0, n, m, x, y, a[1005], b[2005],
dp[10005][2005];
long long f(int pos, int key) {
if (pos == n) return 0;
if (key == k) return 10000000000000000;
if (dp[pos][key] != -1) return dp[pos][key];
long long t = abs(a[pos] - b[key]);
long long y = abs(b[key] - x);
return dp[pos][key] = min(max(t + y, f(pos + 1, key + 1)), f(pos, key + 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> x;
for (i = 0; i < n; i++) cin >> a[i];
for (j = 0; j < k; j++) cin >> b[j];
sort(a, a + n);
sort(b, b + k);
for (i = 0; i <= n; i++)
for (j = 0; j <= k; j++) dp[i][j] = -1;
cout << f(0, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p;
int t[2007], z[2007], res = 2000000007;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> p;
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = 0; i < k; i++) cin >> z[i];
sort(t, t + n);
sort(z, z + k);
for (int i = 0; i <= k - n; i++) {
int akt = 0;
for (int j = 0; j < n; j++) {
if ((z[i + j] > t[j] && z[i + j] < p) ||
(z[i + j] < t[j] && z[i + j] > p))
akt = max(akt, abs(t[j] - p));
else {
if ((t[j] > p && t[j] < z[i + j]) || (t[j] < p && t[j] > z[i + j]))
akt = max(akt, abs(t[j] - z[i + j]) + abs(z[i + j] - p));
else
akt = max(akt, abs(t[j] - z[i + j]) + abs(p - z[i + j]));
}
}
res = min(res, akt);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p, as[1005], bs[2005], ans = 2147483647;
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 0; i < n; i++) scanf("%d", &as[i]);
for (int i = 0; i < k; i++) scanf("%d", &bs[i]);
sort(as, as + n);
sort(bs, bs + k);
for (int i = 0; i <= k - n; i++) {
int temp = 0;
for (int j = 0; j < n; j++)
temp = max(temp, abs(as[j] - bs[i + j]) + abs(p - bs[i + j]));
ans = min(temp, ans);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p, ans;
int a[2050], b[2050];
int f[2050][2050];
inline int read() {
int s = 0, w = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') w = -1;
for (; isdigit(c); c = getchar()) s = (s << 1) + (s << 3) + (c ^ 48);
return s * w;
}
int main() {
n = read(), k = read(), p = read();
for (register int i = 1; i <= n; i++) a[i] = read();
sort(a + 1, a + n + 1);
for (register int i = 1; i <= k; i++) b[i] = read();
sort(b + 1, b + k + 1);
for (register int i = 1; i <= n; i++) {
f[i][i - 1] = 2e9;
for (register int j = i; j <= k - (n - i); j++)
f[i][j] = min(f[i][j - 1],
max(f[i - 1][j - 1], abs(a[i] - b[j]) + abs(b[j] - p)));
}
printf("%d", f[n][k]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, p;
vector<long long> pe;
vector<long long> ke;
int main() {
cin >> n >> k >> p;
long long a;
long long mdist = -1;
for (int i = 0; i < n; i++) {
cin >> a;
pe.push_back(a);
mdist = max(mdist, abs(p - a));
}
for (int i = 0; i < k; i++) {
cin >> a;
ke.push_back(a);
}
sort(pe.begin(), pe.end());
sort(ke.begin(), ke.end());
long long lo = mdist, hi = 2e9, mid, found = -1;
while (lo <= hi) {
mid = (lo + hi) / 2;
int i = 0, j = 0;
long long r, l, dist;
long long of;
while (i < k && j < n) {
if (abs(ke[i] - pe[j]) + abs(ke[i] - p) <= mid) {
j++;
i++;
} else
i++;
}
if (j == n) {
found = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
cout << found << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1003][2003];
int main() {
int i, j, k, l, n, m, a[2003], b[2003], p;
for (i = 0; i < 1003; i++)
for (j = 0; j < 2003; j++) dp[i][j] = 2e9;
cin >> n >> k >> p;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < k; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
for (i = 0; i < k; i++)
if (i)
dp[0][i] = min(dp[0][i - 1], abs(a[0] - b[i]) + abs(b[i] - p));
else
dp[0][i] = abs(a[0] - b[i]) + abs(b[i] - p);
for (i = 1; i < n; i++)
for (j = i; j < k; j++)
dp[i][j] = min(max(abs(a[i] - b[j]) + abs(b[j] - p), dp[i - 1][j - 1]),
dp[i][j - 1]);
cout << dp[n - 1][k - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p;
int a[2222];
int b[2222];
int main() {
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= k; i++) {
cin >> b[i];
}
sort(b + 1, b + k + 1);
int ans = 2e9;
for (int i = 0; i <= k; i++) {
if (i + n > k) break;
int mx = 0;
for (int j = 1; j <= n; j++) {
int tmp = abs(a[j] - b[i + j]) + abs(b[i + j] - p);
mx = max(tmp, mx);
}
ans = min(mx, ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p, a[1005], b[2005], dp[1005][1005] = {0};
int main() {
scanf("%d %d %d", &n, &k, &p);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= k; i++) scanf("%d", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= k; j++) {
if (i == j) {
dp[i][j] = max(dp[i - 1][j - 1], abs(p - b[j]) + abs(a[i] - b[j]));
continue;
}
dp[i][j] = min(dp[i][j - 1],
max(dp[i - 1][j - 1], abs(p - b[j]) + abs(a[i] - b[j])));
}
}
int output = INT_MAX;
for (int i = n; i <= k; i++) {
output = min(output, dp[n][i]);
}
printf("%d\n", output);
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int qq = 2000 + 10;
long long pl[qq], kl[qq];
long long n, k, p;
pair<long long, long long> node[qq];
bool Check(long long x) {
for (int i = 0; i < n; ++i) {
if (x < abs(p - pl[i])) return false;
long long dis = (x - abs(p - pl[i])) / 2;
long long l = p, r = pl[i];
if (l > r) swap(l, r);
l -= dis;
r += dis;
node[i] = make_pair(l, r);
}
sort(node, node + n);
int cur = 0;
for (int i = 0; i < n; ++i) {
while (cur < k && kl[cur] < node[i].first) cur++;
if (cur < k && kl[cur] <= node[i].second)
cur++;
else
return false;
}
return true;
}
int main() {
scanf("%lld%lld%lld", &n, &k, &p);
for (int i = 0; i < n; ++i) {
scanf("%lld", pl + i);
}
sort(pl, pl + n);
for (int i = 0; i < k; ++i) {
scanf("%lld", kl + i);
}
sort(kl, kl + k);
long long l = 0, r = 1e18, mid;
long long ans;
while (l <= r) {
mid = (l + r) / 2;
if (Check(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &first) {
char ch;
for (ch = getchar(); (ch < '0' || ch > '9') && ch != '-';) ch = getchar();
first = 0;
int t = 1;
if (ch == '-') {
ch = getchar();
t = -1;
}
for (; ch >= '0' && ch <= '9'; ch = getchar()) first = first * 10 + ch - '0';
first *= t;
}
const int inf = 2000000001;
int dp[1010][2010], a[2010], b[2010];
int main() {
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
for (int i = 1; i <= n; i++) {
dp[i][0] = inf;
for (int j = 1; j <= m; j++)
dp[i][j] = min(dp[i][j - 1],
max(dp[i - 1][j - 1], abs(a[i] - b[j]) + abs(b[j] - p)));
}
printf("%d\n", dp[n][m]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> num, position;
long long p;
int check(long long x) {
int index = 0;
for (int i = 0; i < num.size(); i++) {
if (abs(num[i] - p) > x) return 0;
int flag = 0;
for (int j = index; j < position.size(); j++) {
if (abs(num[i] - position[j]) + abs(position[j] - p) <= x) {
flag = 1;
index = j + 1;
break;
}
}
if (!flag) return 0;
}
return 1;
}
int main() {
int n, k;
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cin >> n >> k >> p;
long long t;
for (int i = 0; i < n; i++) {
cin >> t;
num.push_back(t);
}
sort(num.begin(), num.end());
for (int i = 0; i < k; i++) {
cin >> t;
position.push_back(t);
}
sort(position.begin(), position.end());
long long r = max(max(position[k - 1], num[n - 1]), p) * 2;
long long l = 0;
while (r - l > 3) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid;
}
long long ans;
for (long long i = l; i <= r; i++) {
if (check(i)) {
ans = i;
break;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, p;
long long arr[1002];
long long keys[2002];
bool check(long long time) {
long long j = 0;
long long i = 0;
while (i < n) {
if (j >= k) return false;
while (j < k && abs(arr[i] - keys[j]) + abs(keys[j] - p) > time) j++;
if (j >= k) return false;
i++;
j++;
}
return true;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> p;
for (long long i = 0; i < n; i++) cin >> arr[i];
for (long long i = 0; i < k; i++) cin >> keys[i];
sort(arr, arr + n);
sort(keys, keys + k);
long long low = 0;
long long high = 2e9;
while (low < high) {
long long mid = (low + high) / 2;
if (!check(mid))
low = mid + 1;
else
high = mid;
}
cout << low;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
t = 1;
while (t--) {
int n, k, p;
cin >> n >> k >> p;
int people[n];
for (int i = 0; i < n; i++) {
cin >> people[i];
}
sort(people, people + n);
int key[k];
for (int i = 0; i < k; i++) {
cin >> key[i];
}
sort(key, key + k);
int dp[n][k];
int ans = INT_MAX;
for (int i = 0; i < k; i++) {
dp[0][i] = abs(people[0] - key[i]) + abs(key[i] - p);
}
for (int i = 1; i < n; i++) {
for (int j = i; j < k; j++) {
dp[i][j] = INT_MAX;
for (int z = i - 1; z < j; z++) {
dp[i][j] = min(dp[i][j], max(dp[i - 1][z], abs(people[i] - key[j]) +
abs(key[j] - p)));
}
}
}
for (int i = n - 1; i < k; i++) {
ans = min(ans, dp[n - 1][i]);
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2005][2005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long n, k, p;
cin >> n >> k >> p;
for (long long i = 0; i < k + 1; i++) dp[0][i] = 0;
long long a[n], b[k];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < k; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
for (long long i = 1; i < n + 1; i++)
for (long long j = i; j < k + 1; j++) {
if (j > i)
dp[i][j] =
min(dp[i][j - 1], max(dp[i - 1][j - 1], abs(a[i - 1] - b[j - 1]) +
abs(p - b[j - 1])));
else
dp[i][j] = max(dp[i - 1][j - 1],
abs(a[i - 1] - b[j - 1]) + abs(p - b[j - 1]));
}
cout << dp[n][k];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 23456;
int n, k, p;
int a[N], b[N];
int main() {
cin >> n >> k >> p;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < k; ++i) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
int ans = INT_MAX;
for (int l = 0, r = n - 1; r < k; ++l, ++r) {
int cnt = 0;
for (int i = 0, j = l; i < n; ++i, ++j) {
cnt = max(cnt, abs(a[i] - b[j]) + abs(b[j] - p));
}
ans = min(ans, cnt);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1000 * 1000 * 1000 * 2 + 7;
int main() {
long long n, k, p;
cin >> n >> k >> p;
vector<long long> a(n), b(k);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < k; i++) {
cin >> b[i];
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long ans = MAX;
for (int l = 0; l < k - n + 1; l++) {
long long cur = -1;
for (int j = 0; j < n; j++) {
long long t = b[l + j];
if (a[j] < p) {
if (a[j] <= t && t <= p) {
if (cur == -1 || cur < p - a[j]) {
cur = abs(p - a[j]);
}
} else if (a[j] > t) {
if (cur == -1 || cur < abs(p - a[j]) + 2 * (a[j] - t)) {
cur = abs(p - a[j]) + 2 * (a[j] - t);
}
} else if (t > p) {
if (cur == -1 || cur < abs(p - a[j]) + 2 * (t - p)) {
cur = abs(p - a[j]) + 2 * (t - p);
}
}
} else {
if (p <= t && t <= a[j]) {
if (cur == -1 || cur < a[j] - p) {
cur = a[j] - p;
}
} else if (t < p) {
if (cur == -1 || cur < a[j] - p + 2 * (p - t)) {
cur = a[j] - p + 2 * (p - t);
}
} else if (t > a[j]) {
if (cur == -1 || cur < a[j] - p + 2 * (t - a[j])) {
cur = a[j] - p + 2 * (t - a[j]);
}
}
}
}
if (cur < ans) {
ans = cur;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9;
const long long OO = (long long)2e18;
const double EPS = (double)1e-9;
const double PI = (double)acos(-1.0);
const long long MOD = (long long)1e9 + 7;
int irand(int lo, int hi) {
return (((double)rand()) / (RAND_MAX + 1.0)) * (hi - lo + 1) + lo;
}
string toString(long long x) {
stringstream ss;
ss << x;
return ss.str();
}
long long toNumber(string S) {
long long ret;
sscanf(S.c_str(), "%lld", &ret);
return ret;
}
void syncOff() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
long long org[1050], key[2050];
int main() {
syncOff();
int norg, nkey;
long long office, ans = OO;
cin >> norg >> nkey >> office;
for (int i = 0; i < norg; i++) {
cin >> org[i];
}
sort(org, org + norg);
for (int i = 0; i < nkey; i++) {
cin >> key[i];
}
sort(key, key + nkey);
for (int i = 0; i <= nkey - norg; i += 1) {
long long tmp = 0;
for (int j = 0; j < norg; j++) {
tmp = max(tmp, abs(org[j] - key[i + j]) + abs(key[i + j] - office));
}
ans = min(tmp, ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
const long long INF = 1e17;
int a[N], b[N];
long long dp[N][N];
int main() {
int n, m, p;
cin >> n >> m >> p;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) cin >> b[i];
sort(a + 1, a + n + 1), sort(b + 1, b + m + 1);
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= m; ++j) {
dp[i][j] =
max(dp[i - 1][j - 1], (long long)(abs(a[i] - b[j])) + abs(b[j] - p));
if (j - 1 >= i) dp[i][j] = min(dp[i][j], dp[i][j - 1]);
}
}
long long ans = INF;
for (int j = n; j <= m; ++j) ans = min(ans, dp[n][j]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, p;
cin >> n >> k >> p;
long long people[5000];
int keys[5000];
for (int i = 0; i < n; i++) cin >> people[i];
sort(people, people + n);
for (int i = 0; i < k; i++) cin >> keys[i];
sort(keys, keys + k);
long long ans = 100000000000000;
for (int i = 0; i <= k - n; i++) {
long long a = 0;
for (int j = 0; j < n; j++)
a = max(a, abs(people[j] - keys[i + j]) + abs(keys[i + j] - p));
ans = min(ans, a);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e6 + 10, MOD = 1e9 + 7;
long long arr[M], b[M];
long long dp[2002][1001];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
long long pos;
cin >> n >> k >> pos;
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
for (int i = 0; i < k; i++) cin >> b[i];
sort(b, b + k);
for (int i = 0; i <= k; i++)
for (int j = 0; j <= n; j++) dp[i][j] = 1e17;
dp[0][0] = 0;
for (int i = 0; i <= k; i++)
for (int j = 0; j <= n; j++) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
if (j < n) {
dp[i + 1][j + 1] =
min(dp[i + 1][j + 1],
max(dp[i][j], abs(arr[j] - b[i]) + abs(b[i] - pos)));
}
}
cout << dp[k][n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve(int n) {
int k, p;
cin >> k >> p;
vector<int> a(n), b(k);
for (int i = 0; i < (int)(n); ++i) cin >> a[i];
for (int i = 0; i < (int)(k); ++i) cin >> b[i];
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
const int inf = (int)2e9 + 10;
int ans = inf;
for (int i = 0; i < (int)(k - n + 1); ++i) {
int cur = 0;
for (int j = 0; j < (int)(n); ++j)
cur = max(cur, abs(a[j] - b[i + j]) + abs(b[i + j] - p));
ans = min(ans, cur);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
while (cin >> n) solve(n);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1010], b[2010];
int main() {
int n, m, p;
scanf("%d%d%d", &n, &m, &p);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
}
sort(a, a + n);
sort(b, b + m);
long long ans = 0x7f7f7f7f7f7f7f;
for (int i = 0; i + n - 1 < m; i++) {
long long s = 0;
for (int j = 0; j < n; j++) {
s = max(s, 1ll * abs(b[i + j] - p) + 1ll * abs(a[j] - b[i + j]));
}
ans = min(ans, s);
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 7, INF = 1e18 + 7, mod = 1e9 + 7;
long long a[maxn], b[maxn], k, n, ans = INF, pos, p;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> p;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= k; i++) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
for (long long i = 0; i <= k - n; i++) {
long long cnt = 0;
for (long long j = 1; j <= n; j++) {
cnt = max(abs(a[j] - b[i + j]) + abs(b[i + j] - p), cnt);
}
ans = min(ans, cnt);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
int a[maxn], b[maxn];
int n, k, p;
long long ABS(long long x) { return x >= 0 ? x : -x; }
long long work(int l, int r) {
long long ans = 0;
for (int i = l; i <= r; ++i) {
ans = max(ans, ABS(b[i] - p) + ABS(b[i] - a[i - l + 1]));
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= k; ++i) scanf("%d", b + i);
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long ans = 1ll << 60;
for (int i = 1; i + n - 1 <= k; ++i) {
ans = min(work(i, i + n - 1), ans);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, p, v[50100], ans = 1e15, minn;
long long b[200100], bb[200100];
long long check(long long dis) {
memset(v, 0, sizeof(v));
for (int i = 1, jj = 1; i <= n; i++) {
if (abs(bb[jj] - p) + abs(b[i] - bb[jj]) <= dis && jj <= m) {
v[i] = 1;
jj++;
continue;
}
while (jj <= m - 1) {
jj++;
if (abs(bb[jj] - p) + abs(b[i] - bb[jj]) <= dis) {
v[i] = 1;
jj++;
break;
}
}
}
for (int i = 1; i <= n; i++)
if (!v[i]) return 0;
return 1;
}
int main() {
cin >> n >> m >> p;
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= m; i++) cin >> bb[i];
sort(bb + 1, bb + m + 1);
sort(b + 1, b + n + 1);
long long l = 0, r = 2e9 + 5000;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, p, a[1010] = {}, b[2010] = {};
cin >> n >> k >> p;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < k; i++) {
cin >> b[i];
}
sort(a, a + n);
sort(b, b + k);
int minn = 2084199027;
for (int x = k - n; x >= 0; x--) {
int maxn = 0;
for (int i = x, j = 0; j < n; i++, j++) {
int res = abs(a[j] - b[i]) + abs(b[i] - p);
maxn = max(res, maxn);
}
minn = min(maxn, minn);
}
cout << minn << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
long long dp[N][N], a[N], b[N];
int main() {
int n, k;
long long p;
scanf("%d%d%I64d", &n, &k, &p);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= k; i++) scanf("%I64d", &b[i]);
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + k);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++) dp[i][j] = INFLL;
for (int i = 0; i <= k; i++) dp[0][i] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
dp[i][j] = min(dp[i][j - 1],
max(dp[i - 1][j - 1], abs(a[i] - b[j]) + abs(b[j] - p)));
}
}
printf("%I64d\n", dp[n][k]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long solve(int i, int j, vector<long long>& people,
vector<long long>& keys, vector<vector<long long>>& dp,
long long pos) {
if (i == people.size()) return 0;
if (j == keys.size()) return 1e17;
if (dp[i][j] != -1) return dp[i][j];
long long op1 = solve(i + 1, j + 1, people, keys, dp, pos);
op1 = max(op1, (abs(keys[j] - people[i]) + abs(pos - keys[j])));
long long op2 = solve(i, j + 1, people, keys, dp, pos);
dp[i][j] = min(op1, op2);
return dp[i][j];
}
int main() {
long long n, k, p;
cin >> n >> k >> p;
vector<long long> people(n);
vector<long long> keys(k);
for (int i = 0; i < n; i++) cin >> people[i];
for (int i = 0; i < k; i++) cin >> keys[i];
sort(keys.begin(), keys.end());
sort(people.begin(), people.end());
vector<vector<long long>> dp(n + 1, vector<long long>(k + 1, -1));
long long ans = solve(0, 0, people, keys, dp, p);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long p, a[1005], b[2005];
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin >> n >> k >> p;
for (int i = 0; i < (n); i++) cin >> a[i];
for (int i = 0; i < (k); i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
long long mi = 1e18;
for (int i = 0; i + n - 1 < k; i++) {
long long ret = 0;
for (int j = 0; j < (n); j++)
ret = max(ret, abs(a[j] - b[i + j]) + abs(p - b[i + j]));
mi = min(mi, ret);
}
cout << mi << endl;
return 0;
}
|
#include <bits/stdc++.h>
template <class t>
void maxi(t &x, t y) {
if (x < y) x = y;
}
template <class t>
void mini(t &x, t y) {
if (x > y) x = y;
}
using namespace std;
int n, k;
long long a[3005], b[3005], dp[3005][3005], p;
long long solve(int i, int j) {
if (i == n) return 0;
if (j == k) return 1e15;
long long &ans = dp[i][j];
if (ans != -1) return ans;
ans = max(abs(a[i] - b[j]) + abs(b[j] - p), solve(i + 1, j + 1));
mini(ans, solve(i, j + 1));
return ans;
}
int main() {
ios::sync_with_stdio(0);
cout << setprecision(10) << fixed;
cin >> n >> k >> p;
for (int(i) = 0; (i) < (n); (i)++) cin >> a[i];
sort(a, a + n);
for (int(i) = 0; (i) < (k); (i)++) cin >> b[i];
sort(b, b + k);
for (int(i) = 0; (i) < (3005); (i)++)
for (int(j) = 0; (j) < (3005); (j)++) dp[i][j] = -1;
long long ans = solve(0, 0);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[1001][2001], location;
int main() {
int aa, bb;
cin >> aa >> bb >> location;
long long a[aa + 1], b[bb + 1];
a[0] = 0;
b[0] = 0;
for (int z = 1; z <= aa; z++) {
cin >> a[z];
}
for (int z = 1; z <= bb; z++) {
cin >> b[z];
}
sort(a, a + (aa + 1));
sort(b, b + (bb + 1));
for (int z = 1; z <= aa; z++) {
long long one = (max(a[z], b[z]) - min(a[z], b[z])) +
(max(location, b[z]) - min(location, b[z]));
dp[z][z] = max(dp[z - 1][z - 1], one);
for (int y = z + 1; y <= bb; y++) {
one = (max(a[z], b[y]) - min(a[z], b[y])) +
(max(location, b[y]) - min(location, b[y]));
dp[z][y] = min(dp[z][y - 1], max(dp[z - 1][y - 1], one));
}
}
cout << dp[aa][bb];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, p;
long long a[1001], b[2001];
bool ok[2001];
long long tinh(long long a, long long b) { return abs(a - b) + abs(p - b); }
signed main() {
cin >> n >> k >> p;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < k; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
long long ans = 0;
long long minn = 1e18;
for (long long i = 0; i < k - n + 1; i++) {
ans = 0;
for (long long j = 0; j < n; j++) {
ans = max(ans, tinh(a[j], b[i + j]));
}
minn = min(ans, minn);
}
cout << minn;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, p;
long long a[10002], b[10002];
cin >> n >> k >> p;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < k; i++) cin >> b[i];
long long res = INT_MAX;
sort(a, a + n);
sort(b, b + k);
for (int i = 0; i < k; i++) {
long long ans = 0;
for (int j = 0; j < n; j++) {
long long tmp = abs(a[j] - b[i + j]) + abs(b[i + j] - p);
ans = max(ans, tmp);
}
res = min(res, ans);
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
int main() {
int num_people, num_keys, office_pos;
std::cin >> num_people >> num_keys >> office_pos;
std::vector<int> people;
for (int i = 0; i < num_people; i++) {
int person;
std::cin >> person;
people.push_back(person);
}
std::vector<int> keys;
for (int i = 0; i < num_keys; i++) {
int key;
std::cin >> key;
keys.push_back(key);
}
std::sort(people.begin(), people.end());
std::sort(keys.begin(), keys.end());
int smallest_max_distance = INT32_MAX;
for (int keys_offset = 0; keys_offset <= num_keys - num_people;
keys_offset++) {
int current_max_distance = 0;
for (int i = 0; i < num_people; i++) {
int current_distance = abs(people[i] - keys[keys_offset + i]) +
abs(keys[keys_offset + i] - office_pos);
if (current_distance > current_max_distance) {
current_max_distance = current_distance;
}
}
if (current_max_distance < smallest_max_distance) {
smallest_max_distance = current_max_distance;
}
}
std::cout << smallest_max_distance << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const int oo = 0x3f3f3f3f;
const long long linf = 1ll << 60;
const double dinf = 1e60;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
return scf(w);
}
inline char mygetchar() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
template <typename T>
inline bool chkmax(T &x, const T &y) {
return y > x ? x = y, 1 : 0;
}
template <typename T>
inline bool chkmin(T &x, const T &y) {
return y < x ? x = y, 1 : 0;
}
const int maxn = 2e3 + 100;
int n, m;
long long a[maxn], b[maxn], P, ans = linf;
void calc(int i) {
long long x = 0;
for (int j = 0, _end_ = (n); j < _end_; ++j)
chkmax(x, abs(a[j + 1] - b[i + j]) + abs(b[i + j] - P));
chkmin(ans, x);
return;
}
int main() {
scf(n, m, P);
for (int i = (1), _end_ = (n); i <= _end_; ++i) scf(a[i]);
sort(a + 1, a + n + 1);
for (int i = (1), _end_ = (m); i <= _end_; ++i) scf(b[i]);
sort(b + 1, b + m + 1);
for (int i = (1), _end_ = (m - n + 1); i <= _end_; ++i) calc(i);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, p;
long long a[2000];
long long b[2001];
long long dp[1003][2004];
long long cnt = 0;
long long solve(long long index1, long long index2) {
if (index1 >= n) {
return dp[index1][index2] = 0;
}
if (index2 >= k) {
return dp[index1][index2] = LONG_LONG_MAX;
}
if (dp[index1][index2] != -1) {
return dp[index1][index2];
}
cnt++;
if (cnt > 10000000) {
cout << cnt << "\n";
exit(0);
}
long long ans = LONG_LONG_MAX;
ans = min(max(solve(index1 + 1, index2 + 1),
abs(a[index1] - b[index2]) + abs(b[index2] - p)),
solve(index1, index2 + 1));
return dp[index1][index2] = ans;
}
int main() {
scanf("%I64d %I64d %I64d", &n, &k, &p);
for (long long i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
for (long long i = 0; i < k; i++) {
scanf("%I64d", &b[i]);
}
sort(a, a + n);
sort(b, b + k);
memset(dp, 255, sizeof dp);
cout << solve(0, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n, k, p;
cin >> n >> k >> p;
int a[n], b[k];
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < k; ++i) cin >> b[i];
sort(b, b + k);
sort(a, a + n);
int minm = INT_MAX;
for (int i = 0; i <= k - n; ++i) {
int val = INT_MIN;
for (int j = 0; j < n; ++j) {
int time;
int key = b[i + j];
int person = a[j];
if (key < person) {
if (p <= key)
time = person - p;
else
time = person - key + p - key;
} else {
if (p >= key)
time = p - person;
else
time = key - person + key - p;
}
val = max(val, time);
}
minm = min(val, minm);
}
cout << minm;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p, a[2005], b[2005];
void solve() {
sort(a, a + n);
sort(b, b + k);
int ans = 2 * 0x3f3f3f3f;
for (int i = 0; i <= k - n; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
sum = max(sum, abs(a[j] - b[i + j]) + abs(p - b[i + j]));
}
ans = min(sum, ans);
}
cout << ans << endl;
}
int main() {
cin >> n >> k >> p;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < k; i++) cin >> b[i];
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans;
const int maxn = 2020;
long long people[maxn];
long long key[maxn];
long long dp[maxn][maxn];
int main() {
int p, k, h;
scanf("%d%d%d", &p, &k, &h);
for (int i = 1; i <= p; i++) scanf("%d", &people[i]);
sort(people + 1, people + 1 + p);
for (int i = 1; i <= k; i++) scanf("%d", &key[i]);
sort(key + 1, key + 1 + k);
for (int i = 1; i <= p; i++) {
dp[i][0] = 2e9 + 7;
for (int j = 1; j <= k; j++) {
dp[i][j] =
max(abs(key[j] - people[i]) + abs(key[j] - h), dp[i - 1][j - 1]);
}
for (int j = 1; j <= k; j++) {
dp[i][j] = min(dp[i][j], dp[i][j - 1]);
}
}
printf("%lld", dp[p][k]);
return 0;
}
|
#include <bits/stdc++.h>
template <typename T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline bool repr(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool repl(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T gcd(T a, T b) {
T t;
if (a < b) {
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
} else {
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
struct Cg {
inline char operator()() { return getchar(); }
};
struct Cp {
inline void operator()(char x) { putchar(x); }
};
inline bool IS(char x) { return x == 10 || x == 13 || x == ' '; }
template <typename T>
struct Fr {
T P;
inline Fr &operator,(int &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
inline operator int() {
int x;
*this, x;
return x;
}
inline Fr &operator,(long long &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
inline operator long long() {
long long x;
*this, x;
return x;
}
inline Fr &operator,(char &x) {
for (x = P(); IS(x); x = P())
;
return *this;
}
inline operator char() {
char x;
*this, x;
return x;
}
inline Fr &operator,(char *x) {
char t = P();
for (; IS(t); t = P())
;
if (~t) {
for (; !IS(t) && ~t; t = P()) *x++ = t;
}
*x++ = 0;
return *this;
}
inline Fr &operator,(double &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
inline operator double() {
double x;
*this, x;
return x;
}
inline Fr &operator,(long double &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
inline operator long double() {
long double x;
*this, x;
return x;
}
inline Fr &operator,(unsigned int &x) {
x = 0;
char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
inline operator unsigned int() {
unsigned int x;
*this, x;
return x;
}
inline Fr &operator,(unsigned long long &x) {
x = 0;
char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
inline operator unsigned long long() {
unsigned long long x;
*this, x;
return x;
}
};
Fr<Cg> in;
template <typename T>
struct Fw {
T P;
inline Fw &operator,(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned int x) {
if (x) {
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(unsigned int x) {
if (x) {
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned long long x) {
if (x) {
char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(unsigned long long x) {
if (x) {
char s[20], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(char x) {
P(x);
return *this;
}
inline Fw &operator()(char x) {
P(x);
return *this;
}
inline Fw &operator,(const char *x) {
while (*x) P(*x++);
return *this;
}
inline Fw &operator()(const char *x) {
while (*x) P(*x++);
return *this;
}
inline Fw &operator()(double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
inline Fw &operator()(long double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
};
Fw<Cp> out;
int n, m, x, a[1003], b[2003];
long long f[1003][2003];
int main() {
in, n, m, x;
for (int i = 1, iend = n; i <= iend; i++) in, a[i];
for (int i = 1, iend = m; i <= iend; i++) in, b[i];
std::sort(a + 1, a + n + 1);
std::sort(b + 1, b + m + 1);
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 0, iend = n; i <= iend; i++)
for (int j = 0, jend = m; j <= jend; j++) {
repl(f[i][j + 1], f[i][j]);
repl(f[i + 1][j + 1], max(f[i][j], (long long)abs(a[i + 1] - b[j + 1]) +
abs(b[j + 1] - x)));
}
out, f[n][m], '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
const int K = 2e3 + 5;
const int inf = 2e9 + 5;
int n, k, p;
int a[N], b[K];
int dp[N][K];
int main() {
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= k; i++) scanf("%d", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++) dp[i][j] = inf;
for (int i = 0; i <= k; i++) dp[0][i] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++) {
dp[i][j] = min(dp[i][j - 1],
max(dp[i - 1][j - 1], (abs(a[i] - b[j]) + abs(b[j] - p))));
}
cout << dp[n][k] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll inf = 1000000000000000000;
void solveCP311() {
ll n, k, p;
cin >> n >> k >> p;
vector<ll> vec(n + 1), key(k + 1);
for (ll i = 1; i <= n; i++) cin >> vec[i];
for (ll j = 1; j <= k; j++) cin >> key[j];
ll dp[n + 1][k + 1];
memset(dp, 0, sizeof(dp));
sort(vec.begin(), vec.end());
sort(key.begin(), key.end());
for (ll i = 1; i <= n; i++) {
for (ll j = 1; j <= k; j++) {
dp[i][j] = max(dp[i - 1][j - 1], abs(vec[i] - key[j]) + abs(key[j] - p));
}
dp[i][0] = inf;
for (ll j = 1; j <= k; j++) {
dp[i][j] = min(dp[i][j], dp[i][j - 1]);
}
}
cout << dp[n][k];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
while (t--) {
solveCP311();
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma 03
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 3005;
long long a[N], b[N], T;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, k, ans = 1e18;
cin >> n >> k >> T;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= k; i++) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
for (long long i = 1; i <= k - n + 1; i++) {
long long cur = 0;
for (long long j = 1; j <= n; j++) {
cur = max(cur, abs(a[j] - b[i + j - 1]) + abs(T - b[i + j - 1]));
}
ans = min(ans, cur);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 101000;
int a[N], b[N];
int n, k, p;
int ans;
bool judge(long long x) {
int j = 1;
int i = 1;
for (i = 1; i <= n; i++) {
if (abs(a[i] - b[j]) + abs(p - b[j]) <= x) {
j++;
continue;
} else
j++, i--;
if (j > k) return 0;
}
return 1;
}
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i(1); i <= (n); ++i) scanf("%d", a + i);
for (int i(1); i <= (k); ++i) scanf("%d", b + i);
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long L = 0, R = 2e9 + 10;
while (L < R) {
long long mid = (L + R) >> 1;
if (judge(mid))
R = mid;
else
L = mid + 1;
}
printf("%lld\n", L);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 7;
long long int memo[N][N];
long long int v[2][N];
int n, m;
long long int p;
long long int cost(int i, int j) {
return abs(v[0][i] - v[1][j]) + abs(v[1][j] - p);
}
long long int pd(int i, int j) {
if (i == n) return 0;
if (j == m) return 1e15;
long long int& me = memo[i][j];
if (me != -1) return me;
me = pd(i, j + 1);
me = min(me, max(pd(i + 1, j + 1), cost(i, j)));
return me;
}
int main() {
memset(memo, -1, sizeof memo);
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> p;
for (int i = 0; i < n; i++) {
cin >> v[0][i];
}
for (int i = 0; i < m; i++) {
cin >> v[1][i];
}
sort(v[0], v[0] + n);
sort(v[1], v[1] + m);
long long int rs = pd(0, 0);
cout << rs << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
bool check(const vector<long long int> &a, const vector<long long int> &b,
long long int x) {
int n = a.size();
int k = b.size();
vector<pair<int, int> > range(n);
for (int i = (int)(0); i < (int)(n); i++) {
if (abs(a[i]) > x) {
return false;
}
long long int lo, hi;
long long int rem = (x - abs(a[i])) / 2;
if (a[i] < 0) {
lo = a[i] - rem;
hi = rem;
} else {
lo = -rem;
hi = a[i] + rem;
}
range[i] = pair<int, int>(lower_bound(b.begin(), b.end(), lo) - b.begin(),
upper_bound(b.begin(), b.end(), hi) - b.begin());
}
int pos = 0;
for (int i = (int)(0); i < (int)(n); i++) {
if (pos >= k) {
return false;
}
pair<int, int> r = range[i];
if (r.second <= pos) {
return false;
}
if (r.second - r.first <= 0) {
return false;
}
pos = max(pos, r.first) + 1;
}
return true;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
long long int p;
cin >> n >> k >> p;
vector<long long int> a(n), b(k);
for (int i = (int)(0); i < (int)(n); i++) {
cin >> a[i];
a[i] -= p;
}
for (int i = (int)(0); i < (int)(k); i++) {
cin >> b[i];
b[i] -= p;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long int lo = -1;
long long int hi = 1e15;
while (hi - lo > 1) {
long long int mid = (hi + lo) / 2;
if (check(a, b, mid)) {
hi = mid;
} else {
lo = mid;
}
}
cout << hi << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
const int N = (int)2e5 + 77;
const long long mod = (long long)1e9 + 7;
long long n, m, k, p;
long long a[1111], b[2111];
long long check(long long lim) {
long long now = 1;
for (int i = 1; i <= (int)(k); ++i)
if (abs(b[i] - a[now]) + abs(b[i] - p) <= lim) {
now++;
}
return now > n;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> p;
for (int i = 1; i <= (int)(n); ++i) cin >> a[i];
for (int i = 1; i <= (int)(k); ++i) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long l = 0, r = (long long)2e9 + 77, ans = (long long)2e9 + 77;
while (l <= r) {
long long mid = l + r >> 1;
if (check(mid))
r = mid - 1, ans = min(ans, mid);
else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2000000000;
const int MAX_N = 3000;
long long a[MAX_N];
long long b[MAX_N];
int main() {
long long n, k, p, ans;
cin >> n >> k >> p;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < k; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
ans = INF;
for (int i = 0; i + n <= k; i++) {
long long q = 0;
for (int j = 0; j < n; j++)
q = max(q, abs(b[i + j] - a[j]) + abs(p - b[i + j]));
ans = min(ans, q);
}
reverse(a, a + n);
reverse(b, b + k);
for (int i = 0; i + n <= k; i++) {
long long q = 0;
for (int j = 0; j < n; j++)
q = max(q, abs(b[i + j] - a[j]) + abs(p - b[i + j]));
ans = min(ans, q);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int SZ = 2000 + 10;
LL g_n, g_k, g_p;
LL a[SZ], b[SZ];
void prete() {}
void input() {
for (int i = 0; i < g_n; ++i) {
scanf(" %I64d", a + i);
}
for (int i = 0; i < g_k; ++i) {
scanf(" %I64d", b + i);
}
}
void solve() {
LL ans = LLONG_MAX;
sort(a, a + g_n);
sort(b, b + g_k);
for (int i = 0; i <= g_k - g_n; ++i) {
LL t = LLONG_MIN;
for (int j = 0; j < g_n; ++j) {
t = max(t, abs(a[j] - b[i + j]) + abs(b[i + j] - g_p));
}
ans = min(ans, t);
}
cout << ans << endl;
}
int main() {
prete();
while (cin >> g_n >> g_k >> g_p) {
input();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int adj[8][2] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1},
{-1, -1}, {-1, 1}, {1, 1}, {1, -1}};
const long long int LLINF = 9e18;
const int INF = 2e9;
const int MOD = 1e9 + 7;
const double EPS = 1e-10;
const double PI = acos(-1);
const int SIZE = 100005;
int N, M, T;
int A[SIZE], B[SIZE];
int main() {
scanf("%d %d %d", &N, &M, &T);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
}
for (int j = 0; j < M; j++) {
scanf("%d", &B[j]);
}
sort(A, A + N);
sort(B, B + M);
int ans = INF;
for (int i = 0; i <= M - N; i++) {
int temp = 0;
for (int j = 0; j < N; j++) {
temp = max(temp, abs(A[j] - B[i + j]) + abs(T - B[i + j]));
}
ans = min(ans, temp);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.precision(0);
int n, k, p;
cin >> n >> k >> p;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort((a).begin(), (a).end());
vector<int> b(k);
for (int i = 0; i < k; ++i) {
cin >> b[i];
}
sort((b).begin(), (b).end());
int ans = 2000010000;
for (int j = 0; j < k - n + 1; ++j) {
int cur = 0;
for (int i = 0; i < n; ++i) {
cur = max(cur, abs(p - b[i + j]) + abs(b[i + j] - a[i]));
}
ans = min(ans, cur);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 2e3 + 10;
long long dp[maxn][maxn], a[maxn], b[maxn];
int main() {
int n, k, p;
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= k; i++) cin >> b[i];
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + k);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++) dp[i][j] = INFLL;
for (int i = 0; i <= k; i++) dp[0][i] = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= k; j++) {
dp[i][j] = min(dp[i][j - 1],
max(dp[i - 1][j - 1], abs(a[i] - b[j]) + abs(b[j] - p)));
}
cout << dp[n][k] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p, a[1002], b[2002];
int dp[2][1002][2002];
int ans;
int Dist(int i, int j) { return abs(a[i] - b[j]) + abs(b[j] - p); }
void compDp() {
for (int i = 1; i <= n; ++i)
for (int j = i; j <= k; ++j) {
dp[0][i][j] = max(dp[1][i - 1][j - 1], Dist(i, j));
if (i == j)
dp[1][i][j] = dp[0][i][j];
else
dp[1][i][j] = min(dp[1][i][j - 1], dp[0][i][j]);
}
ans = dp[1][n][k];
}
int main() {
scanf("%d %d %d", &n, &k, &p);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= k; ++i) scanf("%d", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
compDp();
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p;
int a[1111], b[2222];
int main() {
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= k; i++) {
cin >> b[i];
}
int ans = 2e9;
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
for (int i = 1; i <= k - n + 1; i++) {
int cnt = 0;
for (int j = 1; j <= n; j++) {
cnt = max(cnt, abs(a[j] - b[i + j - 1]) + abs(p - b[i + j - 1]));
}
ans = min(ans, cnt);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, k, p, dp[1010][2010], ar[1010], br[2010];
int main() {
scanf("%lld%lld%lld", &n, &k, &p);
for (int i = 1; i <= n; i++) scanf("%lld", &ar[i]);
for (int i = 1; i <= k; i++) scanf("%lld", &br[i]);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= k; j++) dp[i][j] = 1e12;
sort(ar + 1, ar + n + 1);
sort(br + 1, br + k + 1);
for (int i = 0; i <= k; i++) dp[0][i] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++)
dp[i][j] = min(dp[i][j - 1], max(dp[i - 1][j - 1],
abs(br[j] - ar[i]) + abs(p - br[j])));
printf("%lld\n", dp[n][k]);
}
|
#include <bits/stdc++.h>
using namespace std;
int A[1100], B[2100], n, K, p;
int check(long long lim) {
int now = 1;
for (int i = 1; i <= K; i++)
if (abs(B[i] - A[now]) + abs(B[i] - p) <= lim) {
now++;
if (now > n) return 1;
}
return 0;
}
int main() {
scanf("%d%d%d", &n, &K, &p);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
for (int i = 1; i <= K; i++) scanf("%d", &B[i]);
sort(A + 1, A + n + 1);
sort(B + 1, B + K + 1);
long long l = 0, r = 2e9 + 10, ans = 0;
while (l < r) {
long long mid = l + r >> 1;
if (check(mid))
r = mid, ans = mid;
else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 2000 + 5;
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, k, p;
int a[N], b[N];
bool pd(int now) {
int x = 1;
for (register int i = 1; i <= n; ++i) {
while (abs(a[i] - b[x]) + abs(b[x] - p) > now && x <= k) x += 1;
if (x == k + 1) return 0;
x += 1;
}
return 1;
}
int main() {
n = read();
k = read();
p = read();
for (register int i = 1; i <= n; ++i) a[i] = read();
sort(a + 1, a + n + 1);
for (register int i = 1; i <= k; ++i) b[i] = read();
sort(b + 1, b + k + 1);
int l = 0, r = 2e9, ans = 2e9;
while (l <= r) {
int mid = (int)(1LL * l + 1LL * r >> 1);
if (pd(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1005];
long long b[2005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, k, p;
cin >> n >> k >> p;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= k; i++) {
cin >> b[i];
}
sort(a + 1, a + n + 1);
sort(b + 1, b + 1 + k);
long long ans = 100000000000000;
for (long long i = 1; i <= k - n + 1; i++) {
long long s = 0;
for (long long j = 1; j <= n; j++) {
s = max(abs(a[j] - b[i + j - 1]) + abs(p - b[i + j - 1]), s);
}
ans = min(ans, s);
}
cout << ans;
}
|
#include <bits/stdc++.h>
constexpr int MAX = 2000 + 1;
int n, k, p;
int A[MAX];
int B[MAX];
int main(void) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cin >> n >> k >> p;
for (int i = 1; i <= n; ++i) std::cin >> A[i];
for (int i = 1; i <= k; ++i) std::cin >> B[i];
std::sort(A + 1, A + n + 1);
std::sort(B + 1, B + k + 1);
int max = k - n;
int ans = std::numeric_limits<int>::max();
for (int i = 0; i <= max; ++i) {
int time = 0;
for (int j = 1; j <= n; ++j) {
time = std::max(time, std::abs(A[j] - B[i + j]) + std::abs(B[i + j] - p));
}
ans = std::min(ans, time);
}
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, M, P;
long long a[1005];
long long b[2005];
long long DP[1005][2005] = {0};
bool have[1005][2005] = {0};
long long F(long long x, long long y) {
if (x == N) return 0;
if (y == M) return 1e18;
if (have[x][y]) return DP[x][y];
have[x][y] = 1;
DP[x][y] =
min(max(F(x + 1, y + 1), abs(a[x] - b[y]) + abs(b[y] - P)), F(x, y + 1));
return DP[x][y];
}
int main() {
long long i;
scanf("%lld %lld %lld", &N, &M, &P);
for (i = 0; i < N; i++) scanf("%lld", &a[i]);
for (i = 0; i < M; i++) scanf("%lld", &b[i]);
sort(a, a + N);
sort(b, b + M);
printf("%lld\n", F(0, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void Out(long long a) {
if (a < 0) putchar('-'), a = -a;
if (a >= 10) Out(a / 10);
putchar(a % 10 + '0');
}
const int N = 1005;
long long a[N], b[N << 1];
long long dp[N][N << 1];
int n, m, p;
long long cacu(long long a, long long b) {
if (b <= a && a <= p)
return abs(p - a) + abs(a - b) * 2;
else if (a <= b && b <= p)
return abs(p - a);
else
return abs(a - b) + abs(p - b);
}
int main() {
n = read();
m = read();
p = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= m; i++) b[i] = read();
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + m);
memset(dp, 0x3f, sizeof(dp));
for (int i = 0; i <= m; i++) dp[0][i] = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= m; j++) {
dp[i][j] = min(dp[i][j - 1],
max(dp[i - 1][j - 1], abs(a[i] - b[j]) + abs(b[j] - p)));
}
Out(dp[n][m]);
puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
int n, k, p;
int a[maxn], b[maxn << 1];
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= k; i++) scanf("%d", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
int ans = 2e9;
for (int i = 1; i <= k - n + 1; i++) {
int j = i + n - 1, res = 0;
for (int id = i; id <= j; id++) {
res = max(res, abs(a[id - i + 1] - b[id]) + abs(b[id] - p));
}
ans = min(ans, res);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, pos, a[2010], b[2010], dp[2010][2010];
inline long long read() {
long long s = 0, w = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') w = -1;
for (; isdigit(c); c = getchar()) s = (s << 1) + (s << 3) + (c ^ 48);
return s * w;
}
long long calc(long long i, long long j) {
return abs(a[i] - b[j]) + abs(b[j] - pos);
}
signed main() {
n = read(), m = read(), pos = read();
for (long long i = 1; i <= n; ++i) a[i] = read();
for (long long i = 1; i <= m; ++i) b[i] = read();
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + m);
for (long long i = 1; i <= n; ++i) {
dp[i][i - 1] = 1e12;
for (long long j = i; j <= m; ++j)
dp[i][j] = min(dp[i][j - 1], max(dp[i - 1][j - 1], calc(i, j)));
}
printf("%d\n", dp[n][m]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 5;
const long long INF = 2 * 1e9;
long long a[maxn], b[maxn << 1];
int main() {
int n, k;
long long p;
cin >> n >> k >> p;
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
for (int i = 0; i < k; i++) scanf("%I64d", &b[i]);
sort(a, a + n);
sort(b, b + k);
long long mint = INF;
for (int i = 0; i <= k - n; i++) {
long long maxt = 0;
for (int j = 0; j < n; j++) {
long long tmp = 0;
if ((a[j] <= b[i + j] && b[i + j] <= p) ||
(p <= b[i + j] && b[i + j] <= a[j])) {
tmp = abs(p - a[j]);
} else if ((b[i + j] <= a[j] && a[j] <= p) ||
(p <= a[j] && a[j] <= b[i + j]))
tmp = abs(p - b[i + j] - b[i + j] + a[j]);
else if ((a[j] <= p && p <= b[i + j]) || (b[i + j] <= p && p <= a[j]))
tmp = abs(b[i + j] - a[j] - p + b[i + j]);
maxt = max(maxt, tmp);
}
mint = min(mint, maxt);
}
cout << mint << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1001];
long long b[2001];
int main() {
long long n, k, p;
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= k; i++) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long ans = (long long)2e15 + 1;
for (int i = 1; i <= k - n + 1; i++) {
long long maks = 0;
for (int j = 1; j <= n; j++) {
maks = max(abs(a[j] - b[i + j - 1]) + abs(b[i + j - 1] - p), maks);
}
ans = min(maks, ans);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, p;
struct node {
long long pos, what;
} A[3010], B[3010];
bool cmp1(node x, node y) { return x.pos < y.pos; }
bool cmp2(node x, node y) { return abs(x.pos - p) > abs(y.pos - p); }
bool check(long long mid) {
long long l = 1, r = k;
for (register long long i = 1; i <= n; i++) {
if (A[i].pos < p) {
while (abs(A[i].pos - B[l].pos) + abs(B[l].pos - p) > mid) l++;
if (l > r) return false;
l++;
} else {
while (abs(A[i].pos - B[r].pos) + abs(B[r].pos - p) > mid) r--;
if (l > r) return false;
r--;
}
}
return true;
}
signed main() {
scanf("%lld%lld%lld", &n, &k, &p);
for (register long long i = 1; i <= n; i++) {
long long pos;
scanf("%lld", &A[i].pos);
A[i].what = 1;
}
for (register long long i = 1; i <= k; i++) {
long long pos;
scanf("%lld", &B[i].pos);
B[i].what = 2;
}
sort(A + 1, A + n + 1, cmp2);
sort(B + 1, B + k + 1, cmp1);
long long l = 0, r = 3e9 + 10, mid, res;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid)) {
res = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
printf("%lld", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double pi = 3.14159265358979323846;
vector<long long> al[500005];
long long vis[500005], color[500005], I[101][101];
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long bpow(long long n, long long po) {
long long res = 1;
while (po > 0) {
if (po % 2) {
res *= n;
po--;
} else {
n *= n;
po /= 2;
}
}
return res;
}
long long binpow(long long n, long long po, long long mod) {
long long res = 1;
while (po > 0) {
if (po % 2) {
res = (res * n) % mod;
po--;
} else {
n = (n * n) % mod;
po /= 2;
}
}
return res;
}
long long swap(long long *a, long long *b) {
long long temp = *a;
*a = *b;
*b = temp;
}
long long fact(long long n) {
if ((n == 0) || (n == 1))
return 1;
else
return n * fact(n - 1);
}
long long C(long long n, long long r) {
if (r > n - r) r = n - r;
long long ans = 1;
long long i;
for (i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
ans = ans % 1000000007;
}
return ans;
}
void mmul(long long A[][101], long long B[][101], long long dim) {
long long res[dim][dim];
for (long long i = 0; i < dim; i++)
for (long long j = 0; j < dim; j++) {
res[i][j] = 0;
for (long long k = 0; k < dim; k++)
res[i][j] = (res[i][j] + A[i][k] * B[k][j]) % 1000000007;
}
for (long long i = 0; i < dim; i++)
for (long long j = 0; j < dim; j++) A[i][j] = res[i][j];
}
void mpow(long long A[][101], long long dim, long long po) {
for (long long i = 0; i < dim; i++)
for (long long j = 0; j < dim; j++) {
if (i == j)
I[i][j] = 1;
else
I[i][j] = 0;
}
while (po > 0) {
if (po % 2 == 1) {
mmul(I, A, dim);
po--;
} else {
mmul(A, A, dim);
po /= 2;
}
}
for (long long i = 0; i < dim; i++)
for (long long j = 0; j < dim; j++) A[i][j] = I[i][j];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long testcases = 1;
while (testcases--) {
long long n, k, p;
cin >> n >> k >> p;
long long a[n], b[k];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < k; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
long long ans = 10000000000;
for (long long i = 0; i + n <= k; i++) {
long long cans = 0;
for (long long j = 0; j < n; j++) {
long long ca = 0;
if (a[j] <= p) {
ca += p - a[j];
if (a[j] > b[i + j])
ca += 2 * (a[j] - b[i + j]);
else if (p < b[i + j])
ca += 2 * (b[i + j] - p);
} else {
ca += a[j] - p;
if (a[j] < b[i + j])
ca += 2 * (b[i + j] - a[j]);
else if (p > b[i + j])
ca += 2 * (p - b[i + j]);
}
cans = max(cans, ca);
}
ans = min(ans, cans);
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 2005;
int n, k, p, a[N], b[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= k; i++) cin >> b[i];
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + k);
int sol = 2000000000 + 10;
for (int i = 1; i <= k - n + 1; i++) {
int mx = -1;
for (int j = i; j <= i + n - 1; j++) {
mx = max(mx, abs(b[j] - a[j - i + 1]) + abs(b[j] - p));
}
sol = min(sol, mx);
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[2010], b[2010], c[2010];
long long int n, k, p;
long long int f(int x) {
int j;
long long int tmp = -1;
for (int i = 0; i < n; i++) {
j = i + x;
tmp = max(tmp, abs(a[i] - b[j]) + abs(b[j] - p));
}
return tmp;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> p;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < k; i++) {
cin >> b[i];
}
sort(a, a + n);
sort(b, b + k);
long long int ans = LONG_LONG_MAX;
for (int i = 0; i <= k - n; i++) {
ans = min(ans, f(i));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void smax(long long &x, long long y) { x = max(x, y); }
inline void smin(long long &x, long long y) { x = min(x, y); }
inline long long in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%I64d", &x);
return x;
}
inline void out(long long x) { printf("%d ", x); }
inline void lout(long long x) { printf("%I64d ", x); }
const long long MOD = 1e9 + 7;
const long double EPS = 1e-9;
const long long INF = 1e9 + 10;
const long long LINF = 1e18;
const long long N = 1e3 + 10;
const long long maxn = 1e4 + 10;
const long long MAXN = 1e5 + 10;
const long long MN = 1e6 + 10;
inline long long powmod(long long x, long long y) {
long long res = 1, a = x;
while (y) {
if (y & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
y >>= 1;
}
return res;
}
long long n, k, p, f[2 * N], a[N], b[2 * N], ans = LINF, t[N][2 * N];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> p;
for (long long i = 1; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= k; i++) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
for (long long i = 1; i <= k; i++) f[i] = abs(b[i] - p);
for (long long i = 1; i <= n; i++) {
t[i][i] = max(t[i - 1][i - 1], abs(a[i] - b[i]) + f[i]);
for (long long j = i + 1; j <= k; j++) {
t[i][j] = t[i][j - 1];
smin(t[i][j], max(abs(a[i] - b[j]) + f[j], t[i - 1][j - 1]));
}
}
for (long long i = n; i <= k; i++) smin(ans, t[n][i]);
cout << ans;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
const double PI = acos(-1);
using namespace std;
const long long oo = 1LL << 60;
int n, k, p;
int A[1024], B[2 << 10];
long long dp[1 << 10][2 << 10];
int main() {
scanf("%d %d %d", &n, &k, &p);
for (int i = (1); i <= (n); i++) scanf("%d", A + i);
for (int i = (1); i <= (k); i++) scanf("%d", B + i);
sort(A + 1, A + n + 1);
sort(B + 1, B + k + 1);
for (int i = (0); i <= (n); i++) dp[i][0] = oo;
for (int i = (0); i <= (k); i++) dp[0][i] = 0;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (k); j++) {
dp[i][j] = min(
dp[i][j - 1],
max(dp[i - 1][j - 1], abs(A[i] - B[j] + 0LL) + abs(B[j] - p + 0LL)));
}
cout << dp[n][k] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
vector<long long int> ar, br;
bool predicate(long long int x, long long int p) {
long long int n = ar.size(), k = br.size();
long long int firstptr = 0, secptr = 0;
while ((firstptr < n) and (secptr < k)) {
long long int tim =
llabs(ar[firstptr] - br[secptr]) + llabs(br[secptr] - p);
if (tim <= x) {
firstptr++;
secptr++;
} else {
secptr++;
}
}
if (firstptr < n) {
return false;
} else
return true;
}
void Compute(long long int n, long long int k, long long int p) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ar.resize(n);
br.resize(k);
for (long long int i = 0; i < n; i++) {
cin >> ar[i];
}
for (long long int i = 0; i < k; i++) {
cin >> br[i];
}
sort(ar.begin(), ar.end());
sort(br.begin(), br.end());
long long int lo = -1, hi = 1e14 + 1;
while ((lo + 1) < hi) {
long long int mid = (lo + hi) / 2;
if (predicate(mid, p))
hi = mid;
else
lo = mid;
}
cout << lo + 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, k, p;
cin >> n >> k >> p;
Compute(n, k, p);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const long long int inf = 1e17;
const long long int N = 1e5 + 5;
long long int n, m, office;
long long int men[N], keys[N];
long long int solve(long long int l, long long int r) {
long long int res = 0;
for (long long int i = l; i <= r; i++) {
long long int tmp = 0;
tmp += abs(keys[i] - men[i - l + 1]);
tmp += abs(office - keys[i]);
res = max(res, tmp);
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> office;
for (long long int i = 1; i <= n; i++) {
cin >> men[i];
}
for (long long int i = 1; i <= m; i++) {
cin >> keys[i];
}
sort(men + 1, men + n + 1);
sort(keys + 1, keys + m + 1);
long long int ans = inf;
for (long long int i = 1; i + n - 1 <= m; i++) {
ans = min(ans, solve(i, i + n - 1));
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 20;
int a[maxn], b[maxn], vis[maxn], DFN;
int n, k, p;
bool check(long long int val) {
++DFN;
for (int i = 1; i <= n; ++i) {
bool flag = false;
for (int j = 1; j <= k; ++j) {
if (vis[j] == DFN) continue;
if (abs(a[i] - b[j]) + abs(b[j] - p) <= val) {
vis[j] = DFN;
flag = true;
break;
}
}
if (!flag) return false;
}
return true;
}
void work() {
cin >> n >> k >> p;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= k; ++i) cin >> b[i];
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + k);
long long int be = 0, en = 1e16;
while (be <= en) {
long long int mid = (be + en) >> 1;
if (check(mid))
en = mid - 1;
else
be = mid + 1;
}
cout << be << endl;
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e16;
long long dp[1005][2005];
long long a[1005];
long long b[2006];
long long p;
int main() {
int n, i, j, k;
scanf("%d%d%lld", &n, &k, &p);
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (i = 1; i <= k; i++) scanf("%lld", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
for (j = 0; j <= k; j++) dp[0][j] = 0;
for (i = 1; i <= n; i++) {
for (j = i; j <= k; j++) {
if (i == j) {
dp[i][j] = max(dp[i - 1][j - 1], abs(a[i] - b[j]) + abs(b[j] - p));
continue;
}
dp[i][j] = min(dp[i][j - 1],
max(dp[i - 1][j - 1], abs(a[i] - b[j]) + abs(b[j] - p)));
}
}
j = n;
for (i = n; i <= k; i++) {
if (dp[n][i] < dp[n][j]) j = i;
}
printf("%lld\n", dp[n][j]);
}
|
#include <bits/stdc++.h>
using namespace std;
int res = INT_MAX, n, k, p, a[1001], b[2001];
int main() {
cin >> n >> k >> p;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int j = 0; j < k; ++j) cin >> b[j];
sort(a, a + n);
sort(b, b + k);
for (int i = 0; i <= k - n; ++i) {
int t = 0;
for (int j = 0; j < n; ++j) {
t = max(t, abs(a[j] - b[j + i]) + abs(p - b[i + j]));
}
res = min(res, t);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1E9 + 7;
const double eps = 1e-6;
template <typename T>
T abs(T val) {
return val > 0 ? val : -val;
}
inline int max2(int a, int b) { return ((a > b) ? a : b); }
inline int min2(int a, int b) { return ((a < b) ? a : b); }
inline int max3(int a, int b, int c) { return max2(a, max2(b, c)); }
inline int min3(int a, int b, int c) { return min2(a, min2(b, c)); }
long long a, b, c, A[100001], B[100001];
bool check(long long x) {
bool flag = false;
for (int s = 1; s <= b - a + 1 && !flag; s++) {
int i = 1, j = s;
while (j <= b) {
if (i > a) break;
if (abs(A[i] - B[j]) + abs(B[j] - c) <= x)
i++, j++;
else
j++;
}
if (i > a) flag = true;
}
if (flag) return flag;
for (int s = b; s >= a && !flag; s--) {
int i = 1, j = s;
while (j >= 1) {
if (i > a) break;
if (abs(A[i] - B[j]) + abs(B[j] - c) <= x)
i++, j--;
else
j--;
}
if (i > a) flag = true;
}
return flag;
}
void solve() {
sort(A + 1, A + 1 + a);
sort(B + 1, B + 1 + b);
long long l = 0, r = 4E12;
long long ans = r;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid)) {
ans = min(ans, mid);
r = mid - 1;
} else
l = mid + 1;
}
printf("%lld\n", ans);
}
int main() {
while (~scanf("%lld%lld%lld", &a, &b, &c)) {
for (int i = 1; i <= a; i++) scanf("%lld", A + i);
for (int i = 1; i <= b; i++) scanf("%lld", B + i);
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using ii = pair<int, int>;
using vii = vector<ii>;
using ll = long long;
using ull = unsigned long long;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
using vll = vector<ll>;
using pdd = pair<double, double>;
using vpdd = vector<pdd>;
template <typename T>
using uset = unordered_set<T>;
template <typename T>
using umultiset = unordered_multiset<T>;
template <typename K, typename V>
using umap = unordered_map<K, V>;
template <typename K, typename V>
using umultimap = unordered_multimap<K, V>;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dc[] = {0, 1, 0, -1, 1, -1, -1, 1};
const double eps = 1e-9;
const int INF = 0x7FFFFFFF;
const ll INFLL = 0x3FFFFFFFFFFFFFFFLL;
const double pi = acos(-1);
template <typename T>
T take(queue<T>& O) {
T tmp = O.front();
O.pop();
return tmp;
}
template <typename T>
T take(stack<T>& O) {
T tmp = O.top();
O.pop();
return tmp;
}
template <typename T>
T take(priority_queue<T>& O) {
T tmp = O.top();
O.pop();
return tmp;
}
template <typename T>
inline bool inRange(const T& z, const T& a, const T& b) {
return a <= z && z <= b;
}
void OPEN(const string& in = "input.txt", const string& out = "output.txt") {
freopen(in.c_str(), "r", stdin);
freopen(out.c_str(), "w", stdout);
return;
}
constexpr int N = 2005;
int n, k, p;
int ppl[N], key[N];
ll dp[N][N];
ll f(int pn, int pk) {
ll& res = dp[pn][pk];
if (res != -1LL) return res;
if (pn == n) {
return res = 0LL;
}
if (pk == k) {
return res = INFLL;
}
res = INFLL;
res = min(res, max(llabs(ppl[pn] - key[pk]) + llabs(key[pk] - p),
f(pn + 1, pk + 1)));
res = min(res, f(pn, pk + 1));
return res;
}
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> p;
for (int(i) = (0), _t = (n); i < (_t); ++(i)) {
cin >> ppl[i];
}
for (int(i) = (0), _t = (k); i < (_t); ++(i)) {
cin >> key[i];
}
sort(ppl, ppl + (n));
sort(key, key + (k));
memset(dp, -1, sizeof(dp));
cout << f(0, 0) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 2005;
const int inf = 2E9 + 9;
int n, m, p;
int a[mxn];
int b[mxn];
inline long long calc(int i, int j) { return abs(a[i] - b[j]) + abs(b[j] - p); }
long long f[mxn][mxn];
signed main() {
ios::sync_with_stdio(false);
cin >> n >> m >> p;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
memset(f, 0x3f, sizeof f);
for (int i = 0; i <= m; ++i) f[0][i] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
f[i][j] = min(f[i][j - 1], max(f[i - 1][j - 1], calc(i, j)));
cout << f[n][m] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
vector<long long int> ar, br;
long long int dp[2000][2005];
const long long int INF = 1e14;
long long int recur(long long int i, long long int j, long long int n,
long long int k, long long int p) {
if ((i >= n) and (j <= k))
return 0ll;
else if ((n - i) > (k - j))
return INF;
else if (dp[i][j] != -1)
return dp[i][j];
else {
return dp[i][j] = min(recur(i, j + 1, n, k, p),
max(recur(i + 1, j + 1, n, k, p),
llabs(ar[i] - br[j]) + llabs(p - br[j])));
}
}
void Compute(long long int n, long long int k, long long int p) {
ar.resize(n);
br.resize(k);
memset(dp, -1, sizeof(dp));
for (long long int i = 0; i < n; i++) {
cin >> ar[i];
}
for (long long int i = 0; i < k; i++) {
cin >> br[i];
}
sort(ar.begin(), ar.end());
sort(br.begin(), br.end());
long long int ans = recur(0, 0, n, k, p);
cout << ans << "\n";
}
int main() {
long long int n, k, p;
cin >> n >> k >> p;
Compute(n, k, p);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 4e3;
long long n, m, k;
long long a[maxn];
long long pos[maxn];
long long cal(long long x, long long y) { return abs(x - y) + abs(m - y); }
bool check(long long dis) {
long long j = 0;
for (long long i = 0; i < n; i++) {
while (j < k && cal(a[i], pos[j]) > dis) j++;
if (j == k) return false;
j++;
}
return true;
}
int main() {
scanf("%I64d %I64d %I64d", &n, &k, &m);
for (long long i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
sort(a + 0, a + n);
for (long long i = 0; i < k; i++) {
scanf("%I64d", &pos[i]);
}
sort(pos + 0, pos + k);
long long l = 0;
long long r = 2e9;
long long ans = -1;
while (l <= r) {
long long g = (l + r) >> 1;
if (check(g)) {
ans = g;
r = g - 1;
} else
l = g + 1;
}
cout << ans;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10240000")
using namespace std;
const int MAXN = 2020;
const long long MAX_INF = (long long)1 << 50;
long long a[MAXN], b[MAXN], dp[MAXN][MAXN];
int main() {
int n, m;
long long p;
scanf("%d%d%I64d", &n, &m, &p);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%I64d", &b[i]);
}
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
for (int i = 0; i <= m; i++) {
dp[0][i] = 0;
}
for (int i = 1; i <= n; i++) {
dp[i][i] = max(dp[i - 1][i - 1], abs(b[i] - a[i]) + abs(p - b[i]));
for (int j = i + 1; j <= m; j++) {
dp[i][j] = dp[i][j - 1];
if (max(dp[i - 1][j - 1], abs(b[j] - a[i]) + abs(p - b[j])) < dp[i][j]) {
dp[i][j] = max(dp[i - 1][j - 1], abs(b[j] - a[i]) + abs(p - b[j]));
}
}
}
long long ans = MAX_INF;
for (int j = n; j <= m; j++) {
if (dp[n][j] < ans) {
ans = dp[n][j];
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
int main() {
int n, k, p;
cin >> n >> k >> p;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> key(k);
for (int i = 0; i < k; i++) cin >> key[i];
sort(a.begin(), a.end());
sort(key.begin(), key.end());
int ans = INF;
for (int i = 0; i < key.size() - a.size() + 1; i++) {
int cur_d = -1;
for (int j = 0; j < a.size(); j++) {
int d = abs(key[i + j] - a[j]) + abs(key[i + j] - p);
cur_d = max(cur_d, d);
}
ans = min(ans, cur_d);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int Matrix[1002][2002];
int max(int a, int b) {
if (a > b)
return a;
else
return b;
}
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
int distance(int a, int b, int c) {
int first, second;
first = a < b ? b - a : a - b;
second = b < c ? c - b : b - c;
return first + second;
}
int main() {
int n, k, p;
int person[1005];
int key[2002];
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) cin >> person[i];
for (int i = 1; i <= k; i++) cin >> key[i];
sort(person + 1, person + n + 1);
sort(key + 1, key + k + 1);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= k; j++) {
if (i == j) {
Matrix[i][j] =
max(Matrix[i - 1][j - 1], distance(person[i], key[i], p));
} else {
Matrix[i][j] =
min(Matrix[i][j - 1],
max(Matrix[i - 1][j - 1], distance(person[i], key[j], p)));
}
}
}
int ans = 2e9;
for (int i = n; i <= k; i++) ans = min(ans, Matrix[n][i]);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932385;
const long double E = 2.71828182845904523536;
const double eps = 1e-9;
const long long mod = 1e9 + 7;
const long long inf = 1LL << 50;
const int N = 2020;
long long a[N], b[N];
long long n, m, p;
long long mem[N][N];
long long dp(int i, int j) {
if (i == n) return 0LL;
if (j == m) return inf;
long long &ret = mem[i][j];
if (ret != -1) return ret;
long long path1 = max(abs(a[i] - b[j]) + abs(b[j] - p), dp(i + 1, j + 1));
long long path2 = dp(i, j + 1);
return ret = min(path1, path2);
}
int main() {
scanf("%lld%lld%lld", &n, &m, &p);
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
for (int i = 0; i < m; i++) scanf("%lld", &b[i]);
sort(a, a + n);
sort(b, b + m);
memset(mem, -1, sizeof mem);
printf("%lld", dp(0, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const long long LINF = INF * (long long)INF;
const int MAX = 2 * 1000 + 47;
int a[MAX];
int b[MAX];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, p;
cin >> n >> k >> p;
for (int i = (0); i < (n); i++) cin >> a[i];
for (int i = (0); i < (k); i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
int ans = 2 * INF;
for (int i = (0); i < (k - n + 1); i++) {
int cur = 0;
for (int j = (0); j < (n); j++) {
cur = max(cur, abs(a[j] - b[i + j]) + abs(b[i + j] - p));
}
ans = min(cur, ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2048;
int n, k, p, a[N], b[N];
long long state[N][N];
bool used[N][N];
long long recurse(int posa, int posb) {
if (posa > n) return 0;
if (posb > k) return 1000000000000000000;
if (used[posa][posb]) return state[posa][posb];
long long ans = 1000000000000000000;
ans = min(ans, recurse(posa, posb + 1));
ans = min(ans, max(recurse(posa + 1, posb + 1),
abs(a[posa] - b[posb]) + 0ll + abs(b[posb] - p)));
used[posa][posb] = true;
state[posa][posb] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, j;
scanf("%d %d %d", &n, &k, &p);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (j = 1; j <= k; j++) scanf("%d", &b[j]);
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + k);
printf("%lld\n", recurse(1, 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void io() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
}
int A[1002], B[2002];
int n, k, p;
bool check(int maxval) {
int i = 1;
int j = 1;
for (i = 1; i <= n; i++) {
bool ok = 0;
while (j <= k && !ok) {
int dis = abs(A[i] - B[j]) + abs(B[j] - p);
if (dis <= maxval) {
ok = 1;
}
j++;
}
if (!ok) return 0;
}
return 1;
}
int main(int argc, char* argv[]) {
io();
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) {
cin >> A[i];
}
for (int j = 1; j <= k; j++) {
cin >> B[j];
}
sort(A + 1, A + n + 1);
sort(B + 1, B + k + 1);
int l = 0;
int r = 2e9 + 1;
int mid;
int ans = r;
while (l <= r) {
mid = l + (r - l) / 2;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0;
int ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void rt(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
rt(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
const int maxn = 2005;
int f[maxn][maxn], a[maxn], b[maxn], n, m, p;
int upd(int &x, int y) {
if (x == -1 || y < x) x = y;
}
int main() {
n = rd(), m = rd(), p = rd();
for (int i = int(1); i <= (int)(n); i++) a[i] = rd();
for (int i = int(1); i <= (int)(m); i++) b[i] = rd();
sort(a + 1, a + n + 1), sort(b + 1, b + m + 1);
memset(f, -1, sizeof f);
for (int j = int(0); j <= (int)(m); j++) f[0][j] = 0;
for (int i = int(1); i <= (int)(n); i++) {
for (int j = int(0); j <= (int)(m - (n - i + 1)); j++)
if (~f[i - 1][j])
upd(f[i][j + 1],
max(f[i - 1][j], abs(a[i] - b[j + 1]) + abs(b[j + 1] - p)));
for (int j = int(i); j <= (int)(m); j++) upd(f[i][j + 1], f[i][j]);
}
rt(f[n][m]), putchar('\n');
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, p;
vector<long long> a;
vector<long long> b;
long long val(long long num1, long long num2) {
return (abs(num1 - num2) + abs(num2 - p));
}
bool check(long long num) {
long long idx_a = 0;
long long idx_b = 0;
while (idx_a < n && idx_b < k) {
long long value = val(a[idx_a], b[idx_b]);
if (value <= num) idx_a++;
idx_b++;
}
if (idx_a == n) return true;
return false;
}
int32_t main() {
cin >> n >> k >> p;
a.resize(n);
b.resize(k);
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long j = 0; j < k; ++j) cin >> b[j];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long low = 0;
long long high = 2e9;
while (low < high) {
long long mid = (low + high) / 2;
if (check(mid))
high = mid;
else
low = mid + 1;
}
cout << low;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, p;
cin >> n >> k >> p;
vector<int> pos(n), key(k);
for (int i = 0; i < n; i++) {
cin >> pos[i];
}
for (int i = 0; i < k; i++) {
cin >> key[i];
}
sort(pos.begin(), pos.end());
sort(key.begin(), key.end());
int lo = 0, hi = 2e9;
long long sol = hi;
while (lo <= hi) {
long long mid = lo + (hi - lo) / 2;
bool ok = false;
int j = 0;
for (int i = 0; i < k && j < n; i++) {
if (abs(key[i] - pos[j]) + abs(key[i] - p) <= mid) {
j++;
if (j >= n) ok = true;
}
}
if (ok) {
sol = min(sol, mid);
hi = mid - 1;
} else {
lo = mid + 1;
}
}
cout << sol << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
int n, k, p;
long long a[N], b[N];
bool check(long long x) {
int lc = 0;
for (int i = 1; i <= n; i++) {
bool fp = false;
while (lc <= k) {
++lc;
long long tmp = abs(a[i] - b[lc]) + abs(b[lc] - p);
if (tmp <= x) break;
}
if (lc > k) return false;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= k; i++) cin >> b[i];
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + k);
long long l = 0, r = 2e9, ans;
while (l <= r) {
long long mid = (l + r) / 2;
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
cout << ans << '\n';
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.