text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, k, p;
cin >> n >> k >> p;
vector<long long> a(n), b(k);
for (auto &i : a) cin >> i;
for (auto &i : b) cin >> i;
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
long long ans = 1e18;
for (long long i = 0; i < (long long)(b).size() - (long long)(a).size() + 1;
++i) {
long long res = 0;
for (long long j = 0; j < (long long)(a).size(); ++j) {
res = max(res, abs(a[j] - b[i + j]) + abs(b[i + j] - p));
}
ans = min(ans, res);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2010][2010];
int a[2010], b[2010], n, m, p;
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;
}
long long len(int i, int j) { return abs(a[i] - b[j]) + abs(p - b[j]); }
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);
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
dp[i][i] = max(dp[i - 1][i - 1], len(i, i));
for (int j = i + 1; j <= m - n + i; ++j)
dp[i][j] = min(dp[i][j - 1], max(dp[i - 1][j - 1], len(i, j)));
}
printf("%lld\n", dp[n][m]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> per, obs;
long long n, k, p;
bool check(long long t) {
long long i = 0;
for (long long j = 0; j <= obs.size() - 1; j++) {
if (abs(per[i] - obs[j]) + abs(p - obs[j]) <= t) {
i++;
if (i == n) return 1;
}
}
return 0;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
for (long long test = 1; test <= t; test++) {
cin >> n >> k >> p;
per.resize(n);
obs.resize(k);
for (long long i = 0; i <= n - 1; i++) cin >> per[i];
for (long long i = 0; i <= k - 1; i++) cin >> obs[i];
sort(per.begin(), per.end());
sort(obs.begin(), obs.end());
long long ans = 1e10, st = 0, end = 1e10;
while (st <= end) {
long long mid = (st + end) >> 1;
if (check(mid)) {
ans = min(ans, mid);
end = mid - 1;
} else
st = mid + 1;
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 2e3 + 5;
long long key[N], pp[N], n, k, p, cost[N];
long long dp[N][N];
int main() {
ios_base::sync_with_stdio(false);
int t = 1;
while (t--) {
cin >> n >> k >> p;
for (int i = 0; i < n; i++) cin >> pp[i];
sort(pp, pp + n);
for (int i = 0; i < k; i++) cin >> key[i];
sort(key, key + k);
for (int i = 0; i < k; i++) cost[i] = abs(key[i] - p);
for (int i = 0; i < n; i++)
for (int j = 0; j <= k + 1; j++) {
if (j >= k)
dp[i][j] = LLONG_MAX;
else
dp[i][j] = abs(pp[i] - key[j]) + cost[j];
}
for (int i = n - 2; i > -1; i--)
for (int j = k - 1; j > -1; j--) {
if (j != k - 1) dp[i][j] = max(dp[i][j], dp[i + 1][j + 1]);
}
long long ans = LLONG_MAX;
for (int i = 0; i <= (k - n); i++) ans = min(dp[0][i], ans);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
const long long inf = 1ll << 55;
long long dp[maxn][maxn], mi[maxn][maxn];
int n, m, p;
int da[maxn], key[maxn];
int main() {
cin >> n >> m >> p;
for (int i = 0; i < n; i++) cin >> da[i];
for (int i = 0; i < m; i++) cin >> key[i];
sort(da, da + n);
sort(key, key + m);
for (int i = 0; i < m; i++) {
dp[0][i] = abs(da[0] - key[i]) + abs(key[i] - p);
if (i)
mi[0][i] = min(mi[0][i - 1], dp[0][i]);
else
mi[0][0] = dp[0][0];
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j < i)
dp[i][j] = inf;
else
dp[i][j] = max((long long)abs(da[i] - key[j]) + abs(key[j] - p),
dp[i - 1][j - 1]);
if (j)
mi[i][j] = min(mi[i][j - 1], dp[i][j]);
else
mi[i][j] = inf;
}
}
cout << mi[n - 1][m - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 + 5;
const int mod = 1e9 + 7;
int n, k, p, a[N], b[N];
int d[N][N];
int link[N], vis[N], use[N];
vector<int> G[N];
int dfs(int u) {
for (int v : G[u]) {
if (vis[v]) continue;
vis[v] = 1;
if (link[v] == -1 || dfs(link[v])) {
link[v] = u;
return 1;
}
}
return 0;
}
int maxMatch(int limit) {
int ret = 0;
memset(use, 0, sizeof(use));
for (int i = 1; i <= k; i++) {
if (link[i] == -1) continue;
if (d[link[i]][i] > limit)
link[i] = -1;
else
use[link[i]] = 1;
}
for (int i = 1; i <= n; i++) {
if (use[i]) continue;
memset(vis, 0, sizeof(vis));
if (!dfs(i)) return 0;
}
return 1;
}
int ok(int limit) {
for (int i = 1; i <= n; i++) {
G[i].clear();
for (int j = 1; j <= k; j++) {
if (d[i][j] <= limit) G[i].push_back(j);
}
}
return maxMatch(limit);
}
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]);
}
vector<int> vec;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
d[i][j] = abs(a[i] - b[j]) + abs(b[j] - p);
vec.push_back(d[i][j]);
}
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
int l = 0, r = vec.size() - 1, ans = 2e9 + 5;
memset(link, -1, sizeof(link));
while (l <= r) {
int m = (l + r) / 2;
if (ok(vec[m]))
r = m - 1, ans = min(ans, vec[m]);
else
l = m + 1;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
long long pe[1005], key[2005];
long long n, k, d;
bool check(long long x) {
int pos = 0;
for (int i = 0; i < k; ++i) {
if (abs(d - key[i]) + abs(pe[pos] - key[i]) <= x) ++pos;
if (pos >= n) return true;
}
return false;
}
int main() {
scanf("%I64d%I64d%I64d", &n, &k, &d);
for (int i = 0; i < n; ++i) scanf("%d", pe + i);
for (int i = 0; i < k; ++i) scanf("%d", key + i);
sort(pe, pe + n);
sort(key, key + k);
long long l = 0, r = INF, mid;
while (l < r) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid + 1;
}
printf("%I64d\n", (l + r) / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a[1005], b[2005], dp[2005][1005], hell = pow(10, 15);
void solve() {
long long int n, k, p;
cin >> n >> k >> p;
for (long long int i = 1; i <= n; i++) cin >> a[i];
for (long long int i = 1; i <= k; i++) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
for (long long int i = 0; i <= k; i++)
for (long long int j = i + 1; j <= n; j++) dp[i][j] = hell;
for (long long int i = 1; i <= k; i++)
for (long long int j = 1; j <= min(n, i); j++) {
dp[i][j] = dp[i - 1][j];
dp[i][j] = min(dp[i][j],
max(dp[i - 1][j - 1], abs(b[i] - a[j]) + abs(p - b[i])));
}
cout << dp[k][n];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int qc = 1;
for (long long int i = 1; i <= qc; i++) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int mn = 2010;
long long a[mn], b[mn];
int main() {
int n, k;
long long p;
scanf("%d %d %lld", &n, &k, &p);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= k; i++) scanf("%lld", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long ans = 4e18;
for (int st = 0; st + n <= k; st++) {
long long tans = 0;
for (int i = 1; i <= n; i++) {
long long temp = 0;
long long now = b[st + i];
if (a[i] <= p && now <= p) {
if (a[i] <= now)
temp += p - a[i];
else
temp += a[i] - now + p - now;
} else if (a[i] <= p && p < now)
temp += now - a[i] + now - p;
else if (now <= p && p < a[i])
temp += a[i] - now + p - now;
else if (p < a[i] && p < now) {
if (now <= a[i])
temp += a[i] - p;
else
temp += now - a[i] + now - p;
}
tans = max(tans, temp);
}
ans = min(ans, tans);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
template <typename T>
using vec = vector<T>;
template <typename T>
using Prior = priority_queue<T>;
template <typename T>
using prior = priority_queue<T, vec<T>, greater<T>>;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ll MOD = 998244353;
const double PI = 3.14159265358;
const double EPS = 1e-8;
const int xx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int yy[8] = {1, 0, -1, 0, 1, -1, -1, 1};
unsigned seed = chrono::steady_clock::now().time_since_epoch().count();
mt19937 rng(seed);
uniform_int_distribution<int> dist(1, 1e6);
template <typename T>
void dbg(T x) {
cerr << x << '\n';
}
template <typename T, typename... A>
void dbg(T x, A... y) {
cerr << x << ", ";
dbg(y...);
}
template <typename T>
void amax(T &a, T b) {
if (a < b) a = b;
}
template <typename T>
void amin(T &a, T b) {
if (a > b) a = b;
}
template <typename T>
bool INR(T a, T b, T c) {
return b <= a && a <= c;
}
void pmod(ll &a, ll b) { a = (a + b) % MOD; }
void mmod(ll &a, ll b) { a = (a - b + MOD) % MOD; }
void tmod(ll &a, ll b) { a = (a * b) % MOD; }
void UNI(vec<int> &v) {
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
}
int getint() {
int ret;
cin >> ret;
return ret;
}
ll getll() {
ll ret;
cin >> ret;
return ret;
}
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll POW(ll a, ll b) {
ll res = 1;
do {
if (b % 2) tmod(res, a);
tmod(a, a);
} while (b >>= 1);
return res;
}
const int MXN = 200000;
const int N = MXN + 10;
void solve() {
int n, m, p;
cin >> n >> m >> p;
vec<int> v(n), g(m);
for (auto &i : v) cin >> i;
for (auto &i : g) cin >> i;
v.emplace_back(0);
g.emplace_back(0);
sort(v.begin(), v.end());
sort(g.begin(), g.end());
vec<int> dp(m + 1);
for (int i = 1; i <= (n); ++i) {
for (int j = (m); j >= (i); --j)
dp[j] = max(dp[j - 1], abs(v[i] - g[j]) + abs(g[j] - p));
for (int j = (i); j <= (m - 1); ++j) amin(dp[j + 1], dp[j]);
}
cout << dp[m] << '\n';
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T = 1;
while (T--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 100000000 + 9;
int main(int argc, char** argv) {
long long n, k, p;
cin >> n >> k >> p;
vector<long long> a(n, 0), b(k, 0);
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < k; i++) cin >> b[i];
sort(b.begin(), b.end());
sort(a.begin(), a.end());
long long mintime = inf;
for (long long i = 0; i <= k - n; i++) {
long long time = 0;
for (long long j = 0; j < n; j++) {
if (j != 0)
time = max(time, abs(b[i + j] - a[j]) + abs(p - b[i + j]));
else
time = abs(b[i + j] - a[j]) + abs(p - b[i + j]);
}
if (i != 0)
mintime = min(mintime, time);
else
mintime = time;
}
cout << mintime << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int INF = 1000001000;
const long long INFLL = INF * 1LL * INF;
const int mod = 1000 * 1000 * 1000 + 7;
const int mod9 = 1000 * 1000 * 1000 + 9;
const int modr = 99990001;
const long double PI = 3.1415926535897932385;
template <class T>
void zero(T val, T& first) {
first = val;
}
template <class T, class... Targs>
void zero(T val, T& first, Targs&... Fargs) {
first = val;
zero(val, Fargs...);
}
template <class T, class T2>
std::istream& operator>>(std::istream& is, pair<T, T2>& p) {
return is >> p.first >> p.second;
}
template <class T>
std::istream& readN(T& first, int n, int st = 0) {
for (int i = st, iend = (st + n - 1); i <= iend; i++) cin >> first[i];
return cin;
}
template <class T>
std::istream& readS(set<T>& first, int n) {
T second = *first.rbegin();
for (int i = 0, iend = (n - 1); i <= iend; i++) {
cin >> second;
first.insert(second);
}
return cin;
}
template <class T>
std::istream& read(T& first) {
return cin >> first;
}
template <class T, class... Targs>
std::istream& read(T& first, Targs&... Fargs) {
return read(first), read(Fargs...);
}
template <class T, class T2>
std::ostream& operator<<(std::ostream& os, pair<T, T2> p) {
return os << p.first << " " << p.second;
}
template <class T>
std::ostream& operator<<(std::ostream& os, vector<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, set<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T>
std::ostream& operator<<(std::ostream& os, multiset<T> v) {
bool f = true;
for (auto second : v) {
if (!f) os << ' ';
os << second;
f = false;
}
return os;
}
template <class T, class T2>
std::ostream& operator<<(std::ostream& os, map<T, T2> v) {
bool f = true;
for (pair<T, T2> second : v) {
if (!f) os << ' ';
os << second.first << "=>" << second.second;
f = false;
}
return os;
}
template <class T>
std::ostream& outV(T first, char del = ' ') {
bool f = true;
for (auto second : first) {
if (!f) cout << del;
cout << second;
f = false;
}
return cout;
}
template <class T>
std::ostream& outN(T first, int n = -1, int st = 0) {
for (int i = st, iend = (n == -1 ? (int)first.size() - 1 : st + n - 1);
i <= iend; i++) {
cout << first[i];
if (i < iend) cout << ' ';
}
return cout;
}
template <class T>
std::ostream& outAN(T first, int n = -1, int st = 0) {
for (int i = st, iend = (n - 1); i <= iend; i++) {
cout << first[i];
if (i < iend) cout << ' ';
}
return cout;
}
template <class T>
std::ostream& outA2(T first, int n, int m) {
for (int i = 0, iend = (n - 1); i <= iend; i++) {
for (int j = 0, jend = (m - 1); j <= jend; j++)
cout << first[i][j] << (j == m - 1 ? '\n' : ' ');
}
return cout;
}
template <class T>
std::ostream& out(T first) {
return cout << first;
}
template <class T, class... Targs>
std::ostream& out(T first, Targs... Fargs) {
return out(first) << " ", out(Fargs...);
}
template <typename T>
void srt(T& a, int st, int fn, bool isArr) {
sort(a + st, a + fn + 1);
}
template <class T>
void srt(T& a, int st = 0, int fn = 0) {
sort(a.begin() + st, fn ? a.begin() + fn + 1 : a.end());
}
template <typename T>
T rev_num(T a) {
T r = 0;
for (; a; a /= 10) r = r * 10 + a % 10;
return r;
}
template <typename T>
void rev(T& a, int st, int fn, bool isArr) {
reverse(a + st, a + fn + 1);
}
template <class T>
void rev(T& a, int st = 0, int fn = 0) {
reverse(a.begin() + st, fn ? a.begin() + fn + 1 : a.end());
}
long long sqr(long long a) { return a * a; };
long long sqr(int a) { return a * 1LL * a; };
long double sqr(long double a) { return a * a; };
long double dist(pair<long long, long long> first,
pair<long long, long long> second) {
return sqrt(sqr(first.first - second.first) +
sqr(first.second - second.second));
}
long long phi(int n) {
int res = n;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
while (n % i == 0) n /= i;
res -= res / i;
}
if (n > 1) res -= res / n;
return res;
}
long long bpm(long long a, long long n = -2, long long m = mod) {
n = n < 0 ? n + m : n;
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % m;
a = (a * a) % m;
n >>= 1;
}
return r;
}
unsigned long long gcd(unsigned long long a, unsigned long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
vector<int> ero_p, ero_l;
void ero(int n) {
ero_l.resize(n + 1);
ero_l[0] = -1;
for (int i = 2, iend = (n); i <= iend; i++)
if (!ero_l[i]) {
ero_p.push_back(i);
ero_l[i] = i;
for (long long j = i * 1LL * i; j <= n; j += i) {
ero_l[j] = i;
}
}
}
long long gcd_cb(long long a, long long b, long long& first,
long long& second) {
if (!b) {
first = 1;
second = 0;
return a;
}
long long x1, y1, g;
g = gcd_cb(b, a % b, x1, y1);
first = y1;
second = x1 - a / b * y1;
return g;
}
vector<long long> fact;
void fact_prec(int n = 20) {
fact.resize(n + 1);
fact[0] = 1;
for (int i = 1, iend = (n); i <= iend; i++) {
fact[i] = fact[i - 1] * i;
}
}
vector<long double> factd;
void fact_precd(int n = 146) {
factd.resize(n + 1);
factd[0] = 1;
for (int i = 1, iend = (n); i <= iend; i++) {
factd[i] = factd[i - 1] * i;
}
}
string str(long long a) {
string r = "";
for (; a; a /= 10) r += a % 10 + '0';
rev(r);
return r;
}
template <class T>
int bitc(T first) {
int r = 0;
for (T d = first; d >= 0; d >>= 1) r += d & 1;
return r;
}
const int N = 100005;
int a[N], b[N];
bool can(int n, int k, long long s, long long p) {
int st = 0;
for (int i = 0, iend = (n - 1); i <= iend; i++) {
long long pos = a[i];
if (abs(pos - p) > s) return false;
long long ost = (s - abs(pos - p)) / 2;
long long l, r;
if (pos < p) {
l = pos - ost;
r = p + ost;
} else {
l = p - ost;
r = pos + ost;
}
int bi = upper_bound(b + st, b + k, l - 1) - b;
int f = b[bi];
if (bi < k && f <= r && f >= l) {
st = bi + 1;
} else {
return false;
}
}
return true;
}
int main() {
int n, k, p;
read(n, k, p);
readN(a, n);
readN(b, k);
sort(b, b + k);
sort(a, a + n);
long long l = 0, r = 3e9;
while (l != r) {
long long m = (l + r) >> 1;
if (!can(n, k, m, p)) {
l = m + 1;
} else {
r = m;
}
}
out(l) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e15, mod = 1e9 + 7;
long long pos[1005], key[2005], p;
long long dp[1005][2005];
int n, k;
long long solve(int i, int j) {
if (i == n) return 0ll;
if (dp[i][j] != -1) return dp[i][j];
long long ans = inf;
if (j < k and i < n)
ans = max(solve(i + 1, j + 1), abs(pos[i] - key[j]) + abs(key[j] - p));
if (j < k) ans = min(ans, solve(i, j + 1));
return dp[i][j] = ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> p;
for (int i = 0; i < n; i++) cin >> pos[i];
for (int i = 0; i < k; i++) cin >> key[i];
memset(dp, -1, sizeof(dp));
sort(pos, pos + n);
sort(key, key + k);
cout << solve(0, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long N = 2001;
long people[N], keys[N], cur[N], best[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
long n, k, goal;
cin >> n >> k >> goal;
for (long i = 0; i < n; ++i) cin >> people[i];
for (long i = 0; i < k; ++i) cin >> keys[i];
sort(people, people + n);
sort(keys, keys + k);
long choices = k - n + 1;
for (long i = 0; i < n; ++i) {
for (long j = 0; j < choices; ++j) {
cur[i + j] = abs(keys[i + j] - people[i]) + abs(keys[i + j] - goal);
cur[i + j] = max(cur[i + j], best[i + j]);
}
best[i + 1] = cur[i];
for (long j = 1; j < choices; ++j)
best[i + j + 1] = min(best[i + j], cur[i + j]);
}
cout << best[k] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p, a[2010], b[2010], res = INT_MAX, i, j;
int main() {
cin >> n >> k >> p;
for (i = 0; i < n; i++) scanf("%d", a + i);
for (i = 0; i < k; i++) scanf("%d", b + i);
sort(a, a + n);
sort(b, b + k);
for (i = 0; i <= k - n; i++) {
int t = 0;
for (j = 0; j < n; j++)
t = max(t, abs(a[j] - b[i + j]) + abs(p - b[i + j]));
res = min(t, res);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long b[2010], a[2010];
long long dp[2010][2010];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.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(b, b + k);
sort(a, a + n);
memset(dp, 0, sizeof dp);
for (int i = 0; i < k; i++) {
dp[0][i] = abs(a[0] - b[i]) + abs(b[i] - p);
}
for (int i = 1; i < k; i++) dp[0][i] = min(dp[0][i - 1], dp[0][i]);
for (int i = 1; i < n; i++) {
for (int j = i; j < k; j++) {
dp[i][j] = max(abs(a[i] - b[j]) + abs(b[j] - p), dp[i - 1][j - 1]);
}
for (int j = i + 1; j < k; j++) dp[i][j] = min(dp[i][j - 1], dp[i][j]);
}
cout << dp[n - 1][k - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[202000], b[200020];
long long dp[2020][2020];
int main() {
long long n, k, p;
while (~scanf("%lld%lld%lld", &n, &k, &p)) {
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long i = 1; i <= k; i++) scanf("%lld", &b[i]);
memset(dp, 0, sizeof(dp));
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long ans = 0x3f3f3f3f3f3f;
for (long long i = 1; i <= n; i++) {
for (long long j = i; j <= k; j++) {
long long key = abs(a[i] - b[j]) + abs(b[j] - p);
long long tmp = max(key, dp[i - 1][j - 1]);
if (i == j)
dp[i][j] = tmp;
else
dp[i][j] = min(tmp, dp[i][j - 1]);
}
}
for (long long i = n; i <= k; i++) ans = min(ans, dp[n][i]);
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void TEST_CASE() {
long long n, k, p;
cin >> n >> k >> p;
long long a[n + 1];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long b[k + 1];
for (long long i = 0; i < k; i++) {
cin >> b[i];
}
sort(a, a + n);
sort(b, b + k);
long long dp[k + 1][n + 1];
for (long long i = 0; i <= k; i++) {
for (long long j = 0; j <= n; j++) {
dp[i][j] = 1000000000000000000;
}
}
dp[0][0] = 0;
for (long long i = 0; i < k; i++) {
for (long long 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(a[j] - b[i]) + abs(b[i] - p)));
}
}
}
cout << dp[k][n] << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
TEST_CASE();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000, INF = 2e9;
int dp[MAXN][MAXN];
int N, K, P, A[MAXN], B[MAXN];
int f(int i, int j) {
if (i == N) return 0;
if (j == K) return INF;
if (dp[i][j] != -1) return dp[i][j];
dp[i][j] =
min(f(i, j + 1), max(f(i + 1, j + 1), abs(A[i] - B[j]) + abs(P - B[j])));
return dp[i][j];
}
int main() {
scanf("%d", &N), scanf("%d", &K), scanf("%d", &P);
for (int i = 0; i < (int)N; i++) scanf("%d", &A[i]);
for (int i = 0; i < (int)K; i++) scanf("%d", &B[i]);
sort(A, A + N);
sort(B, B + K);
memset(dp, -1, sizeof(dp));
printf("%d\n", f(0, 0));
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1010 + 1][2010 + 1], arrm[1010 + 1], arrk[2010 + 1];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k, p;
cin >> n >> k >> p;
for (int i = 0; i < n; i++) cin >> arrm[i];
for (int i = 0; i < k; i++) cin >> arrk[i];
sort(arrm, arrm + n);
sort(arrk, arrk + k);
dp[0][0] = abs(arrm[0] - arrk[0]) + abs(p - arrk[0]);
for (int i = 1; i < k; i++)
dp[0][i] = min(dp[0][i - 1], abs(arrm[0] - arrk[i]) + abs(p - arrk[i]));
for (int i = 1; i < n; i++) {
dp[i][i] = max(dp[i - 1][i - 1], abs(arrm[i] - arrk[i]) + abs(p - arrk[i]));
for (int j = i + 1; j < k; j++)
dp[i][j] =
min(max(dp[i - 1][j - 1], abs(arrm[i] - arrk[j]) + abs(p - arrk[j])),
dp[i][j - 1]);
}
cout << dp[n - 1][k - 1] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e15 + 7;
const int M = 2e6 + 3;
const long double PI = acos(-1);
const int POW = 25;
const long long MOD = 1e9 + 7;
const int N = 3e5 + 10;
long long a[N], b[N];
int main() {
long long n, k, p;
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 = INF;
for (long long l = 0; l < k - n + 1; ++l) {
long long mx = 0;
for (long long i = 0; i < n; ++i) {
mx = max(mx, abs(b[i + l] - a[i]) + abs(b[i + l] - p));
}
ans = min(ans, mx);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, k, p;
long long kq = 1e18;
cin >> n >> k >> p;
vector<long long> a(n), b(k);
for (long i = 0; i < n; cin >> a[i], ++i)
;
for (long i = 0; i < k; cin >> b[i], ++i)
;
sort(a.begin(), a.end());
sort(b.begin(), b.end());
for (long i = 0; i <= k - n; ++i) {
long long k1 = 0;
for (long j = 0, z = i; j < n && z < k; ++j, ++z)
k1 = max(k1, abs(a[j] - b[z]) + abs(b[z] - p));
kq = min(kq, k1);
}
cout << kq;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long N = 1e5 + 10;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
const long long inf = -1e18;
const long long M = 5 * 1e8;
long long a[1100], b[2100], n, k, p, co, color[2100];
long long check(long long t) {
long long h, s;
co++;
for (int i = 1; i <= n; i++) {
int f = 0;
for (int j = 1; j <= k; j++) {
if (color[j] != co) {
s = abs(a[i] - b[j]) + abs(b[j] - p);
if (s <= t) {
f = 1;
color[j] = co;
break;
}
}
}
if (f == 0) return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
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 = 0ll, r = 20000000000ll;
while (l + 1 < r) {
long long mid = ((l + r) >> 1);
if (check(mid) == 1)
r = mid;
else
l = mid;
}
if (check(l) == 1) {
cout << l;
} else {
cout << r;
}
cin.get(), cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1e3 + 2;
long long dp[2 * MAX_N], memo[2 * MAX_N];
long long c[2 * MAX_N];
long long v[MAX_N], x[2 * MAX_N];
int n, k;
long long p;
int main() {
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = 1; i <= k; i++) cin >> x[i];
sort(v + 1, v + n + 1);
sort(x + 1, x + k + 1);
for (int i = 1; i <= k; i++) c[i] = abs(x[i] - p);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) dp[j] = memo[j];
for (int j = i; j <= k; j++)
dp[j] = max(memo[j - 1], abs(v[i] - x[j]) + c[j]);
memo[i] = dp[i];
for (int j = i + 1; j <= k; j++) memo[j] = min(memo[j - 1], dp[j]);
}
cout << memo[k] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using ii = pair<int, int>;
using ll = pair<lint, lint>;
using ti = tuple<int, int, int>;
using il = pair<int, lint>;
namespace T {
const int MAX = 1e5 + 5;
const int INF = 1e9 + 7;
int max_t[4 * MAX];
int min_t[4 * MAX];
void max_up(int n, int s, int e, int p, int v) {
if (p < s || p > e) return;
if (s == e)
max_t[n] = v;
else {
max_up(2 * n, s, (s + e) / 2, p, v);
max_up(2 * n + 1, (s + e) / 2 + 1, e, p, v);
max_t[n] = max(max_t[2 * n], max_t[2 * n + 1]);
}
}
void min_up(int n, int s, int e, int p, int v) {
if (p < s || p > e) return;
if (s == e)
min_t[n] = v;
else {
min_up(2 * n, s, (s + e) / 2, p, v);
min_up(2 * n + 1, (s + e) / 2 + 1, e, p, v);
min_t[n] = min(min_t[2 * n], min_t[2 * n + 1]);
}
}
int max_v(int n, int s, int e, int l, int r) {
if (r < s || l > e) return 0;
if (l <= s && e <= r) return max_t[n];
int m = (s + e) / 2;
return max(max_v(2 * n, s, m, l, r), max_v(2 * n + 1, m + 1, e, l, r));
}
int min_v(int n, int s, int e, int l, int r) {
if (r < s || l > e) return INF;
if (l <= s && e <= r) return min_t[n];
int m = (s + e) / 2;
return min(min_v(2 * n, s, m, l, r), min_v(2 * n + 1, m + 1, e, l, r));
}
} // namespace T
namespace P {
const int N = 2 * 1e6 + 5;
using lint = long long;
bool v[N];
void make() {
fill(v, v + N, true);
for (int i = 2; i < N; i++) {
if (v[i]) {
for (lint j = (lint)i * i; j < N; j += i) {
v[j] = false;
}
}
}
}
} // namespace P
namespace U {
int min3(int a, int b, int c) { return min(min(a, b), c); }
int min4(int a, int b, int c, int d) { return min(min(a, b), min(c, d)); }
int max3(int a, int b, int c) { return max(max(a, b), c); }
int max4(int a, int b, int c, int d) { return max(max(a, b), max(c, d)); }
bool get(char c) {
return (c == 'a') || (c == 'e') || (c == 'i') || (c == 'o') || (c == 'u');
}
int gcd(int a, int b) {
if (a < b) {
swap(a, b);
}
if (b == 0)
return a;
else
return gcd(b, a % b);
}
} // namespace U
const int N = 5 * 1e3 + 5;
const lint mod = 1e9 + 7;
const lint inf = 1e18 + 7;
int n, k;
lint p;
lint a[N], b[N];
void input() {
scanf("%d%d%lld", &n, &k, &p);
for (int i = 0; i < n; i++) {
scanf("%lld", a + i);
}
sort(a, a + n);
for (int i = 0; i < k; i++) {
scanf("%lld", b + i);
}
sort(b, b + k);
}
void go() {
lint ans = inf;
for (int i = 0; i < k; i++) {
if (i + n > k) {
break;
}
lint t = 0;
for (int j = 0; j < n; j++) {
t = max(t, (lint(abs(a[j] - b[i + j]))) + (lint(abs(p - b[i + j]))));
}
ans = min(ans, t);
}
printf("%lld\n", ans);
}
int main() {
input();
go();
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:216000000")
using namespace std;
const long long MAX = 100000000LL * 100000000LL;
const long long MIN = numeric_limits<long long>::min();
const double PI = 3.14159265358979;
const long long MOD = 1000000007LL;
template <class T>
ostream& operator<<(ostream& out, vector<T>& v) {
for (int i = 0; i < v.size(); ++i) out << v[i] << " ";
return out;
}
template <class T>
istream& operator>>(istream& in, vector<T>& v) {
for (int i = 0; i < v.size(); ++i) in >> v[i];
return in;
}
template <class L, class R>
istream& operator>>(istream& in, pair<L, R>& p) {
in >> p.first >> p.second;
return in;
}
template <class T>
T lexical_cast(string& s) {
stringstream ss(s);
T t;
ss >> t;
return t;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long cdiv(long long a, long long b) {
return (a % b) ? (a / b + 1) : (a / b);
}
long long inv(long long n, long long mod) {
long long pow = mod - 2;
long long ans = 1;
long long cur = n;
while (pow > 0) {
if (pow & 1) {
ans *= cur;
ans %= mod;
}
pow /= 2;
cur *= cur;
cur %= mod;
}
return ans;
}
template <class Cont>
void sort(Cont& c) {
sort(begin(c), end(c));
}
template <class Cont>
void reverse(Cont& c) {
reverse(begin(c), end(c));
}
map<long long, long long> get_divs(long long k) {
map<long long, long long> divs;
for (long long i = 2; i * i <= k; ++i) {
while (k % i == 0) {
divs[i]++;
k /= i;
}
}
if (k != 1) divs[k]++;
return divs;
}
int main() {
ios_base::sync_with_stdio(false);
int n, k;
long long p;
cin >> n >> k >> p;
vector<long long> a(n), b(k);
cin >> a >> b;
sort(a);
sort(b);
long long ans = MAX;
for (int st = 0; st + n <= k; ++st) {
long long curans = 0;
for (int i = 0; i < n; ++i) {
curans = max(curans, abs(a[i] - b[st + i]) + abs(b[st + i] - p));
}
ans = min(ans, curans);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e3 + 10;
const double eps = 1e-6;
int dp[MAX][MAX];
int main() {
int n, m, aim, i, j, a[MAX], b[MAX];
cin >> n >> m >> aim;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= m; i++) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
memset(dp, 0, sizeof(dp));
for (i = 1; i <= n; i++)
for (j = i; j <= m; j++) {
if (i == j)
dp[i][j] = max(dp[i - 1][j - 1], abs(a[i] - b[j]) + abs(b[j] - aim));
else
dp[i][j] = min(dp[i][j - 1], max(dp[i - 1][j - 1],
abs(a[i] - b[j]) + abs(b[j] - aim)));
}
cout << dp[n][m] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10;
long long a[N], b[N], p;
int k, n;
bool vis[N];
bool ok(long long x) {
memset(vis, 0, sizeof(vis));
bool f = 1;
for (int i = 1; i <= n && f; i++) {
f = 0;
for (int j = 1; j <= k; j++) {
if (!vis[j]) {
if (abs(a[i] - b[j]) + abs(p - b[j]) <= x) {
vis[j] = 1;
f = 1;
break;
}
}
}
}
return f;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
while (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 l = 0, r = 1e10 + 10;
long long ans = -1;
while (l <= r) {
long long m = (l + r) >> 1;
if (ok(m)) {
ans = m;
r = m - 1;
} else
l = m + 1;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 123;
const long long inf = 1e18;
int n, k, p, a[N], b[N];
bool u[N];
long long l, r = inf;
bool ok(long long x) {
int cnt = 0;
for (int i = 1; i <= k; i++) u[i] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (!u[j] && abs(a[i] - b[j]) + abs(p - b[j]) <= x) {
u[j] = 1;
cnt++;
break;
}
}
}
return cnt == n;
}
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);
long long ans;
while (l <= r) {
long long mid = (l + r) / 2;
if (ok(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, p;
cin >> n >> k >> p;
vector<int> people(n);
for (int& x : people) cin >> x;
vector<int> keys(k);
for (int& x : keys) cin >> x;
sort(begin(people), end(people));
sort(begin(keys), end(keys));
int answer = numeric_limits<int>::max();
for (int i = 0; i + n <= k; i++) {
int option = 0;
for (int j = 0; j < n; j++)
option = max(option, abs(people[j] - keys[i + j]) + abs(keys[i + j] - p));
answer = min(answer, option);
}
cout << answer << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[1005][2005];
bool mark[1005][2005];
int a[1005], b[2005];
int n, k, p;
long long f(int i, int j) {
if (i == n) return 0;
if (mark[i][j]) return dp[i][j];
mark[i][j] = true;
long long ret = 1e18;
if (k - j > n - i) ret = f(i, j + 1);
long long dist = abs(a[i] - b[j]) + abs(p - b[j]);
ret = min(ret, max(f(i + 1, j + 1), dist));
return dp[i][j] = ret;
}
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < k; i++) scanf("%d", &b[i]);
sort(a, a + n);
sort(b, b + k);
long long ans = f(0, 0);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ppos[2005];
int kpos[2005];
pair<int, int> seg[2005];
bool tk[2005];
int main() {
int n, k, p;
scanf("%d %d %d", &n, &k, &p);
for (int i = 0; i < n; i++) scanf("%d", ppos + i);
for (int i = 0; i < k; i++) scanf("%d", kpos + i);
int lo = 0;
int hi = 2000000000;
int md;
sort(ppos, ppos + n);
while (lo <= hi) {
memset(tk, 0, sizeof(tk));
md = (0ll + lo + hi) / 2;
for (int i = 0; i < k; i++) {
seg[i] = make_pair(kpos[i] - (md - abs(kpos[i] - p)),
kpos[i] + (md - abs(kpos[i] - p)));
}
sort(seg, seg + k);
bool ok = true;
for (int i = 0; i < n; i++) {
bool bad = true;
for (int j = 0; j < k; j++) {
if (tk[j]) continue;
if (seg[j].first <= ppos[i] && seg[j].second >= ppos[i]) {
tk[j] = true;
bad = false;
break;
}
}
if (bad) ok = false;
}
if (ok)
hi = md - 1;
else
lo = md + 1;
}
printf("%d\n", lo);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[2222], b[2222], par[2222], vst[2222];
vector<int> adj[2222];
int BPM(int u) {
for (int i = 0; i < adj[u].size(); i++) {
if (par[adj[u][i]] == -1) {
par[adj[u][i]] = u;
return 1;
}
}
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (vst[v]) continue;
vst[v] = 1;
if (BPM(par[v])) {
par[v] = u;
return 1;
}
}
return 0;
}
int main() {
int n, k, p;
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 + n + 1);
long long st = -1, ed = 2000000000;
while (ed > st + 1) {
long long mid = (st + ed) >> 1;
for (int i = 1; i <= n; i++) adj[i].clear();
memset(par, -1, sizeof(par));
memset(vst, 0, sizeof(vst));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (abs(a[i] - b[j]) + abs(b[j] - p) <= mid) adj[i].push_back(j);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += BPM(i);
}
if (ans == n)
ed = mid;
else
st = mid;
}
cout << ed << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int ans;
int a[2002], b[2002];
int le;
int p;
int ssearch(int x) {
int maxd = 0;
for (int i = 1; i <= n; i++) {
int z = abs(a[i] - b[x - le + i]) + abs(b[x - le + i] - p);
if (z > maxd) maxd = z;
}
return maxd;
}
int main() {
int k;
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);
le = n;
for (int i = 1; i <= n; i++)
if (a[i] >= p) {
le = i - 1;
break;
}
ans = 2147483647;
for (int i = le; i <= k + le - n; i++) {
int y = ssearch(i);
if (y < ans) ans = y;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, first, k, p, i, a[2002], b[2002], dp[2002][2002], j;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
vector<pair<long long, long long> > v;
cin >> n >> k >> p;
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);
for (i = 0; i <= n; ++i)
for (j = 0; j <= k; ++j) dp[i][j] = 1e15;
for (i = 0; i <= k; ++i) dp[0][i] = 0;
for (i = 1; i <= n; ++i)
for (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];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100009];
long long b[100009];
int n, m;
int x;
int main() {
cin >> n >> m >> x;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int j = 0; j < m; j++) cin >> b[j];
sort(b, b + m);
long long max1 = 100000000000;
for (int i = 0; i <= m - n; i++) {
long long op = 0;
for (int j = 0; j < n; j++) {
op = max(op, abs(a[j] - b[i + j]) + abs(x - b[i + j]));
}
max1 = min(max1, op);
}
cout << max1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mp[2005];
int main() {
memset(mp, 0, sizeof mp);
long long key[2001], a[2001], n, k, p, i, j;
cin >> n >> k >> p;
for (i = 0; i < n; i++) {
scanf("%lld", a + i);
}
for (i = 0; i < k; i++) {
scanf("%lld", key + i);
}
sort(a, a + n);
sort(key, key + k);
long long mn = 1e18;
for (i = 0; i < k - n + 1; i++) {
long long x = -1;
for (int j = i, l = 0; l < n; l++, j++) {
long long y = abs(a[l] - key[j]) + abs(p - key[j]);
x = max(y, x);
}
mn = min(x, mn);
}
cout << mn;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18;
const double eps = 1e-12;
const double pi = acos(-1);
template <typename T>
istream& operator>>(istream& is, vector<T>& vec) {
for (auto&& x : vec) is >> x;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
for (long long i = (0), __last_i = (vec.size()); i < __last_i; i++) {
if (i) os << " ";
os << vec[i];
}
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<vector<T> >& vec) {
for (long long i = (0), __last_i = (vec.size()); i < __last_i; i++) {
if (i) os << endl;
os << vec[i];
}
return os;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m, X;
cin >> n >> m >> X;
vector<long long> a(n), b(m);
cin >> a >> b;
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
auto check = [&](long long T) {
long long s = 0;
for (auto&& x : a) {
long long d = T - abs(X - x);
if (d < 0) return false;
d /= 2;
long long l = x < X ? x - d : X - d;
long long r = x < X ? X + d : x + d;
l = lower_bound((b).begin(), (b).end(), l) - b.begin();
r = upper_bound((b).begin(), (b).end(), r) - b.begin();
l = max(l, s);
if (l >= r) return false;
s = l + 1;
}
return true;
};
long long lb = 0, ub = linf;
for (long long t = (0), __last_t = (60); t < __last_t; t++) {
long long mid = (lb + ub) / 2;
if (check(mid)) {
ub = mid;
} else {
lb = mid;
}
}
cout << ub << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p, a[1000], b[2000], ans = 2e9;
inline int abs(int x) {
if (x < 0)
return -x;
else
return x;
}
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a, a + n);
for (int i = 0; i < k; ++i) scanf("%d", &b[i]);
sort(b, b + k);
for (int i = 0; i <= k - n; ++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));
if (ans > cur) ans = cur;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void cmax(T &x, T y) {
x < y ? x = y : x;
}
template <typename T>
inline void cmin(T &x, T y) {
y < x ? x = y : x;
}
char bf[1 << 21], *p1(bf), *p2(bf);
template <typename T>
inline void read(T &x) {
char t(
(p1 == p2 && (p1 = bf, p2 = bf + fread(bf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++)),
flg(0);
x = 0;
for (; !isdigit(t);
t = (p1 == p2 &&
(p1 = bf, p2 = bf + fread(bf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++))
flg = t == '-';
for (; isdigit(t);
t = (p1 == p2 &&
(p1 = bf, p2 = bf + fread(bf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++))
x = x * 10 + (t & 15);
flg ? x = -x : x;
}
clock_t t_bg, t_ed;
int N, M, P, n, m;
int a[1005], b[1005 << 1];
int l, r, mid, ans;
inline int Abs(int x) { return x < 0 ? -x : x; }
bool v[1005 << 1];
inline bool check(int d) {
memset(v, 0, sizeof v);
int i(1), j(n), p(1);
while (i <= j) {
while (p <= m && (v[p] || Abs(a[i] - b[p]) + Abs(P - b[p]) > d)) ++p;
if (p > m)
break;
else
v[p] = 1;
++i;
}
p = M;
while (i <= j) {
while (p > m && (v[p] || Abs(a[j] - b[p]) + Abs(P - b[p]) > d)) --p;
if (p <= m)
return 0;
else
v[p] = 1;
--j;
}
i = n + 1, j = N, p = 1;
while (i <= j) {
while (p <= m && (v[p] || Abs(a[i] - b[p]) + Abs(P - b[p]) > d)) ++p;
if (p > m)
break;
else
v[p] = 1;
++i;
}
p = M;
while (i <= j) {
while (p > m && (v[p] || Abs(a[j] - b[p]) + Abs(P - b[p]) > d)) --p;
if (p <= m)
return 0;
else
v[p] = 1;
--j;
}
return 1;
}
int main() {
read(N), read(M), read(P);
for (int i(1), I(N); i <= I; ++i) read(a[i]), cmax(l, Abs(P - a[i]));
for (int i(1), I(M); i <= I; ++i) read(b[i]);
sort(a + 1, a + N + 1), sort(b + 1, b + M + 1);
n = lower_bound(a + 1, a + N + 1, P) - a;
if (a[n] != P) --n;
m = lower_bound(b + 1, b + M + 1, P) - b;
if (b[m] != P) --m;
r = 2e9;
while (l <= r)
check(mid = ((long long)l + (long long)r) >> 1) ? r = (ans = mid) - 1
: l = mid + 1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
const int MAXN = 2003;
int n, k, p;
int dp[MAXN / 2][MAXN];
int a[MAXN / 2];
int b[MAXN];
int main() {
n = readInt(), k = readInt(), p = readInt();
for (int i = 0; i < n; i++) {
a[i] = readInt();
}
for (int i = 0; i < k; i++) {
b[i] = readInt();
}
sort(a, a + n);
sort(b, b + k);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= k; j++) {
dp[i][j] = 2e9;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
chkmin(dp[i][j + 1], dp[i][j]);
chkmin(dp[i + 1][j + 1], max(dp[i][j], abs(a[i] - b[j]) + abs(b[j] - p)));
}
}
int ans = 2e9;
for (int i = 0; i <= k; i++) {
chkmin(ans, dp[n][i]);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[1000], y[2000];
int main() {
int n, k, p;
scanf("%d%d%d", &n, &k, &p);
for (int i = 0; i < (int)(n); ++i) scanf("%d", x + i);
sort(x, x + n);
for (int i = 0; i < (int)(k); ++i) scanf("%d", y + i);
sort(y, y + k);
int an = 2e9;
for (int i = 0; i < (int)(k - n + 1); ++i) {
int a = 0;
for (int j = 0; j < (int)(n); ++j)
a = max(a, abs(p - y[i + j]) + abs(y[i + j] - x[j]));
an = min(an, a);
}
printf("%d\n", an);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long int INF = 1e14;
void Compute(long long int n, long long int k, long long int p) {
vector<long long int> ar(n), br(k);
vector<vector<long long int> > dp(n + 1, vector<long long int>(k + 1));
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());
for (long long int i = 0; i < n; i++) {
dp[i][k] = INF;
}
for (long long int j = 0; j < k + 1; j++) {
long long int mn = INF;
for (long long int itr = j; itr < k; itr++) {
long long int tmp = llabs(ar[n - 1] - br[j]) + llabs(br[j] - p);
mn = min(mn, tmp);
}
dp[n - 1][j] = mn;
}
for (long long int i = n - 2; i >= 0; i--) {
for (long long int j = k - 1; j >= 0; j--) {
dp[i][j] = min(dp[i][j + 1], max(dp[i + 1][j + 1], llabs(ar[i] - br[j]) +
llabs(p - br[j])));
}
}
cout << dp[0][0] << "\n";
}
int main() {
long long int n, k, p;
cin >> n >> k >> p;
Compute(n, k, p);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << '{';
for (int i = (0), __i = (((int)(vec).size())); i < __i; i++) {
os << vec[i];
if (i + 1 != ((int)(vec).size())) os << ',';
}
os << '}';
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &par) {
os << '(' << par.first << ',' << par.second << ')';
return os;
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
template <class T>
T sqr(T x) {
return x * x;
}
long long a[1010];
long long b[2020];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k, p;
cin >> n >> k >> p;
for (int i = (0), __i = (n); i < __i; i++) cin >> a[i];
for (int i = (0), __i = (k); i < __i; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
for (int i = (0), __i = (n); i < __i; i++) a[i] -= p;
for (int i = (0), __i = (k); i < __i; i++) b[i] -= p;
long long res = 1LL << 50;
for (int i = (0), __i = (k - n + 1); i < __i; i++) {
long long cur = 0;
for (int j = (0), __j = (n); j < __j; j++) {
if (a[j] * b[i + j] < 0)
cur = max(cur, 2 * abs(b[i + j]) + abs(a[j]));
else if (abs(a[j]) < abs(b[i + j]))
cur = max(cur, 2 * abs(b[i + j]) - abs(a[j]));
else
cur = max(cur, abs(a[j]));
}
res = min(res, cur);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1005];
long long key[2005];
long long dp[1005][2005];
int main() {
int n, k, p;
while (cin >> n >> k >> p) {
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
for (int j = 1; j <= k; ++j) {
scanf("%d", key + j);
}
sort(a + 1, a + 1 + n);
sort(key + 1, key + k + 1);
memset(dp, 0xf, sizeof(dp));
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] - key[j]) + abs(key[j] - p)));
}
}
printf("%lld\n", dp[n][k]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int man[1010], key[2010];
int n, k, p;
int query(int x) {
int vis = -1;
for (int i = 0; i < n; i++) {
while (vis < k) {
vis++;
if (abs(man[i] - key[vis]) + abs(key[vis] - p) <= x) break;
}
if (vis >= k) return 0;
}
return 1;
}
int main() {
while (scanf("%d%d%d", &n, &k, &p) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", &man[i]);
for (int i = 0; i < k; i++) scanf("%d", &key[i]);
sort(man, man + n);
sort(key, key + k);
long long l = 0, r = 2e9, ans = 0;
while (l <= r) {
int mid = (l + r) / 2;
if (query(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
const long long int inf = 1e18;
const long long int mod = 1e9 + 7;
const long long int MOD = 998244353;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug &operator<<(const c &) {
return *this;
}
};
vector<char *> tokenizer(const char *args) {
char *token = new char[111];
strcpy(token, args);
token = strtok(token, ", ");
vector<char *> v({token});
while ((token = strtok(NULL, ", "))) v.push_back(token);
return reverse(v.begin(), v.end()), v;
}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
void debugg(vector<char *> args) { cerr << "\b\b "; }
#pragma clang diagnostic pop
template <typename Head, typename... Tail>
void debugg(vector<char *> args, Head H, Tail... T) {
debug() << " [" << args.back() << ": " << H << "] ";
args.pop_back();
debugg(args, T...);
}
template <typename T>
T power(T a, T b) {
if (b == 0) return 1;
if (b == 1)
return a;
else {
T res = (power(a, b / 2));
if (b % 2) {
return (res * res * a);
} else {
return res * res;
}
}
}
template <typename T>
T power(T a, T b, T modulo) {
if (b == 0) return 1;
if (b == 1)
return a;
else {
T res = (power(a, b / 2, modulo) % modulo);
if (b % 2) {
return ((((res % modulo) * (res % modulo)) % modulo) * (a % modulo)) %
modulo;
} else {
return ((res % modulo) * (res % modulo)) % modulo;
}
}
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
template <typename T>
T gcd_extended(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T x1, y1;
T d = gcd_extended(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
bool find_solution(long long int a, long long int b, long long int c,
long long int &x, long long int &y) {
long long int g = gcd_extended<long long int>(a, b, x, y);
if (c % g) {
return false;
}
x = x * (c / g);
y = y * (c / g);
if (a < 0) x *= (-1);
if (b < 0) y *= (-1);
return true;
}
void factorial(vector<long long int> &fact, long long int n) {
fact.resize(n + 1, 1);
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i <= n; ++i) {
fact[i] = ((fact[i - 1] % mod) * (i % mod)) % mod;
}
}
long long int mod_inv(long long int a) {
return (power<long long int>(a, mod - 2, mod)) % mod;
}
long long int ncr(long long int n, long long int r,
vector<long long int> &fact) {
if (r > n or n < 0 or r < 0) return 0LL;
return (((fact[n] % mod) * (mod_inv(fact[n - r]) % mod)) % mod *
(mod_inv(fact[r]) % mod)) %
mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long int n, k, p;
cin >> n >> k >> p;
vector<long long int> person(n + 1);
for (auto i = 1; i <= n; i++) {
cin >> person[i];
};
vector<long long int> key(k + 1);
for (auto i = 1; i <= k; i++) {
cin >> key[i];
};
sort((key).begin(), (key).end());
sort((person).begin(), (person).end());
long long int ans = inf;
for (long long int i = 0; i < k - n + 1; ++i) {
long long int mx = 0;
for (long long int j = 1; j <= n; ++j) {
long long int x = 0;
if ((person[j] <= p and person[j] <= key[i + j] and key[i + j] <= p) or
(person[j] >= p and person[j] >= key[i + j] and key[i + j] >= p)) {
x = max(abs(person[j] - p), abs(person[j] - key[i + j]));
} else {
x = abs(person[j] - key[i + j]) + abs(p - key[i + j]);
}
{};
mx = max(mx, x);
}
ans = min(ans, mx);
}
cout << ((ans)) << "\n";
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = double;
using pll = pair<ll, ll>;
using vll = vector<ll>;
using vpll = vector<pll>;
using vvll = vector<vll>;
using vi = vector<int>;
struct d_ {
template <class T>
d_& operator,(const T& x) {
cerr << ' ' << x;
return *this;
}
template <class T>
d_& operator,(const vector<T>& x) {
for (auto& a : x) cerr << ' ' << a;
return *this;
}
} d_t;
ll n, K, p, ppl[1000], key[2000];
int t = (1000 + 2000 + 1) - 1, D[(1000 + 2000 + 1)], P[(1000 + 2000 + 1)], N;
vi G[(1000 + 2000 + 1)];
void add_edge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
bool bfs() {
queue<int> Q;
for (decltype(N) i = 0; i < N; ++i)
if (P[i] == t)
D[i] = 0, Q.push(i);
else
D[i] = (1 << 30);
D[t] = (1 << 30);
while (Q.size()) {
int v = Q.front();
Q.pop();
if (D[v] < D[t])
for (auto w : G[v])
if (D[P[w]] == (1 << 30)) D[P[w]] = D[v] + 1, Q.push(P[w]);
}
return D[t] != (1 << 30);
}
bool dfs(int v) {
if (v != t) {
for (auto w : G[v])
if (D[P[w]] == D[v] + 1 && dfs(P[w])) return P[w] = v, P[v] = w, true;
D[v] = (1 << 30);
return false;
}
return true;
}
int hopcroft_karp() {
for (decltype((1000 + 2000 + 1)) i = 0; i < (1000 + 2000 + 1); ++i) P[i] = t;
int res = 0;
while (bfs())
for (decltype(N) i = 0; i < N; ++i)
if (P[i] == t && dfs(i)) ++res;
return res;
}
ll dist(ll a, ll b) { return abs(a - b); }
bool can(ll maxt) {
for (decltype((1000 + 2000 + 1)) i = 0; i < (1000 + 2000 + 1); ++i)
G[i].clear();
N = n;
for (decltype(n) i = 0; i < n; ++i)
for (decltype(K) j = 0; j < K; ++j)
if (dist(ppl[i], key[j]) + dist(key[j], p) <= maxt) add_edge(i, n + j);
auto flow = hopcroft_karp();
return flow == n;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> K >> p;
for (decltype(n) i = 0; i < n; ++i) cin >> ppl[i];
for (decltype(K) i = 0; i < K; ++i) cin >> key[i];
ll l = 0, r = (ll)(2e9 + 7);
while (l < r) {
ll m = (l + r) / 2;
if (can(m))
r = m;
else
l = m + 1;
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long getnum() {
char c = getchar();
long long num, sign = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') sign = -1;
for (num = 0; c >= '0' && c <= '9';) {
c -= '0';
num = num * 10 + c;
c = getchar();
}
return num * sign;
}
int A[2003];
int B[2003];
int main() {
int n = getnum(), k = getnum(), p = getnum(), ans = INT_MAX;
for (int i = 1; i <= n; i++) A[i] = getnum();
for (int i = 1; i <= k; i++) B[i] = getnum();
sort(A + 1, A + n + 1);
sort(B + 1, B + k + 1);
for (int i = 1; i <= k - n + 1; i++) {
int cur = 0;
for (int j = 1; j <= n; j++)
cur = max(cur, abs(A[j] - B[j + i - 1]) + abs(p - B[j + i - 1]));
ans = min(ans, cur);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long abso(long long x) {
if (x < 0) return -x;
return x;
}
long long key[2003], v[2003];
const long long inf = 20e13 + 5;
int main() {
long long n, k, pb;
cin >> n >> k >> pb;
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
for (int i = 1; i <= k; i++) {
cin >> key[i];
}
long long sol = inf;
sort(v + 1, v + 1 + n);
sort(key + 1, key + 1 + k);
for (int i = 1; i <= k - n + 1; i++) {
long long sol1 = 0;
for (int j = 1; j <= n; j++) {
long long p = abso(v[j] - key[i + j - 1]) + abso(key[i + j - 1] - pb);
sol1 = max(sol1, p);
if (j == n) {
sol = min(sol1, sol);
}
}
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) { return a < b; }
int dp[1005][2005];
int a[1005], b[2005];
int main() {
int n, k, p;
while (scanf("%d %d %d", &n, &k, &p) != EOF) {
memset(dp, 0, sizeof(dp));
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, cmp);
sort(b + 1, b + k + 1, cmp);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= k; j++) {
if (j == i)
dp[i][j] = max(dp[i - 1][j - 1], abs(a[i] - b[j]) + abs(b[j] - p));
else
dp[i][j] = min(dp[i][j - 1], max(dp[i - 1][j - 1],
abs(a[i] - b[j]) + abs(b[j] - p)));
}
}
int ans = 2000000000;
for (int i = n; i <= k; i++) {
ans = min(ans, dp[n][i]);
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
void rset();
void init_test();
void solve();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed;
cout.precision(20);
init_test();
return 0;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
template <typename T>
void MACRO_rdv2_Init(int n, T& t) {
t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_rdv2_Init(int n, First& first, Rest&... rest) {
first.resize(n);
MACRO_rdv2_Init(n, rest...);
}
template <typename T>
void MACRO_rdv2_Scan(int p, T& t) {
std::cin >> t[p];
}
template <typename First, typename... Rest>
void MACRO_rdv2_Scan(int p, First& first, Rest&... rest) {
std::cin >> first[p];
MACRO_rdv2_Scan(p, rest...);
}
template <typename T>
void wrv(const vector<T>& v) {
for (int(__ii) = (0); (__ii) < (((int)v.size())); ++(__ii)) {
if (__ii) cout << ' ';
cout << v[__ii];
}
cout << '\n';
}
template <typename T>
void wrm(const vector<vector<T>>& v) {
for (int(__ii) = (0); (__ii) < (((int)v.size())); ++(__ii)) {
for (int(__jj) = (0); (__jj) < (v[__ii].size()); ++(__jj)) {
if (__jj) cout << ' ';
cout << v[__ii][__jj];
}
cout << '\n';
}
}
template <typename T>
void sc(T& x) {
cin >> x;
}
template <typename Head, typename... Tail>
void sc(Head& head, Tail&... tail) {
cin >> head;
sc(tail...);
}
template <typename T>
void wr(const T& x) {
cout << x << '\n';
}
template <typename Head, typename... Tail>
void wr(const Head& head, const Tail&... tail) {
cout << head << ' ';
wr(tail...);
}
template <typename T>
void wrf(const T& x) {
cout << x << endl;
}
template <typename Head, typename... Tail>
void wrf(const Head& head, const Tail&... tail) {
cout << head << ' ';
wrf(tail...);
}
template <typename T>
void debug_out(const T& x) {
cerr << x << '\n';
}
template <typename Head, typename... Tail>
void debug_out(const Head& head, const Tail&... tail) {
cerr << head << ' ';
debug_out(tail...);
}
template <typename... T>
void err(const T&... cod) {
wr(cod...);
exit(0);
}
const int N = 2020;
int n, k, p;
int a[N], b[N];
bool can(long long x) {
int j = 0;
for (int(i) = (0); (i) < (n); ++(i)) {
while (j < k && abs(a[i] - b[j]) + abs(b[j] - p) > x) ++j;
if (j == k) return false;
++j;
}
return true;
}
void solve() {
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 low = -1, high = 2e18;
while (low + 1 < high) {
long long mid = (low + high) / 2;
if (can(mid))
high = mid;
else
low = mid;
}
wr(high);
}
void init_test() {
int qq = 1;
while (qq--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
cin >> x;
}
template <typename T, typename T0>
void read(T &x, T0 &y) {
cin >> x >> y;
}
template <typename T, typename T0, typename T1>
void read(T &x, T0 &y, T1 &z) {
cin >> x >> y >> z;
}
template <typename T, typename T0, typename T1, typename T2>
void read(T &x, T0 &y, T1 &z, T2 &w) {
cin >> x >> y >> z >> w;
}
template <typename T, typename T0>
void read(pair<T, T0> &p) {
cin >> p.fst >> p.scd;
}
template <typename T>
void read(vector<T> &oneD) {
for (long long int i = 0; i < (int)(oneD).size(); i++) {
read(oneD[i]);
}
}
template <typename T>
void read(T oneD[], long long int n) {
for (long long int i = 0; i < n; i++) {
read(oneD[i]);
}
}
template <typename T>
void write(T &x) {
cout << x << " ";
}
template <typename T, typename T0>
void write(T &x, T0 &y) {
cout << x << " " << y << "\n";
}
template <typename T, typename T0, typename T1>
void write(T &x, T0 &y, T1 &z) {
cout << x << " " << y << " " << z << "\n";
}
template <typename T, typename T0, typename T1, typename T2>
void write(T &x, T0 &y, T1 &z, T2 &w) {
cout << x << " " << y << " " << z << " " << w << "\n";
}
template <typename T, typename T0>
void write(pair<T, T0> &p) {
write(p.fst);
write(p.scd);
cout << endl;
}
template <typename T>
void write(vector<T> &oneD) {
for (long long int i = 0; i < (int)(oneD).size(); i++) {
write(oneD[i]);
}
cout << endl;
}
template <typename T>
void write(T oneD[], int n) {
for (long long int i = 0; i < n; i++) {
write(oneD[i]);
}
cout << endl;
}
template <typename T, typename T0>
void write(map<T, T0> &mpp) {
for (auto it : mpp) {
write(it.fst);
cout << ": ";
write(it.scd);
cout << "\n";
}
cout << endl;
}
template <typename T>
inline bool umax(T &x, T y) {
return (y > x) ? x = y, true : false;
}
template <typename T>
inline bool umin(T &x, T y) {
return (y < x) ? x = y, true : false;
}
template <class T>
void offset(long long int o, T &x) {
x += o;
}
template <class T>
void offset(long long int o, vector<T> &x) {
for (auto &a : x) offset(o, a);
}
template <class T, size_t S>
void offset(long long int o, array<T, S> &x) {
for (auto &a : x) offset(o, a);
}
inline bool isSquare(long long int x) {
long long int s = sqrt(x);
return (s * s == x);
}
inline bool isPowerOfTwo(long long int x) {
return ((1LL << (long long int)log2(x)) == x);
}
long long int extended_GCD(long long int a, long long int b, long long int &x,
long long int &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long int x1, y1;
long long int gcd = extended_GCD(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return gcd;
}
vector<long long int> prime;
void sieve(long long int N) {
bool isPrime[N + !1];
for (long long int i = 0; i <= N; ++i) {
isPrime[i] = true;
}
isPrime[0] = false;
isPrime[1] = false;
for (long long int i = 2; i * i <= N; ++i) {
if (isPrime[i] == true) {
for (long long int j = i * i; j <= N; j += i) isPrime[j] = false;
}
}
for (long long int i = 2; i <= N; i++) {
if (isPrime[i] == true) {
prime.push_back(i);
}
}
}
long long int minPrime[(int)(1 * 1e6 + 10)];
void factorSieve(long long int n) {
memset(minPrime, 0, sizeof(minPrime));
for (long long int i = 2; i * i <= n; ++i) {
if (minPrime[i] == 0) {
for (long long int j = i * i; j <= n; j += i) {
if (minPrime[j] == 0) {
minPrime[j] = i;
}
}
}
}
for (long long int i = 2; i <= n; ++i) {
if (minPrime[i] == 0) {
minPrime[i] = i;
}
}
}
long long int factorize(long long int n) {
map<long long int, long long int> m;
m.clear();
while (n != 1) {
m[minPrime[n]]++;
n /= minPrime[n];
}
for (auto i : m) {
if (i.second > 1) {
return 0;
}
}
return 1;
}
string to_string(char c) { return string(1, c); }
long long int n, k, p;
vector<long long int> a, b;
long long int check(long long int x) {
long long int l = 0;
for (long long int i = (0); ((1) > 0 ? i < (n) : i > (n)); i += (1)) {
while (l < k && abs(a[i] - b[l]) + abs(b[l] - p) > x) {
l++;
}
if (l == k) return 0;
l++;
}
return 1;
}
void solve() {
read(n, k, p);
a = vector<long long int>(n);
b = vector<long long int>(k);
read(a);
read(b);
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long int l = 0, r = 1e15;
while (l < r) {
long long int mid = (l + r) / 2;
if (check(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
cout << l;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t = 1;
for (long long int i = (0); ((1) > 0 ? i < (t) : i > (t)); i += (1)) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
long long pow(long long a, long long b, long long M) {
long long t = 1;
for (a %= M; b; b >>= 1) {
if (b & 1) t = t * a % M;
a = a * a % M;
}
return t;
}
const int N = 2005;
int n, m, p, a[N], b[N];
int main() {
cin >> n >> m >> p;
for (int i = 1; i <= int(n); i++) scanf("%d", &a[i]);
for (int i = 1; i <= int(m); i++) scanf("%d", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
int ans = 2e9;
for (int i = 1; i <= int(m - n + 1); i++) {
int rem = 0;
for (int j = 1; j <= int(n); j++)
rem = max(rem, abs(a[j] - b[i + j - 1]) + abs(b[i + j - 1] - p));
ans = min(ans, rem);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int k, n;
int long long p;
int long long per[1017], key[2017];
bool solve(int long long mid) {
int l = 0, r = 0;
while (l < n && r < k) {
if (fabs(per[l] - key[r]) + fabs(p - key[r]) <= mid)
l++, r++;
else
r++;
}
if (l == n) return 1;
return 0;
}
int main() {
scanf("%d%d%lld", &n, &k, &p);
for (int i = 0; i < n; i++) scanf("%lld", &per[i]);
for (int j = 0; j < k; j++) scanf("%lld", &key[j]);
sort(per, per + n);
sort(key, key + k);
int long long l = 0, r = 100000000000;
int long long ans;
while (l <= r) {
int long long mid = (l + r) / 2;
if (solve(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[500005], b[500005], n, m, pos;
inline bool check(long long x) {
long long p = 1;
for (long long i = 1; i <= n; i++) {
while (abs(a[i] - b[p]) + abs(pos - b[p]) > x) {
p++;
if (p > m) break;
}
if (abs(a[i] - b[p]) + abs(pos - b[p]) > x) return 0;
if (p > m) return 0;
p++;
}
return 1;
}
signed main() {
scanf("%lld%lld%lld", &n, &m, &pos);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long i = 1; i <= m; i++) scanf("%lld", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
long long l = 0;
long long r = 2e9 + 10;
long long ans = 2e9 + 10;
while (l + 1 < r) {
long long mid = (l + r) >> 1;
if (check(mid))
ans = mid, r = mid;
else
l = mid;
}
if (check(l)) ans = min(ans, l);
if (check(r)) ans = min(ans, r);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1e9 + 7;
long long int INF = 1e18;
long long int sub(long long int a, long long int b, long long int p = MOD) {
return ((a % p) - (b % p) + p) % p;
}
long long int mult(long long int a, long long int b, long long int p = MOD) {
return ((a % p) * (b % p)) % p;
}
long long int add(long long int a, long long int b, long long int p = MOD) {
return (a % p + b % p) % p;
}
long long int fpow(long long int n, long long int k, long long int p = MOD) {
long long int r = 1;
while (k > 0) {
if (k & 1) r = r * n % p;
n = n * n % p;
k = k >> 1;
}
return r;
}
long long int inv(long long int a, long long int p = MOD) {
return fpow(a, p - 2, p);
}
long long int power(long long int a, long long int b) {
long long int ans = 1;
long long int i;
for (i = 1; i < b + 1; i++) {
ans *= a;
}
return ans;
}
long long int fdiv(long long int a, long long int b, long long int p = MOD) {
long long int yinv = inv(b);
long long int ans = (a * yinv) % p;
return ans;
}
unsigned long long int I1018 = 1000000000000000000;
const unsigned long long int I10e5 = 100000;
const long long int I10e6 = 1e6;
template <typename T>
istream &operator>>(istream &in, vector<T> &a) {
for (auto &item : a) {
in >> item;
}
return in;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, pair<T, U> &a) {
cout << a.first << " " << a.second;
return out;
}
template <typename T, typename U>
istream &operator>>(istream &out, pair<T, U> &a) {
cin >> a.first >> a.second;
return out;
}
template <typename T, typename U>
ostream &operator<<(ostream &out, map<T, U> &a) {
for (auto &item : a) {
out << item << endl;
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> &a) {
for (auto &item : a) {
out << item << " ";
}
return out;
}
template <typename T>
ostream &operator<<(ostream &out, vector<vector<T>> &a) {
for (auto &item : a) {
out << item << "\n";
}
return out;
}
std::vector<bool> is_prime;
std::vector<long long int> primes;
void sieve(long long int n) {
is_prime.resize(n + 2, true);
primes.clear();
long long int p;
for (p = 2; p * p <= n; p++) {
if (is_prime[p]) {
long long int i;
for (i = p * p; i <= n; i += p) {
is_prime[i] = false;
}
}
}
is_prime[0] = is_prime[1] = false;
long long int i;
for (i = 2; i <= n; i++) {
if (is_prime[i]) {
primes.emplace_back(i);
}
}
}
map<long long int, long long int> prime_factors(long long int n) {
map<long long int, long long int> s;
long long int i;
long long int tc = 0;
while (n % 2 == 0) {
tc++;
n /= 2;
}
if (tc > 0) {
s[2] = tc;
}
for (i = 3; i <= sqrt(n); i += 2) {
tc = 0;
while (n % i == 0) {
tc++;
n /= i;
}
if (tc > 0) {
s[i] = tc;
}
}
if (n > 2) {
s[n] += 1;
}
return s;
}
std::vector<long long int> fact_vec;
void fact_fun(long long int n) {
fact_vec.resize(n + 10);
long long int i;
fact_vec[0] = 1;
for (i = 1; i <= n + 2; i++) {
fact_vec[i] = (fact_vec[i - 1] * i) % MOD;
}
}
long long int npr(long long int n, long long int r) {
long long int ans = fact_vec[n];
ans /= fact_vec[n - r];
return ans;
}
long long int ncr(long long int n, long long int r) {
long long int ans = fact_vec[n];
ans = fdiv(ans, fact_vec[n - r]);
ans = fdiv(ans, fact_vec[r]);
return ans;
}
long long int nc2(long long int n) { return (n * (n - 1)) / 2; }
int main() {
long long int i, j;
ios::sync_with_stdio(false);
cin.tie(0);
long long int n, m, p;
cin >> n >> m >> p;
std::vector<long long int> a(n), b(m);
cin >> a >> b;
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
long long int start = 0, end = 1e12;
long long int ans = 0;
auto check = [&](long long int mid) {
long long int i;
j = 0;
for (i = 0; i < m; i++) {
if (abs(a[j] - b[i]) + abs(b[i] - p) <= mid) {
j++;
if (j >= n) {
return true;
}
}
}
return false;
};
while (start < end) {
long long int mid = (start + end) / 2;
if (check(mid)) {
end = mid;
ans = mid;
} else {
start = mid + 1;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NR = 20000;
const int PR = 1e9 + 7;
int n, k;
long long p;
int a[NR + 1], b[NR + 1];
bool check(long long x) {
int r = 1;
for (int i = 1; i <= n; i++) {
while (r <= k && abs(b[r] - a[i]) + abs(b[r] - p) > x) r++;
if (r >= k + 1) return false;
r++;
}
return true;
}
int main() {
scanf("%d%d%lld", &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 = 4e9, ans = 0;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid - 1, ans = mid;
else
l = mid + 1;
}
printf("%lld\n", ans);
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(solve(index1, index2 + 1),
max(solve(index1 + 1, index2 + 1),
abs(a[index1] - b[index2]) + abs(b[index2] - p)));
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, -1, sizeof dp);
cout << solve(0, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const long long linf = 4000000000000000000LL;
const long long inf = 1000000007;
const long double pi = 3.1415926535;
void pv(vector<int> a) {
for (auto& x : a) cout << x << " ";
cout << '\n';
}
void pv(vector<long long> a) {
for (auto& x : a) cout << x << " ";
cout << '\n';
}
void pv(vector<vector<int>> a) {
for (int i = (0); i < (int(a.size())); ++i) {
cout << i << '\n';
pv(a[i]);
cout << '\n';
}
}
void pv(vector<vector<long long>> a) {
for (int i = (0); i < (int(a.size())); ++i) {
cout << i << '\n';
pv(a[i]);
}
cout << '\n';
}
void pv(vector<string> a) {
for (auto& x : a) cout << x << '\n';
cout << '\n';
}
void build_primes(vector<int>& primes, int size) {
vector<int> visited;
visited.resize(size, 0);
for (int i = (2); i < (size); ++i) {
if (visited[i] == 0) {
primes.push_back(i);
int a = i;
while (a < size) {
visited[a] = 1;
a += i;
}
}
}
}
vector<vector<long long>> matrix_mult(vector<vector<long long>>& a,
vector<vector<long long>>& b) {
int n = a.size();
vector<vector<long long>> answer;
answer.resize(n);
for (int i = 0; i < n; i++) answer[i].resize(n, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++)
answer[i][j] = (answer[i][j] + a[i][k] * b[k][j]) % inf;
}
}
return answer;
}
int modInverse(int a, int m) {
int m0 = m;
int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
int q = a / m;
int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long power(long long x, long long y) {
long long k = 1LL << 60;
long long z = 1;
while (k != 0) {
z *= z;
z %= inf;
if (y >= k) {
z *= x;
z %= inf;
y -= k;
}
k >>= 1;
}
return z;
}
struct point {
long double x, y;
bool operator<(const point& rhs) const {
if (x == rhs.x) return y < rhs.y;
return x < rhs.x;
}
};
struct pt {
long long x, y;
bool operator<(const pt& rhs) const {
if (x == rhs.x) return y < rhs.y;
return x < rhs.x;
}
};
long double area(point x, point y, point z) {
return (x.y * y.x + y.y * z.x + z.y * x.x - x.x * y.y - y.x * z.y -
z.x * x.y) /
2.0;
}
bool clockwise(point x, point y, point z) { return area(x, y, z) > 0; }
long double area(pt x, pt y, pt z) {
return (x.y * y.x + y.y * z.x + z.y * x.x - x.x * y.y - y.x * z.y -
z.x * x.y) /
2.0;
}
bool clockwise(pt x, pt y, pt z) { return area(x, y, z) > 0; }
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(a, b % a);
}
int popcount(long long a) {
int count = 0;
while (a) {
count += (a & 1);
a >>= 1;
}
return count;
}
long long choose(long long n, long long r) {
long long p = 1, k = 1;
if (n - r < r) r = n - r;
if (r != 0) {
while (r) {
p *= n;
k *= r;
long long m = gcd(p, k);
p /= m;
k /= m;
n--;
r--;
}
} else
p = 1;
return p;
}
vector<long long> prefix_hash(string& a, vector<long long>& powers,
long long mod) {
int n = int(a.size());
vector<long long> prefix(n + 1);
for (int i = (0); i < (n); ++i)
prefix[i + 1] = (prefix[i] + powers[i] * (a[i] - '1' + 1)) % mod;
return prefix;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
uint64_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
struct custom_hash_fast {
uint64_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
x ^= FIXED_RANDOM;
return x ^ (x >> 16);
}
};
void setIO(string second) {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (int(second.size())) {
freopen((second + ".in").c_str(), "r", stdin);
if (second != "test3") freopen((second + ".out").c_str(), "w", stdout);
}
}
int n, k;
long long p;
vector<long long> a, b;
long long ans = linf;
void solve() {
long long sum = 0;
for (int i = (0); i < (n); ++i) {
sum = max(sum, abs(a[i] - b[i]) + abs(p - b[i]));
}
ans = min(ans, sum);
}
int main() {
setIO("");
cin >> n >> k >> p;
a.resize(n);
for (auto& x : a) cin >> x;
vector<long long> c(k);
for (auto& x : c) cin >> x;
sort(a.begin(), a.end());
sort(c.begin(), c.end());
for (int i = (0); i < (n); ++i) b.push_back(c[i]);
for (int i = (0); i < (k - n); ++i) {
solve();
b.erase(b.begin());
b.push_back(c[i + n]);
}
solve();
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Inf = 1e9 + 7;
namespace myspace {
const int N = 1007;
int n, keys, office_pos;
int a[N], b[2 * N];
void solve() {
cin >> n >> keys >> office_pos;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < keys; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + keys);
int res = 2e9 + 7;
for (int s = 0; s + n - 1 < keys; s++) {
int tmax = 0;
for (int i = 0; i < n; i++) {
int t = abs(a[i] - b[s + i]) + abs(b[s + i] - office_pos);
tmax = max(tmax, t);
}
res = min(res, tmax);
}
cout << res << '\n';
}
}; // namespace myspace
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(9);
cout << fixed;
myspace::solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, p, k;
cin >> n >> m >> p;
int i, j, b[m + 5], v[m + 5], a[n + 5];
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (i = 1; i <= m; i++) cin >> b[i];
sort(b + 1, b + 1 + m);
long long int t = 0, w = 2000000000, mid, f, ff;
while (t < w) {
mid = (t + w) / 2;
ff = 0;
k = 1;
for (i = 1; i <= n; i++) {
f = 0;
for (j = k; j <= m; j++) {
if (abs(a[i] - b[j]) + abs(b[j] - p) <= mid) {
f = 1;
break;
}
}
if (f == 0) {
ff = 1;
break;
} else {
k = j + 1;
}
}
if (ff == 0)
w = mid;
else
t = mid + 1;
}
cout << t << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long spf[2100000];
long long fac[2100000];
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 2100000; i++) spf[i] = i;
for (long long i = 4; i < 2100000; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 2100000; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 2100000; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
map<long long, long long> getfactor(long long a) {
map<long long, long long> m;
while (a > 1) {
m[spf[a]]++;
a /= spf[a];
}
return m;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long inverse(long long a, long long p) { return power(a, p - 2, p); }
long long ncr(long long n, long long r, long long p) {
if (r == 0) return 1;
return (fac[n] * inverse(fac[r], p) % p * inverse(fac[n - r], p) % p) % p;
}
void solve() {
long long n, k, p;
cin >> n >> k >> p;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long b[k];
for (long long i = 0; i < k; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + k);
long long mini = 1e18;
for (long long i = 0; i < k; i++) {
long long temp = i, maxi = 0;
for (long long j = 0; j < n; j++) {
maxi = max(abs(b[temp] - a[j]) + abs(b[temp] - p), maxi);
temp++;
if (temp == k) temp = 0;
}
mini = min(mini, maxi);
}
cout << mini << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, q;
while (~scanf("%d%d%d", &n, &m, &q)) {
int i, j, l, k, a[5050], b[5050];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < m; i++) scanf("%d", &b[i]);
sort(a, a + n);
sort(b, b + m);
int ans = 0x7fffffff;
for (i = 0; i <= m - n; i++) {
int ma = 0;
for (j = 0; j < n; j++) {
ma = max(ma, abs(a[j] - b[i + j]) + abs(b[i + j] - q));
}
ans = min(ans, ma);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void _print(T x, bool end_line = 1, bool bracket = 0) {
if (bracket) cout << "{ ";
cout << x;
if (bracket) cout << " }";
if (end_line) cout << '\n';
}
void _print(string x, bool end_line = 1, bool bracket = 0) {
if (bracket) cout << "{ ";
cout << "\"";
cout << x;
cout << "\"";
if (bracket) cout << " }";
if (end_line) cout << '\n';
}
void _print(char x, bool end_line = 1, bool bracket = 0) {
if (bracket) cout << "{ ";
cout << "\'";
cout << x;
cout << "\'";
if (bracket) cout << " }";
if (end_line) cout << '\n';
}
template <typename T>
void _print(set<T> &s, bool end_line = 1) {
cout << "{ ";
for (auto ele : s) {
_print(ele, 0);
cout << " ,";
}
cout << "}";
if (end_line) cout << "\n";
}
template <typename T>
void _print(multiset<T> &s, bool end_line = 1) {
cout << "{ ";
for (auto ele : s) {
_print(ele, 0);
cout << " ,";
}
cout << "}";
if (end_line) cout << "\n";
}
template <typename T, typename S>
void _print(pair<T, S> &p, bool end_line = 1) {
cout << "{ ";
_print(p.first, 0);
cout << " , ";
_print(p.second, 0);
cout << " }";
if (end_line) cout << "\n";
}
template <typename T>
void _print(vector<T> &A, bool end_line = 1) {
cout << "{ ";
for (auto ele : A) {
_print(ele, false);
cout << " ,";
}
cout << "}";
if (end_line) cout << '\n';
}
template <typename T>
void _print(vector<vector<T>> &A) {
if (A.size()) {
_print(A[0]);
}
for (long long i = 1; i < A.size(); i++) {
if (i == (long long)A.size() - 1) {
cout << " ";
_print(A[i]);
} else {
cout << " ";
_print(A[i]);
}
}
}
template <typename T, typename S>
void _print(map<T, S> &mp) {
cout << '\n';
for (auto ele : mp) {
_print(ele.first, 0);
cout << " -> ";
_print(ele.second);
}
}
template <typename T, typename S>
void _print(unordered_map<T, S> &mp) {
cout << '\n';
for (auto ele : mp) {
_print(ele.first, 0);
cout << " -> ";
_print(ele.second);
}
}
long long power(long long x, long long y, long long p = (long long)1e9 + 7) {
long long res = 1LL;
x = x % p;
while (y > 0) {
if (y & 1) res = (1LL * res * x) % p;
y >>= 1;
x = (x * x) % p;
}
return res;
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
long long p = sqrt(n);
for (long long i = 5; i <= p; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long gcdExtended(long long a, long long b, long long *x, long long *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long x1, y1;
long long gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long modInverse(long long b, long long m = (long long)1e9 + 7) {
long long x, y;
long long g = gcdExtended(b, m, &x, &y);
if (g != 1) return -1;
return (x % m + m) % m;
}
long long mod_sum(long long a, long long b, long long M = (long long)1e9 + 7) {
return ((a + b) % M + M) % M;
}
long long mod_mul(long long a, long long b, long long M = (long long)1e9 + 7) {
return ((1LL * a * b) % M + M) % M;
;
}
long long mod_diff(long long a, long long b, long long M = (long long)1e9 + 7) {
return ((a - b) % M + M) % M;
}
void inp(vector<long long> &A, long long idx = 0) {
for (long long i = idx; i < A.size(); i++) cin >> A[i];
}
void to_binary(long long n, long long dig = 6) {
string ans = "";
long long orig = n;
while (n > 0) {
ans += (char)((n & 1) + '0');
n >>= 1;
}
while (ans.size() < dig) {
ans += '0';
}
reverse(ans.begin(), ans.end());
cout << orig << ": " << ans << '\n';
}
long long max_n = 2e5 + 1;
vector<long long> seive(max_n + 20, 1);
void make_seive(long long max_n) {
seive[0] = 0;
seive[1] = 0;
for (long long i = 2; i <= max_n; i++) {
if (seive[i])
for (long long j = i * i; j <= max_n; j += i) seive[j] = 0;
}
}
long long max_N = 2e5 + 1;
vector<long long> min_prime(max_n, 0);
void make_min_prime(long long max_N) {
for (long long i = 2; i <= max_N; i++) {
if (seive[i])
for (long long j = i; j <= max_N; j += i) min_prime[j] = i;
}
}
inline void solve() {
long long n;
cin >> n;
long long k, loc;
cin >> k >> loc;
long long inf = 1e15;
vector<long long> A(n), B(k);
inp(A);
inp(B);
sort(A.begin(), A.end());
sort(B.begin(), B.end());
vector<long long> time(k);
vector<vector<long long>> dp(n, vector<long long>(k));
for (long long i = 0; i < k; i++) time[i] = abs(loc - B[i]);
for (long long i = 0; i < n; i++) {
for (long long j = i; j < k; j++) {
dp[i][j] =
min(abs(A[i] - B[j]) + time[j], (j - 1 >= i ? dp[i][j - 1] : inf));
dp[i][j] = max(dp[i][j], (i - 1 >= 0 ? dp[i - 1][j - 1] : 0));
}
}
cout << dp[n - 1][k - 1] << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << setprecision(12) << fixed;
long long t = 1;
for (long long i = 1; i <= t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e17;
const int N = 2001;
long long a[N], b[N];
long long n, k, p;
bool check(long long x) {
int j = 1;
for (int i = 1; i < n + 1; ++i) {
if (j > k) return 0;
while (abs(p - b[j]) + abs(a[i] - b[j]) > x) {
++j;
if (j > k) return 0;
}
++j;
}
return 1;
}
void solve() {
cin >> n >> k >> p;
for (int i = 1; i < n + 1; ++i) cin >> a[i];
for (int i = 1; i < k + 1; ++i) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long l = 0;
long long r = 1e18;
while (r - l > 1) {
long long m = (l + r) >> 1;
if (check(m))
r = m;
else
l = m;
}
cout << (check(l) ? l : r);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
const int M = (int)1e6 + 10;
const long long LINF = (long long)2e18;
const int INF = (int)1e9 + 7;
const double EPS = (double)1e-9;
const double PI = 3.14159265359;
int n, k, p;
int a[N], b[N];
bool ok(int lim) {
for (int i = 1, l = 1; i <= n; i++) {
while (l <= k && abs(a[i] - b[l]) + abs(b[l] - p) > lim) l++;
if (l <= k && abs(a[i] - b[l]) + abs(b[l] - p) <= lim) {
++l;
} else {
return false;
}
}
return true;
}
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];
}
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
int l = 0, r = 2e9 + 10;
int ans;
while (l <= r) {
int mid = (l + 0ll + r) / 2;
if (ok(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, p;
cin >> n >> k >> p;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> b(k);
for (int i = 0; i < k; i++) {
cin >> b[i];
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
vector<int> left_keys, right_keys;
int best = numeric_limits<int>::max();
for (int i = 0; i + n <= k; i++) {
int ma = 0;
for (int per = 0; per < n; per++) {
int pp = a[per];
int pk = b[i + per];
if (pp <= pk && pk <= p)
ma = max(ma, p - pp);
else if (pk <= pp && pp <= p)
ma = max(ma, p - pk + pp - pk);
else if (p <= pk && pk <= pp)
ma = max(ma, pp - p);
else if (pp <= p && p <= pk)
ma = max(ma, pk - pp + pk - p);
else if (p <= pp && pp <= pk)
ma = max(ma, pk - pp + pk - p);
else if (pk <= p && p <= pp)
ma = max(ma, pp - pk + p - pk);
}
best = min(best, ma);
}
cout << best << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double sn = 1e-6;
int n, k, p;
long long res = LLONG_MAX;
int arrn[1005];
int arrk[2005];
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 0; i < n; i++) scanf("%d", &arrn[i]);
sort(arrn, arrn + n);
for (int i = 0; i < k; i++) scanf("%d", &arrk[i]);
sort(arrk, arrk + k);
for (int i = 0; i <= k - n; i++) {
long long t = 0;
for (int j = i; j < n + i; j++) {
t = max((long long)abs(arrk[j] - arrn[j - i]) + abs(arrk[j] - p), t);
}
res = min(res, t);
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[2005], b[2005], c[2005];
long long dp[2005][2005];
int main() {
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(1 + a, 1 + n + a);
sort(1 + b, 1 + k + b);
memset(dp, -0xff, sizeof(dp));
for (long long i = 0; i <= k; i++) dp[0][i] = 0;
for (long long i = 1; i <= n; i++)
for (long long 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];
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1005;
const int maxm = 2005;
int a[maxn], b[maxm], n, k, p;
bool check(int now) {
int pos, i;
for (i = 1, pos = 0; i <= n; i++) {
while (pos <= k) {
pos++;
if (abs(a[i] - b[pos]) + abs(b[pos] - p) <= now) break;
}
if (pos > k) return false;
}
return true;
}
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 l = 0, r = 2e9, mid;
while (l < r) {
mid = (int)(((long long)l + r) >> 1);
if (check(mid))
r = mid;
else
l = mid + 1;
}
printf("%d\n", l);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
const int N = 5e6 + 100;
const int MAX = 1e9 + 1;
int n, k, p;
int a[N], b[N];
int main() {
int i, j;
scanf("%d%d%d", &n, &k, &p);
for (i = 0; i < n; ++i) scanf("%d", a + i);
for (i = 0; i < k; ++i) scanf("%d", b + i);
sort(a, a + n);
sort(b, b + k);
int ans = 2e9;
for (i = 0; i <= k - n; ++i) {
int row = 0;
for (j = 0; j < n; ++j) {
row = max(row, abs(a[j] - b[i + j]) + abs(b[i + j] - p));
}
ans = min(ans, row);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 1e9;
int n, k, p;
const int N = 2005;
int a[N], b[N];
bitset<N> used;
bool f(int m) {
used.reset();
for (int i = 1; i <= n; i++) {
int mini = inf;
for (int j = 1; j <= k; j++) {
if (!used[j] && abs(a[i] - b[j]) + abs(b[j] - p) <= m)
mini = min(mini, j);
}
if (mini == inf) return 0;
used[mini] = 1;
}
return 1;
}
vector<int> v;
void gettest() {
n = 1000, k = 2000, p = 1 + rand() % 1000000000;
freopen("inp.txt", "w", stdout);
printf("%d %d %d\n", n, k, p);
for (int i = 1; i <= n; i++) printf("%d ", 1 + rand() % 1000000000);
for (int i = 1; i <= k; i++) printf("%d ", 1 + rand() % 1000000000);
fclose(stdout);
}
signed 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 = 1; j <= k; j++) {
v.emplace_back(abs(a[i] - b[j]) + abs(b[j] - p));
}
}
v.emplace_back(-1);
sort(v.begin(), v.end());
v.erase(unique((v).begin(), (v).end()), v.end());
int l = 0, r = v.size() - 1;
while (r - l > 1) {
int m = (l + r) >> 1;
if (f(v[m]))
r = m;
else
l = m;
}
printf("%d", v[r]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
int n, k, p, a[1005], b[2005], d[1005][2005];
bool used[2005];
vector<pair<int, int> > g[3005];
bool check(int x) {
for (int i = 0, j = 0; i < k; i++) {
if (abs(a[j] - b[i]) + abs(p - b[i]) <= x) j++;
if (j == n) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.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);
int lb = -1, ub = 2 * 1000000007;
while (ub - lb > 1) {
int mid = (lb + 1ll * ub) >> 1;
if (check(mid))
ub = mid;
else
lb = mid;
}
cout << ub << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, M = 2005;
int a[N], b[M];
int main() {
ios::sync_with_stdio(false);
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 + n + 1);
sort(b + 1, b + k + 1);
int ans = 2e9;
for (int i = 0; i <= k - n; i++) {
int t = 0;
for (int j = 1; j <= n; j++)
t = max(t, abs(a[j] - b[i + j]) + abs(p - b[i + j]));
ans = min(ans, t);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 100005;
const long long inf = 1e18;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long n, k, p;
long long a[1002], b[2002], dp[2002][1002];
long long find(long long key, long long person) {
if (person >= n) return 0;
if (key >= k) return inf;
if (dp[key][person] != -1) return dp[key][person];
long long ans = find(key + 1, person);
ans = min(ans, max(find(key + 1, person + 1),
abs(a[person] - b[key]) + abs(p - b[key])));
return dp[key][person] = ans;
}
void solve() {
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);
memset(dp, -1, sizeof dp);
long long ans = find(0, 0);
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long T = 1;
while (T--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long p;
long long a[3100], b[3100];
long long dp[3100][3100];
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);
for (int j = 0; j <= k; j++) dp[0][j] = 0;
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(b[j] - p) + abs(a[i] - b[j]));
else
dp[i][j] = min(dp[i][j - 1],
max(abs(a[i] - b[j]) + abs(b[j] - p), dp[i - 1][j - 1]));
}
}
cout << dp[n][k] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int MAXN = 2004;
const long long oo = 123456789123456;
long long ans, f[MAXN][MAXN];
int n, k, p, a[MAXN], b[MAXN];
long long tinh(long long x, long long y, long long z) {
return (abs(y - x) + abs(z - y));
}
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];
sort(b + 1, b + k + 1);
sort(a + 1, a + n + 1);
f[1][0] = oo;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
if (i > j)
f[i][j] = oo;
else {
f[i][j] = f[i][j - 1];
f[i][j] = min(f[i][j], max(f[i - 1][j - 1], tinh(a[i], b[j], p)));
}
}
}
cout << f[n][k];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 2000;
int n, K, P, a[MaxN + 5], b[MaxN + 5];
int main() {
while (~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 l = 1; l <= K - n + 1; l++) {
int r = l + n - 1;
long long cnt = 0;
for (int i = l; i <= r; i++) {
long long now = abs(b[i] - P) + abs(b[i] - a[i - l + 1]);
cnt = max(cnt, now);
}
ans = min(ans, cnt);
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
int n, m, x;
int a[100007], b[100007];
int abs(int a) { return a > 0 ? a : -a; }
void maxs(int& a, int b) {
if (a < b) a = b;
}
void mins(int& a, int b) {
if (a > b) a = b;
}
int main() {
scanf("%d%d%d", &n, &m, &x);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= m; ++i) scanf("%d", b + i);
std::sort(a + 1, a + n + 1);
std::sort(b + 1, b + m + 1);
int ans = 0x7fffffff;
for (int L = 1, R = n; R <= m; ++L, ++R) {
int mx = 0;
for (int i = 1, j = L; i <= n; ++i, ++j)
maxs(mx, abs(a[i] - b[j]) + abs(b[j] - x));
mins(ans, mx);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 10;
const int K = 2000 + 10;
const long long int INF = 1e16 + 13;
long long int d[N][K], p;
int n, k, a[N];
pair<long long int, long long int> b[K];
int main() {
cin >> n >> k >> p;
for (int i = 0; i < n; ++i) scanf("%d", a + i);
for (int i = 0; i < k; ++i) scanf("%d", &b[i].first);
sort(b, b + k);
for (int i = 0; i < k; ++i) b[i].second = abs(p - b[i].first);
sort(a, a + n);
for (int i = 0; i < N; ++i)
for (int j = 0; j < K; ++j) d[i][j] = INF;
d[0][0] = abs(a[0] - b[0].first) + b[0].second;
for (int i = 1; i < k; ++i)
d[0][i] = min(abs(a[0] - b[i].first) + b[i].second, d[0][i - 1]);
long long int dis;
for (int i = 1; i < n; ++i)
for (int j = i; j < k; ++j) {
dis = abs(a[i] - b[j].first) + b[j].second;
if (max(dis, d[i - 1][j - 1]) < d[i][j - 1]) {
d[i][j] = max(dis, d[i - 1][j - 1]);
continue;
}
d[i][j] = d[i][j - 1];
}
cout << d[n - 1][k - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
using namespace std;
long long int N, K, P, A[5000 + 10], B[5000 + 10], Right[5000 + 10],
Left[5000 + 10], used[5000 + 10];
vector<int> edge[5000 + 10];
void init(long long int M) {
for (long long int i = 0; i < M; i++) {
edge[i].clear();
Right[i] = -1;
Left[i] = -1;
used[i] = 0;
}
}
long long int match(long long int u) {
if (used[u] == 1) return 0;
used[u] = 1;
for (long long int i = 0; i < edge[u].size(); i++) {
long long int v = edge[u][i];
if (Left[v] == -1 || match(Left[v])) {
Left[v] = u;
Right[u] = v;
return 1;
}
}
return 0;
}
long long int BPM(long long int N) {
long long int ans = 0, path = 1;
while (path) {
path = 0;
memset(used, 0, sizeof(used));
for (long long int i = 1; i <= N; i++) {
if (!used[i] && Right[i] == -1) {
path += match(i);
}
}
}
for (long long int i = 1; i <= N; i++)
if (Right[i] != -1) ans++;
return ans;
}
void buildGraph(long long int lim) {
init(N + K + 5);
for (long long int i = 1; i <= N; i++) {
for (long long int j = 1; j <= K; j++) {
long long int val = abs(A[i] - B[j]) + abs(P - B[j]);
if (val <= lim) {
edge[i].push_back(N + j);
}
}
}
}
long long int binSearch() {
long long int lo = 0, hi = 1e12, ret = -1, val, mid;
while (lo <= hi) {
mid = (lo + hi) / 2ll;
buildGraph(mid);
val = BPM(N);
if (val == N) {
ret = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
return ret;
}
int main() {
long long int i, j, l, a, b;
while (scanf("%lld %lld %lld", &N, &K, &P) == 3) {
long long int superSrce = 0, superSink = N + K + 1;
for (i = 1; i <= N; i++) {
scanf("%lld", &A[i]);
}
for (i = 1; i <= K; i++) {
scanf("%lld", &B[i]);
}
long long int ans = binSearch();
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pe[150050];
int key[150050];
int dp[1005][1005];
int main() {
int n, k, p;
scanf("%d%d%d", &n, &k, &p);
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) scanf("%d", &pe[i]);
for (int i = 1; i <= k; i++) scanf("%d", &key[i]);
sort(pe + 1, pe + 1 + n);
sort(key + 1, key + 1 + k);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= k; j++) {
if (i != j)
dp[i][j] =
min(dp[i][j - 1],
max(dp[i - 1][j - 1], abs(p - key[j]) + abs(pe[i] - key[j])));
else
dp[i][j] = max(dp[i - 1][j - 1], abs(p - key[j]) + abs(pe[i] - key[j]));
}
}
int ans = INT_MAX;
for (int i = n; i <= k; i++) ans = min(ans, dp[n][i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e3 + 5;
long long n, k, p;
long long a[N], b[N];
long long cache[N][N];
long long dp(long long i, long long j) {
if (i == n + 1) {
return 0;
}
if (j == k + 1) {
return 1000000000000000000;
}
if (cache[i][j] != -1) {
return cache[i][j];
}
return cache[i][j] = min(dp(i, j + 1), max(abs(a[i] - b[j]) + abs(p - b[j]),
dp(i + 1, j + 1)));
}
void TEST_CASE() {
memset(cache, -1, sizeof(cache));
cin >> n >> k >> p;
for (long long i = 1; i < n + 1; i++) {
cin >> a[i];
}
for (long long i = 1; i < k + 1; i++) {
cin >> b[i];
}
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
cout << dp(1, 1) << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
TEST_CASE();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[2005], b[2005];
long long n, k, p;
int cmp(long long u, long long v) { return u < v; }
struct node {
long long le, ri;
} seg[2005];
int cmp1(node u, node v) { return u.le < v.le; }
int check(long long x) {
int i;
for (i = 0; i < n; i++) {
long long now = fabs(p - a[i]);
if (now > x) return 0;
seg[i].le = min(p, a[i]) - ((x - now) >> 1);
seg[i].ri = max(p, a[i]) + ((x - now) >> 1);
}
sort(seg, seg + n, cmp1);
int now = 0;
for (i = 0; i < n; i++) {
while (!(b[now] >= seg[i].le && b[now] <= seg[i].ri)) {
now++;
if (now >= k) return 0;
}
now++;
}
return 1;
}
int main() {
int i, j, x;
cin >> n >> k >> p;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < k; i++) {
cin >> b[i];
}
sort(b, b + k, cmp);
long long le = 0, ri = 0x3f3f3f3f3f3f3f3f, mid, ans;
while (le <= ri) {
mid = (le + ri) >> 1;
if (check(mid)) {
ans = mid;
ri = mid - 1;
} else
le = mid + 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2005;
const int inf = 2e9 + 5;
int a[maxn], b[maxn], f[maxn][maxn];
int main() {
int n, k, p;
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 <= k; ++i) {
for (int j = 1; j <= min(n, i); ++j) {
if (i - 1 >= j)
f[i][j] = f[i - 1][j];
else
f[i][j] = inf;
f[i][j] =
min(f[i][j], max(f[i - 1][j - 1], abs(a[j] - b[i]) + abs(b[i] - p)));
}
}
printf("%d\n", f[k][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10;
const long long int LINF = 1LL * INF * INF;
const int MAXN = 2e5 + 10;
const int MAXM = 2e3 + 10;
priority_queue<int> pq;
vector<vector<int> > graph;
queue<int> que;
long long int A[MAXM];
long long int B[MAXM];
long long int dp[MAXM][MAXM];
long long int dpmn[MAXM][MAXM];
long long int myabs(long long int p) {
if (p >= 0) return p;
return -p;
}
int main() {
int n, m, k, a, b, x, y;
int sum = 0;
int cnt = 0;
int mx = 0;
int mn = INF;
int cur = 0, idx = -1;
int p;
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);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) dp[i][j] = dpmn[i][j] = LINF;
for (int j = i; j <= k; j++) {
dp[i][j] = max(myabs(A[i] - B[j]) + myabs(B[j] - p), dpmn[i - 1][j - 1]);
dpmn[i][j] = min(dpmn[i][j - 1], dp[i][j]);
}
}
cout << dpmn[n][k];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1005], b[2005];
int n, k, P;
bool chk(int x) {
int p = 1;
for (int i = 1; i <= n; i++) {
while (p <= k && abs(a[i] - b[p]) + abs(P - b[p]) > x) ++p;
if (p > k) return 0;
++p;
}
return 1;
}
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];
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long l = 0, r = 2e9;
long long mid;
while (l < r) {
mid = (l + r) / 2;
if (chk(mid))
r = mid;
else
l = mid + 1;
}
cout << r;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, p;
scanf("%d%d%d", &n, &k, &p);
vector<int> ap(n), bk(k);
for (int &t : ap) scanf("%d", &t);
for (int &t : bk) scanf("%d", &t);
sort(ap.begin(), ap.end());
sort(bk.begin(), bk.end());
long long mn = 0, mx = 2e9 + 10, res = 0;
while (mn <= mx) {
long long md = (mn + mx) / 2;
int j = 0;
bool g = 1;
for (int i = 0; i < n; i++) {
bool sc = 0;
while (j < k) {
long long dis = abs(ap[i] - bk[j]) + abs(bk[j] - p);
j++;
if (dis <= md) {
sc = 1;
break;
}
}
if (!sc) {
g = 0;
break;
}
}
if (g)
res = md, mx = md - 1;
else
mn = md + 1;
}
printf("%I64d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long add(long long a, long long b) {
return ((a % 1000000007LL) + (b % 1000000007LL)) % 1000000007LL;
}
inline long long mul(long long a, long long b) {
return ((a % 1000000007LL) * (b % 1000000007LL)) % 1000000007LL;
}
inline long long sub(long long a, long long b) {
return ((a % 1000000007LL) - (b % 1000000007LL) + 1000000007LL) %
1000000007LL;
}
long long dp[1001][2001];
long long findAns(long long i, long long j, long long n, long long k,
long long a[], long long key[], long long p) {
if (i == n) {
return 0;
}
if (j >= k) {
return -1000000000000000000LL;
}
if (dp[i][j] != -1) {
return dp[i][j];
}
long long ret;
long long ret1 = findAns(i, j + 1, n, k, a, key, p);
long long ret2 = findAns(i + 1, j + 1, n, k, a, key, p);
if (ret1 == -1000000000000000000LL && ret2 == -1000000000000000000LL) {
ret = -1000000000000000000LL;
} else if (ret1 == -1000000000000000000LL) {
ret = max(abs(a[i] - key[j]) + abs(key[j] - p), ret2);
} else if (ret2 == -1000000000000000000LL) {
ret = ret1;
} else {
ret = min(ret1, max(abs(a[i] - key[j]) + abs(key[j] - p), ret2));
}
return dp[i][j] = ret;
}
void Flash() {
long long n, k, p;
cin >> n >> k >> p;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long key[k];
for (long long i = 0; i < k; i++) {
cin >> key[i];
}
sort(a, a + n), sort(key, key + k);
memset(dp, -1, sizeof(dp));
long long ans = findAns(0, 0, n, k, a, key, p);
cout << ans << "\n";
}
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
;
long long t = 1;
for (long long i = 1; i <= t; i++) {
Flash();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, p, peop[100000], key[100005], minn = 0, maxx, coun = 1,
mark[100005];
long long dis(long long a, long long b) {
a = peop[a];
b = key[b];
if ((a <= b) && (b <= p)) return p - a;
if ((a <= p) && (p <= b)) return 2 * b - a - p;
if ((b <= a) && (a <= p)) return a + p - 2 * b;
if ((b <= p) && (p <= a)) return a + p - 2 * b;
if ((p <= a) && (a <= b))
return 2 * b - a - p;
else
return a - p;
}
bool func(long long x) {
long long cnt = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= k; ++j) {
if ((mark[j] != coun) && (dis(i, j) <= x)) {
cnt++;
mark[j] = coun;
break;
}
}
}
if (cnt == n) return true;
return false;
}
void bin() {
long long mid, ans = maxx;
while (minn <= maxx) {
mid = (minn + maxx) / 2;
if (func(mid)) {
ans = min(ans, mid);
maxx = mid - 1;
} else {
minn = mid + 1;
}
coun++;
}
cout << ans << endl;
}
int main() {
cin >> n >> k >> p;
for (int i = 1; i <= n; ++i) cin >> peop[i];
for (int i = 1; i <= k; ++i) cin >> key[i];
sort(peop + 1, peop + n + 1);
sort(key + 1, key + k + 1);
maxx = 1000000000000000000;
bin();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... s) {
long long idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ", ";
dbs(str.substr(idx + 1), s...);
}
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k, p;
cin >> n >> k >> p;
vector<long long> pos(n);
for (long long i = 0; i < n; i++) cin >> pos[i];
sort((pos).begin(), (pos).end());
vector<long long> keys(k);
for (long long i = 0; i < k; i++) cin >> keys[i];
sort((keys).begin(), (keys).end());
long long ans = LLONG_MAX;
for (long long i = 0; i + n - 1 < k; i++) {
long long mx = 0;
for (long long j = 0; j < n; j++) {
mx = max(mx, abs(keys[i + j] - pos[j]) + abs(keys[i + j] - p));
}
ans = min(ans, mx);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, k, p;
cin >> n >> k >> p;
vector<long long> a(n);
for (auto &i : a) cin >> i;
vector<long long> b(k);
for (auto &j : b) cin >> j;
sort(a.begin(), a.end());
sort(b.begin(), b.end());
long long ans = INT_MAX;
long long curans = 0;
for (int i = 0; i <= k - n; i++) {
curans = 0;
for (int j = 0; j < n; j++)
curans = max(curans, abs(a[j] - b[i + j]) + abs(b[i + j] - p));
ans = min(ans, curans);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2222;
long long n, m, p, a[N], b[N], dp[N][N];
bool used[N][N];
long long rec(long long i, long long j) {
if (used[i][j]) return dp[i][j];
if (i == n) return 0;
if (j == m) return 1e18;
used[i][j] = 1;
dp[i][j] = 1e18;
dp[i][j] = min(max(rec(i + 1, j + 1), abs(a[i] - b[j]) + abs(p - b[j])),
rec(i, j + 1));
return dp[i][j];
}
signed main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> p;
for (long long i = 0; i < n; ++i) cin >> a[i];
for (long long i = 0; i < m; ++i) cin >> b[i];
sort(a, a + n);
sort(b, b + m);
cout << rec(0, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[2010], b[2010], n, m, k;
bool check(long long mid) {
int t = 1, w = 1;
while (t <= n) {
while (w <= m && abs(a[t] - b[w]) + abs(b[w] - k) > mid) w++;
if (w > m) return false;
t++;
w++;
}
return true;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
sort(b + 1, b + m + 1);
long long l = 0, r = 1e15, mid, ans;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int mul(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
long long int sub(long long int a, long long int b) {
return ((a % mod) - (b % mod) + mod) % mod;
}
long long int gcdExtended(long long int a, long long int b, long long int *x,
long long int *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
long long int x1, y1;
long long int gcd = gcdExtended(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
long long int modInverse(long long int b) {
long long int x, y;
long long int g = gcdExtended(b, mod, &x, &y);
if (g != 1) return -1;
return (x % mod + mod) % mod;
}
long long int modDivide(long long int a, long long int b) {
a = a % mod;
long long int inv = modInverse(b);
if (inv == -1)
return -1;
else
return (inv * a) % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, t, j, inp, n, k, p;
cin >> n >> k >> p;
vector<long long int> A, B;
for (j = 0; j < n; j++) {
cin >> inp;
A.push_back(inp);
}
for (j = 0; j < k; j++) {
cin >> inp;
B.push_back(inp);
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
i = 0, j = n - 1;
long long int tm = INT_MIN, tim = INT_MAX;
for (j = 0; j <= k - n; j++) {
i = j;
long long int k1 = 0, tm = INT_MIN;
while (k1 < n) {
if ((B[i] <= p && B[i] >= A[k1]) || (B[i] >= p && B[i] <= A[k1])) {
t = abs(p - A[k1]);
} else if ((p <= B[i] && p >= A[k1]) || (p >= B[i] && p <= A[k1])) {
t = abs(A[k1] - p) + 2 * abs(p - B[i]);
} else {
t = abs(A[k1] - p) + 2 * abs(A[k1] - B[i]);
}
tm = max(tm, t);
i++, k1++;
}
tim = min(tim, tm);
}
cout << tim << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, p;
long long ans = LLONG_MAX;
cin >> n >> k >> p;
vector<long long> N(n), K(k);
for (int i = 0; i < n; i++) cin >> N[i];
for (int i = 0; i < k; i++) cin >> K[i];
sort(N.begin(), N.end());
sort(K.begin(), K.end());
for (int i = 0; i <= k - n; i++) {
long long aux = 0;
for (int j = 0; j < n; j++)
aux = max(aux, abs(N[j] - K[i + j]) + abs(K[i + j] - p));
ans = min(aux, ans);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int n, k, p;
int a[N];
int b[N];
void load() {
cin >> n >> k >> p;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < k; i++) cin >> b[i];
}
int rac(int x) {
int poz = 0;
int maks = 0;
for (int i = x; i < x + n; i++) {
int dist = abs(a[poz] - b[i]) + abs(b[i] - p);
maks = max(maks, dist);
poz++;
}
return maks;
}
void solve() {
sort(a, a + n);
sort(b, b + k);
int mini = 2000000007;
for (int i = 0; i <= k - n; i++) mini = min(mini, rac(i));
cout << mini << endl;
}
int main() {
load();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2005;
int man[N], key[N];
int main() {
int n, k, p;
scanf("%d%d%d", &n, &k, &p);
for (int i = 0; i < n; ++i) {
scanf("%d", &man[i]);
}
for (int i = 0; i < k; ++i) {
scanf("%d", &key[i]);
}
sort(man, man + n);
sort(key, key + k);
int min = 0x7fffffff;
for (int i = 0; i <= k - n; ++i) {
int sum = 0;
for (int j = 0; j < n; ++j) {
if (key[i + j] <= p && key[i + j] >= man[j] ||
key[i + j] >= p && key[i + j] <= man[j]) {
if (abs(p - man[j]) > sum) {
sum = abs(p - man[j]);
}
} else {
if (abs(man[j] - key[i + j]) + abs(key[i + j] - p) > sum) {
sum = abs(man[j] - key[i + j]) + abs(key[i + j] - p);
}
}
}
if (min > sum) {
min = sum;
}
}
printf("%d\n", min);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, k, p;
int a[1050], b[2050];
bool judge(long long x) {
int pos = -1;
for (int i = 0; i < n; i++) {
while (pos <= k) {
pos++;
if ((long long)(abs(a[i] - b[pos]) + abs(p - b[pos])) <= x) break;
}
if (pos >= k) return 0;
}
return 1;
}
int main() {
scanf("%d%d%d", &n, &k, &p);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
for (int i = 0; i < k; i++) scanf("%d", &b[i]);
sort(b, b + k);
long long ans = 0x3f3f3f3f3f3f3f3f;
long long l = 0, r = ans;
while (l <= r) {
long long mid = (l + r) >> 1;
if (judge(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
printf("%I64d\n", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.