text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 2e5 + 5;
int a[MAXN], b[MAXN];
struct Data {
Data() {}
Data(int Id, int X) { id = Id, x = X; }
int id, x;
bool operator<(const Data &b) const {
if (x != b.x) return x < b.x;
return id < b.id;
}
};
set<Data> s1, s2;
bool used[MAXN];
int main() {
int n = read(), m = read(), k = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) b[i] = read();
int tot = 0, sum = 0, ans = 0, j = 1;
for (int i = 1; i <= n; i++) {
tot += (b[i] + 1) / 2;
sum += a[i];
s1.insert(Data(i, b[i]));
used[i] = 1;
if ((int)s1.size() > m) {
auto it = s1.begin();
tot -= (it->x + 1) / 2;
s2.insert(*it);
tot += it->x;
used[it->id] = 0;
s1.erase(it);
}
while (tot > k) {
if (used[j]) {
auto it = s1.lower_bound(Data(j, b[j]));
tot -= (b[j] + 1) / 2;
s1.erase(it);
if (s2.size()) {
it = --s2.end();
tot -= it->x;
used[it->id] = 1;
s1.insert(*it);
tot += (it->x + 1) / 2;
s2.erase(it);
}
} else {
auto it = s2.lower_bound(Data(j, b[j]));
tot -= b[j];
s2.erase(it);
}
sum -= a[j++];
}
ans = max(ans, sum);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf2 = 1e18;
const int inf = 1e9 + 7;
const long long INF = 1e18;
inline int add(int a, int b, int m = inf) {
a += b;
if (a >= m) a -= m;
return a;
}
inline int subt(int a, int b, int m = inf) {
a -= b;
if (a < 0) a += m;
return a;
}
inline int mul(int a, int b, int m = inf) {
return (int)(((long long)a * (long long)b) % m);
}
set<pair<long long, long long> > h1, h2;
long long b[200005], a[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long T, N, M, i, j, k, w;
long long tt = 0;
long long now = 0;
long long L, R;
cin >> N >> w >> k;
for (i = 0; i < N; i++) cin >> a[i];
for (i = 0; i < N; i++) cin >> b[i];
long long res = 0;
for (L = 0, R = 0; R < N;) {
while (tt <= k and R < N) {
if (h1.size() < w) {
h1.insert(make_pair(b[R], R));
tt += (b[R] + 1) / 2;
} else if (h1.begin()->first < b[R]) {
tt -= (h1.begin()->first + 1) / 2;
tt += h1.begin()->first;
tt += (b[R] + 1) / 2;
h2.insert(*h1.begin());
h1.erase(*h1.begin());
h1.insert(make_pair(b[R], R));
} else {
tt += b[R];
h2.insert(make_pair(b[R], R));
}
now += a[R++];
if (tt <= k) res = max(res, now);
}
while (tt > k) {
if (h1.count(make_pair(b[L], L))) {
tt -= (b[L] + 1) / 2;
h1.erase(make_pair(b[L], L));
if (!h2.empty()) {
tt -= h2.rbegin()->first;
tt += (h2.rbegin()->first + 1) / 2;
h1.insert(*h2.rbegin());
h2.erase(*h2.rbegin());
}
} else {
tt -= b[L];
h2.erase(make_pair(b[L], L));
}
now -= a[L++];
if (tt <= k) res = max(res, now);
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
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 = 2e5 + 5;
int n, m, p, a[N], t[N], ans, sa, st;
set<pair<int, int> > q, Q;
int erase(int j) {
if (q.count(make_pair(t[j], j)))
q.erase(make_pair(t[j], j)), st -= t[j], sa -= a[j];
else
Q.erase(make_pair(t[j], j)), st -= (t[j] + 1) / 2, sa -= a[j];
while (!q.empty() && !Q.empty()) {
auto l = *prev(q.end());
auto r = *Q.begin();
if (l.first > r.first) {
q.erase(l);
Q.erase(r);
q.insert(r);
Q.insert(l);
st -= l.first;
st -= (r.first + 1) / 2;
st += r.first;
st += (l.first + 1) / 2;
} else
break;
}
}
int check(int t) {
int tmp = st;
if (((int)(Q).size()) < m) return (t + 1) / 2 + st > p;
if (Q.begin()->first < t) {
tmp -= (Q.begin()->first + 1) / 2;
tmp += Q.begin()->first;
tmp += (t + 1) / 2;
} else
tmp += t;
return tmp > p;
}
int main() {
cin >> n >> m >> p;
for (int i = 1; i <= int(n); i++) scanf("%d", &a[i]);
for (int i = 1; i <= int(n); i++) scanf("%d", &t[i]);
int j = 1;
for (int i = 1; i <= int(n); i++) {
if ((t[i] + 1) / 2 > p) {
q.clear();
Q.clear();
sa = st = 0;
j = i + 1;
continue;
}
while (check(t[i])) erase(j), j++;
if (((int)(Q).size()) < m) {
Q.insert(make_pair(t[i], i));
sa += a[i];
st += (t[i] + 1) / 2;
} else {
if (Q.begin()->first < t[i]) {
q.insert(*Q.begin());
st -= (Q.begin()->first + 1) / 2;
st += Q.begin()->first;
Q.erase(Q.begin());
sa += a[i];
st += (t[i] + 1) / 2;
Q.insert(make_pair(t[i], i));
} else {
q.insert(make_pair(t[i], i));
sa += a[i];
st += t[i];
}
}
ans = max(ans, sa);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int a[maxn], t[maxn];
struct node {
int id;
};
bool operator<(node a, node b) {
return (t[a.id] == t[b.id]) ? (a.id < b.id) : (t[a.id] < t[b.id]);
}
bool operator>(node a, node b) { return b < a; }
set<node> hf;
set<node, greater<node>> fl;
int main() {
int i, n, w, k, l = 1, c = 0, tmp = 0, nAns = 0;
scanf("%d%d%d", &n, &w, &k);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &t[i]);
for (i = 1; i <= n; i++) {
hf.insert({i});
c += (t[i] + 1) / 2;
tmp += a[i];
if (hf.size() > w) {
auto it = hf.begin();
fl.insert(*it);
c += t[it->id] / 2;
hf.erase(it);
}
for (; c > k; l++) {
tmp -= a[l];
if (t[l] < t[hf.begin()->id]) {
if (fl.count({l})) fl.erase({l});
c -= t[l];
} else {
if (hf.count({l})) hf.erase({l});
c -= (t[l] + 1) / 2;
if (!fl.empty()) {
auto it = fl.begin();
hf.insert(*it);
c -= t[it->id] / 2;
fl.erase(it);
}
}
}
nAns = max(nAns, tmp);
}
printf("%d\n", nAns);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 111111;
struct Data {
int t, id;
Data() {}
Data(int _t, int _id) {
t = _t;
id = _id;
}
bool operator<(const Data& B) const {
return (t == B.t) ? (id < B.id) : t < B.t;
}
bool operator==(const Data& B) const { return t == B.t && id == B.id; }
};
struct node {
int t, v;
} a[maxn];
set<Data> S1, S2;
int nowt = 0, tot = -1, st = 0;
void Insert(int ty, int t, int id) {
if (ty == 1) {
S1.insert(Data(t, id));
nowt += t;
} else {
S2.insert(Data(t, id));
nowt += ((t - 1) / 2 + 1);
}
}
void Erase(int ty, int t, int id) {
if (ty == 1) {
S1.erase(Data(t, id));
nowt -= t;
} else {
S2.erase(Data(t, id));
nowt -= ((t - 1) / 2 + 1);
}
}
void ERASE(int st) {
if (S1.find(Data(a[st].t, st)) != S1.end())
Erase(1, a[st].t, st);
else {
Erase(2, a[st].t, st);
if (S1.size() > 0) {
Data tmp = *(--S1.end());
Erase(1, tmp.t, tmp.id);
Insert(2, tmp.t, tmp.id);
}
}
}
int n, w, k;
int main() {
cin >> n >> w >> k;
for (int i = 0; i < n; i++) cin >> a[i].v;
for (int i = 0; i < n; i++) cin >> a[i].t;
int ans = 0, ANS = 0;
while (st != n) {
while (nowt <= k) {
tot++;
if (tot >= n) break;
if (S2.size() < w) {
Insert(2, a[tot].t, tot);
} else {
Data tmp = *S2.begin();
if (tmp.t < a[tot].t) {
Erase(2, tmp.t, tmp.id);
Insert(1, tmp.t, tmp.id);
Insert(2, a[tot].t, tot);
} else
Insert(1, a[tot].t, tot);
}
if (nowt <= k)
ans += a[tot].v;
else {
ERASE(tot);
tot--;
break;
}
ANS = max(ANS, ans);
}
ERASE(st);
ans -= a[st].v;
st++;
}
cout << ANS << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, w, k;
int a[N], t[N];
int d[N];
bool in[N];
struct Sol {
set<pair<int, int> > big;
set<pair<int, int> > small;
int z = 0;
void add(int i) {
if (small.empty() || t[i] > small.rbegin()->first) {
big.insert(make_pair(t[i], i));
z += (t[i] + 1) / 2;
} else {
small.insert(make_pair(t[i], i));
z += t[i];
}
while (big.size() > w) {
auto tt = *big.begin();
big.erase(big.begin());
z -= (tt.first + 1) / 2;
small.insert(tt);
z += tt.first;
}
}
void erase(int i) {
if (small.count(make_pair(t[i], i))) {
small.erase(make_pair(t[i], i));
z -= t[i];
} else {
big.erase(make_pair(t[i], i));
z -= (t[i] + 1) / 2;
}
while (big.size() < w) {
if (small.empty()) break;
auto tt = *small.rbegin();
small.erase(--small.end());
z -= tt.first;
big.insert(tt);
z += (tt.first + 1) / 2;
}
}
int get() { return z; }
} sol;
int main() {
scanf("%d%d%d", &n, &w, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
for (int i = 0; i < n; ++i) d[i] = (i == 0 ? 0 : d[i - 1]) + a[i];
for (int i = 0; i < n; ++i) {
scanf("%d", t + i);
}
int ans = 0;
int j = 0;
for (int i = 0; i < n; ++i) {
for (; j < n; ++j) {
sol.add(j);
in[j] = 1;
if (sol.get() > k) {
sol.erase(j);
in[j] = 0;
break;
}
}
if (sol.get() <= k) {
ans = max(ans, d[j - 1] - (i == 0 ? 0 : d[i - 1]));
}
if (in[i]) {
sol.erase(i);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 500000;
int Profit[kMaxN], Time[kMaxN];
int n, w, k;
int total_time, total_profit, economy;
template <typename cmp>
struct CustomSet {
int cnt[5005];
int sz;
priority_queue<int, vector<int>, cmp> Q;
void insert(int x) {
cnt[x] += 1;
sz += 1;
if (cnt[x] == 1) Q.push(x);
}
void erase(int x) {
cnt[x] -= 1;
sz -= 1;
}
bool has(int x) { return cnt[x] > 0; }
void clear() {
while (!Q.empty()) Q.pop();
memset(cnt, 0, sizeof(cnt));
sz = 0;
}
int size() { return sz; }
int first() {
while (cnt[Q.top()] == 0) Q.pop();
return Q.top();
}
};
CustomSet<greater<int>> GoodSet;
CustomSet<less<int>> BadSet;
void Ins(int x) {
GoodSet.insert(x);
economy += x;
if (GoodSet.size() > w) {
int y = GoodSet.first();
economy -= y;
BadSet.insert(y);
GoodSet.erase(y);
}
}
void Ers(int x) {
if (BadSet.has(x))
BadSet.erase(x);
else {
economy -= x;
GoodSet.erase(x);
if (BadSet.size() > 0) {
int y = BadSet.first();
economy += y;
GoodSet.insert(y);
BadSet.erase(y);
}
}
}
void Insert(int i) {
total_time += Time[i];
total_profit += Profit[i];
Ins(Time[i] / 2);
}
void Erase(int i) {
total_time -= Time[i];
total_profit -= Profit[i];
Ers(Time[i] / 2);
}
bool Check(int need) {
int i = 1, j = 1;
total_profit = total_time = economy = 0;
GoodSet.clear();
BadSet.clear();
while (i <= n) {
while (j <= n && total_profit < need) Insert(j++);
if (total_profit >= need && total_time - economy <= k) return true;
Erase(i++);
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
scanf("%d %d %d", &n, &w, &k);
for (int i = 1; i <= n; ++i) scanf("%d", Profit + i);
for (int i = 1; i <= n; ++i) scanf("%d", Time + i);
int ans = 0;
for (int step = (1 << 30); step; step /= 2)
if (Check(ans + step)) ans += step;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 2e5 + 10;
long long n, w, k, happy[N], nice, t[N], mytime, ans;
bool in[N];
pair<int, int> lowest;
set<pair<int, int>> st;
queue<int> q;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> w >> k;
for (int i = 0; i < n; i++) cin >> happy[i];
for (int i = 0; i < n; i++) cin >> t[i];
for (int i = n - 1; ~i; i--) {
st.insert({t[i], -i});
if ((int)st.size() == w) {
lowest = *st.begin();
mytime += (t[i] + 1) / 2;
in[i] = true;
} else if ((int)st.size() > w) {
if (t[i] >= lowest.first) {
in[-lowest.second] = false;
mytime += (t[i] + 1) / 2;
mytime -= (lowest.first + 1) / 2;
mytime += lowest.first;
lowest = *st.upper_bound(lowest);
in[i] = true;
} else
mytime += t[i];
} else {
in[i] = true;
mytime += (t[i] + 1) / 2;
}
nice += happy[i];
q.push(i);
while (mytime > k) {
nice -= happy[q.front()];
if (in[q.front()]) {
mytime -= (t[q.front()] + 1) / 2;
in[q.front()] = false;
st.erase({t[q.front()], -q.front()});
if ((int)st.size() >= w) {
lowest = *(--st.lower_bound(lowest));
in[-lowest.second] = true;
mytime -= lowest.first;
mytime += (lowest.first + 1) / 2;
}
} else {
mytime -= t[q.front()];
st.erase({t[q.front()], -q.front()});
}
q.pop();
}
ans = max(ans, nice);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 10;
long long n, k, w, tot, val, ans;
struct node {
long long v, t, id, b;
inline bool operator<(const node& x) const { return t < x.t; }
} a[MAXN];
multiset<long long> s1, s2;
multiset<long long>::iterator it;
signed main() {
ios ::sync_with_stdio(0), cin.tie(0);
cin >> n >> w >> k;
for (long long i = 1; i <= n; i++) cin >> a[i].v;
for (long long i = 1; i <= n; i++) cin >> a[i].t, a[i].b = (a[i].t + 1) / 2;
long long l = 1, r = 1;
while (r <= n) {
tot += a[r].b;
val += a[r].v;
s2.insert(a[r].t);
if (s2.size() > w) {
it = s2.begin();
tot += *it - (*it + 1) / 2;
s2.erase(it);
s1.insert(*it);
}
while (l <= r && tot > k) {
it = s2.begin();
if (a[l].t < *it) {
tot -= a[l].t;
val -= a[l].v;
s1.erase(s1.find(a[l].t));
} else {
tot -= (a[l].b);
val -= a[l].v;
s2.erase(s2.find(a[l].t));
while (s2.size() < w && !s1.empty()) {
it = s1.end();
it--;
s2.insert(*it);
s1.erase(it);
tot -= *it - (*it + 1) / 2;
}
}
l++;
}
ans = max(ans, val);
r++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<pair<int, int> > seti, setfull;
set<pair<int, int> >::iterator it1, it, it2;
int arr[212345] = {0};
int a[212345] = {0};
int t[212345] = {0};
int main() {
std::ios::sync_with_stdio(false);
int n, w, k;
cin >> n >> w >> k;
int i = 0;
int j = 0;
long long plea = 0;
long long total = 0;
long long totalnew = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
cin >> t[i];
}
i = 0;
j = 0;
long long maxi = 0;
long long val;
while (j < n) {
if (seti.size() < w) {
if (total + (t[j] + 1) / 2 <= k) {
seti.insert(make_pair((t[j] + 1) / 2, j));
arr[j] = 1;
total += (t[j] + 1) / 2;
plea += a[j];
j++;
} else {
if (arr[i] == 1) {
seti.erase(make_pair((t[i] + 1) / 2, i));
plea -= a[i];
total -= (t[i] + 1) / 2;
arr[i] = 0;
} else {
j++;
}
i++;
}
} else {
it = seti.begin();
int val = it->second;
if (t[val] < t[j]) {
totalnew = total + (t[val]) - (t[val] + 1) / 2 + (t[j] + 1) / 2;
if (totalnew <= k) {
seti.erase(it);
setfull.insert(make_pair(t[val], val));
arr[val] = 0;
plea += a[j];
total = totalnew;
seti.insert(make_pair((t[j] + 1) / 2, j));
arr[j] = 1;
j++;
} else {
if (arr[i] == 1) {
seti.erase(make_pair((t[i] + 1) / 2, i));
plea -= a[i];
total -= (t[i] + 1) / 2;
if (!setfull.empty()) {
it = setfull.end();
it--;
val = it->second;
arr[val] = 1;
arr[i] = 0;
setfull.erase(it);
total -= t[val];
total += (t[val] + 1) / 2;
seti.insert(make_pair((t[val] + 1) / 2, val));
}
} else {
setfull.erase(make_pair(t[i], i));
plea -= a[i];
total -= t[i];
}
i++;
}
} else {
totalnew = total + t[j];
if (totalnew <= k) {
setfull.insert(make_pair(t[j], j));
plea += a[j];
total += t[j];
j++;
} else {
if (arr[i] == 1) {
seti.erase(make_pair((t[i] + 1) / 2, i));
plea -= a[i];
total -= (t[i] + 1) / 2;
arr[i] = 0;
if (!setfull.empty()) {
it = setfull.end();
it--;
val = it->second;
arr[val] = 1;
setfull.erase(it);
total -= t[val];
total += (t[val] + 1) / 2;
seti.insert(make_pair((t[val] + 1) / 2, val));
}
} else {
setfull.erase(make_pair(t[i], i));
plea -= a[i];
total -= t[i];
}
i++;
}
}
}
maxi = max(maxi, plea);
}
cout << maxi << endl;
}
|
#include <bits/stdc++.h>
int n, w, k;
int a[(int)2e5 + 1];
int t[(int)2e5 + 1];
int ans;
std::priority_queue<int, std::vector<int>, std::greater<int> > part, dpart;
std::priority_queue<int> full, dfull;
int time_;
inline void clean(void) {
while (part.size() && dpart.size() && part.top() == dpart.top())
part.pop(), dpart.pop();
while (full.size() && dfull.size() && full.top() == dfull.top())
full.pop(), dfull.pop();
}
inline bool insert(int T) {
clean();
if ((time_ + ((T + 1) >> 1)) > k) return false;
time_ += (T + 1) >> 1;
part.push(T);
if (part.size() - dpart.size() > w) {
if ((time_ + (part.top() >> 1)) > k) {
time_ -= (T + 1) >> 1;
dpart.push(T);
return false;
} else {
time_ += part.top() >> 1;
full.push(part.top());
dpart.push(part.top());
}
}
return true;
}
inline void erase(int T) {
clean();
if (T < part.top()) {
time_ -= T;
dfull.push(T);
} else {
time_ -= (T + 1) >> 1;
dpart.push(T);
if (full.size()) {
dfull.push(full.top());
part.push(full.top());
time_ -= full.top() >> 1;
}
}
}
int main(void) {
scanf(" %d %d %d", &n, &w, &k);
for (int i = 1; i <= n; ++i) {
scanf(" %d", a + i);
}
for (int i = 1; i <= n; ++i) {
scanf(" %d", t + i);
}
int r = 1;
int val = 0;
for (int l = 1; l <= n; ++l) {
while (r <= n && insert(t[r])) val += a[r++];
if (r > l) {
ans = std::max(ans, val);
val -= a[l];
erase(t[l]);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int data[2][100010], t[100010], num[100010];
queue<pair<int, int> > que;
int dis(int x, int y) { return abs(data[0][x] - data[1][y]); }
int main() {
scanf("%d%d%*d%*d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &data[0][i]);
for (int i = 0; i < m; i++) scanf("%d", &data[1][i]);
for (int i = 0; i < m; i++) t[i] = 0x7fffffff;
int j = 0;
for (int i = 0; i < n; i++) {
while (j + 1 < m && dis(i, j + 1) < dis(i, j)) j++;
if (j + 1 < m && dis(i, j) == dis(i, j + 1)) {
que.push(make_pair(i, j));
continue;
}
int k = j;
if (j + 1 < m && dis(i, j + 1) < dis(i, j)) k++;
if (t[k] > dis(i, k)) num[k] = 0, t[k] = dis(i, k);
if (t[k] == dis(i, k)) num[k]++;
}
while (!que.empty()) {
int i = que.front().first, j = que.front().second;
que.pop();
if (dis(i, j) == t[j] || t[j] == 0x7fffffff)
num[j]++, t[j] = dis(i, j);
else if (dis(i, j + 1) == t[j + 1] || t[j + 1] == 0x7fffffff)
num[j + 1]++, t[j + 1] = dis(i, j + 1);
}
int ans = n;
for (int i = 0; i < m; i++) ans -= num[i];
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int ches[100010];
int mice[100010];
int n, m;
int main() {
int i, x, y, j;
scanf("%d %d %d %d", &n, &m, &x, &y);
for (i = 0; i < n; i++) {
scanf("%d", &mice[i]);
}
for (j = 0; j < m; j++) {
scanf("%d", &ches[j]);
}
int last = -1, res = 0;
j = 0;
for (i = 0; i < n; i++) {
while (j < m && abs(mice[i] - ches[j]) > abs(mice[i] - ches[j + 1])) {
j++;
}
if (j != last || abs(mice[i] - ches[j]) == abs(mice[i - 1] - ches[j])) {
last = j;
res++;
} else if (j + 1 < m &&
abs(mice[i] - ches[j]) == abs(mice[i] - ches[j + 1])) {
res++;
last = ++j;
} else {
last = j;
}
}
printf("%d", n - res);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
int n, m;
int botva[100100], y2[100100];
multiset<int> ans[100100];
int main() {
int y3, y4;
scanf("%d %d %d %d", &n, &m, &y3, &y4);
if (m == 0) {
cout << n << endl;
return 0;
}
for (int i = 0; i < n; i++) scanf("%d", &botva[i]);
for (int i = 0; i < m; i++) scanf("%d", &y2[i]);
for (int i = 0; i < n; i++) {
int t1 = lower_bound(y2, y2 + m, botva[i]) - y2, t2 = t1 - 1;
if (t2 < 0) {
ans[t1].insert(abs(botva[i] - y2[t1]));
continue;
}
if (t1 >= m || botva[i] - y2[t2] < y2[t1] - botva[i]) {
ans[t2].insert(abs(botva[i] - y2[t2]));
continue;
}
if (botva[i] - y2[t2] > y2[t1] - botva[i]) {
ans[t1].insert(abs(botva[i] - y2[t1]));
continue;
}
if (ans[t2].empty() || (*ans[t2].begin() == abs(botva[i] - y2[t2])))
ans[t2].insert(abs(botva[i] - y2[t2]));
else
ans[t1].insert(abs(botva[i] - y2[t1]));
}
int ans1 = 0;
for (int i = 0; i < m; i++) {
int ans2 = 0;
for (multiset<int>::iterator it = ans[i].begin();
it != ans[i].end() && (*it == *ans[i].begin()); it++)
ans2++;
ans1 += ans[i].size() - ans2;
}
cout << ans1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 1000 * 100 + 1000;
const int INF = (1u << 31) - 1;
int l1[MN];
int l2[MN];
int b[MN];
int p[MN];
int n, m, _;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> _ >> _;
for (int i = 0; i < n; i++) cin >> l1[i];
for (int i = 0; i < m; i++) cin >> l2[i];
sort(l1, l1 + n);
sort(l2, l2 + m);
for (int i = 0; i < m; i++) b[i] = INF;
int now = 0;
for (int i = 0; i < n; i++) {
while (now + 1 < m && abs(l2[now + 1] - l1[i]) < abs(l2[now] - l1[i]))
now++;
if (now + 1 < m && abs(l2[now + 1] - l1[i]) == abs(l2[now] - l1[i]) &&
b[now] != abs(l2[now] - l1[i]) && b[now] != INF)
now++;
p[i] = now;
b[now] = min(b[now], abs(l2[now] - l1[i]));
}
int hung = 0;
for (int i = 0; i < n; i++)
if (b[p[i]] != abs(l2[p[i]] - l1[i])) hung++;
cout << hung << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
int Y0, Y1;
cin >> N >> M >> Y0 >> Y1;
long long int a[N + 1];
long long int b[M + 1];
for (int i = 0; i < N; i++) {
cin >> a[i];
}
for (int i = 0; i < M; i++) {
cin >> b[i];
}
long long int last_eaten = -1;
int j = 0;
int eaten = 0;
for (int i = 0; i < N; i++) {
while (j < M && abs(a[i] - b[j + 1]) < abs(a[i] - b[j])) {
j++;
}
if (last_eaten < j || (i > 0 && abs(a[i - 1] - b[j]) == abs(a[i] - b[j]))) {
eaten++;
last_eaten = j;
} else if (j < M && i < N && abs(a[i] - b[j]) == abs(a[i] - b[j + 1])) {
eaten++;
last_eaten = ++j;
} else {
last_eaten = j;
}
}
cout << N - eaten;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5, INF = 1e9;
int n, m, x, y;
int a[MAX], b[MAX];
int match[MAX];
bool ok[MAX];
void init(void) {
cin >> n >> m >> x >> y;
for (int i = (1), _b = (n); i <= _b; i++) cin >> a[i];
for (int i = (1), _b = (m); i <= _b; i++) cin >> b[i];
}
void process(void) {
int res = 0;
for (int i = 1, j = 1; i <= n; i++) {
while (j < m && b[j] < a[i]) j++;
if (b[j] <= a[i] || j == 1)
match[i] = j;
else {
int p = abs(b[j] - a[i]), q = abs(b[j - 1] - a[i]);
if (p < q)
match[i] = j;
else
match[i] = j - 1;
if (p == q) ok[i] = 1;
}
}
int last = 1;
for (int i = 2; i <= n; i++)
if (match[i] == match[last]) {
int j = match[i];
if (abs(a[i] - b[j]) == abs(a[last] - b[j]))
last = i;
else if (abs(a[i] - b[j]) > abs(a[last] - b[j])) {
if (ok[i]) {
match[i]++;
last = i;
} else
res++;
} else if (!ok[i]) {
res++;
last = i;
} else {
match[i]++;
last = i;
}
} else
last = i;
cout << res << endl;
}
int main(void) {
init();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int M, N, ans;
int a[100010], b[100010];
int len, stane;
pair<int, int> ps[200010];
int is[200010];
int main() {
cin >> M >> N >> stane >> stane;
for (int i = 0; i < M; i++) cin >> a[i];
for (int j = 0; j < N; j++) cin >> b[j];
for (int i = 0; i < M; i++) ps[len++] = make_pair(a[i], 0);
for (int j = 0; j < N; j++) ps[len++] = make_pair(b[j], 1);
ps[len++] = make_pair(-0x3f3f3f3, 0);
ps[len++] = make_pair(0x3f3f3f3, 0);
sort(ps, ps + len);
len--;
memset(is, 0, sizeof is);
for (int i = 1, j; i < len; i++)
if (!ps[i].second) {
int d = 0x3f3f3f3;
j = lower_bound(b, b + N, ps[i].first) - b;
if (j < N) d = min(d, b[j] - ps[i].first);
if (j > 0) d = min(d, ps[i].first - b[j - 1]);
int dl = ps[i - 1].second ? (ps[i].first - ps[i - 1].first) : 0x3f3f3f3;
int dr = ps[i + 1].second ? (ps[i + 1].first - ps[i].first) : 0x3f3f3f3;
if (d < 0x3f3f3f3 && d == dl) is[i - 1] = 1;
if (d < 0x3f3f3f3 && d == dr) is[i] = 1;
}
for (int i = 0, j; i < len; i = j) {
if (is[i]) {
for (j = i; j < len && is[j]; j++)
;
bool shr = 0;
for (int k = i + 1; k < j; ++k)
if (ps[k].second)
if (ps[k].first - ps[k - 1].first == ps[k + 1].first - ps[k].first)
shr = 1;
ans += (j - i + 1) / 2;
if (!ps[i].second && !ps[j].second && shr) ++ans;
} else
j = i + 1;
}
cout << M - ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[200000], d[200000];
int a[200000], b[200000];
int n, m;
int dis(int x, int y) { return abs(a[x] - b[y]); }
int main() {
int y0, y1;
cin >> n >> m >> y0 >> y1;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
int k = 1;
for (int i = 1; i <= m; i++) d[i] = 100000000;
for (int i = 1; i <= n; i++) {
while (k < m && dis(i, k) > dis(i, k + 1)) k++;
if (k < m && dis(i, k) == dis(i, k + 1)) {
if (t[k] == 0 || dis(i, k) == d[k]) {
t[k]++;
d[k] = dis(i, k);
} else {
k++;
t[k] = 1;
d[k] = dis(i, k);
}
} else {
if (t[k] == 0 || dis(i, k) < d[k]) {
t[k] = 0;
d[k] = dis(i, k);
t[k]++;
} else if (dis(i, k) == d[k])
t[k]++;
}
}
int ans = 0;
for (int i = 1; i <= m; i++) ans += t[i];
cout << n - ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5;
const int INF = 0x3f3f3f3f;
int a[M];
int b[M];
int match[M];
int mn[M];
int main() {
int n, m;
scanf("%d%d%*d%*d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
int j = 0;
memset(mn, INF, sizeof(mn));
for (int i = 0; i < n; i++) {
while (j + 1 < m && abs(a[i] - b[j + 1]) < abs(a[i] - b[j])) j++;
if (j + 1 < m && abs(a[i] - b[j + 1]) == abs(a[i] - b[j]) && mn[j] != INF &&
mn[j] != abs(a[i] - b[j]))
j++;
match[i] = j;
mn[j] = min(mn[j], abs(a[i] - b[j]));
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (abs(a[i] - b[match[i]]) != mn[match[i]]) ans++;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ches[100010];
int mice[100010];
int n, m;
int main() {
int i, x, y, j;
scanf("%d %d %d %d", &n, &m, &x, &y);
for (i = 0; i < n; i++) {
scanf("%d", &mice[i]);
}
for (j = 0; j < m; j++) {
scanf("%d", &ches[j]);
}
int last = -1, res = 0;
j = 0;
for (i = 0; i < n; i++) {
while (j < m && abs(mice[i] - ches[j]) > abs(mice[i] - ches[j + 1])) {
j++;
}
if (j != last) {
last = j;
res++;
} else if (abs(mice[i] - ches[j]) == abs(mice[i - 1] - ches[j])) {
res++;
last = j;
} else if (j + 1 < m &&
abs(mice[i] - ches[j]) == abs(mice[i] - ches[j + 1])) {
res++;
last = ++j;
} else {
last = j;
}
}
printf("%d", n - res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 100086;
int mice[MAXN], arr[MAXN], chese[MAXN];
int main() {
for (int n, m; ~scanf("%d%d%*d%*d", &n, &m);) {
for (int i = 0; i < n; i++) {
scanf("%d", &mice[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &chese[i]);
}
fill(arr, arr + m, INF);
int ans = 0, now = 0;
for (int i = 0; i < n; i++) {
while (now + 1 < m &&
abs(mice[i] - chese[now + 1]) < abs(mice[i] - chese[now])) {
now++;
}
int left = now, right = now + 1 < m && abs(mice[i] - chese[now + 1]) ==
abs(mice[i] - chese[now])
? now + 1
: now;
int dist = abs(mice[i] - chese[left]);
if (arr[left] == INF) {
ans++;
arr[left] = dist;
} else if (arr[left] == dist) {
ans++;
} else if (arr[left] > dist && left == right) {
arr[left] = dist;
} else if (left != right) {
arr[right] = dist;
ans++;
}
}
printf("%d\n", n - ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 2;
const int inf = 1e9;
int a[maxn];
int b[maxn];
int p[maxn];
int main() {
int n, m, y, y0, ans = 0, cur, x;
cin >> n >> m >> y >> y0;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
memset(p, -1, sizeof(p));
cur = 0;
for (int i = 0; i < n; i++) {
for (; cur < m && b[cur + 1] <= a[i]; cur++)
;
if (b[cur] < a[i] && cur + 1 < m && a[i] - b[cur] == b[cur + 1] - a[i]) {
if (p[cur] == -1) {
p[cur] = a[i] - b[cur];
ans++;
} else {
if (p[cur] == a[i] - b[cur])
ans++;
else {
ans++;
p[cur + 1] = b[cur + 1] - a[i];
}
}
} else {
if (cur + 1 < m && abs(a[i] - b[cur]) > b[cur + 1] - a[i]) {
if (p[cur + 1] == -1) {
p[cur + 1] = b[cur + 1] - a[i];
ans++;
}
p[cur + 1] = min(p[cur + 1], b[cur + 1] - a[i]);
} else {
x = abs(b[cur] - a[i]);
if (p[cur] == -1 || p[cur] == x) {
p[cur] = x;
ans++;
} else {
p[cur] = min(p[cur], x);
}
}
}
}
cout << n - ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
int mi[N], ch[N], rr[N];
int dp[N][2];
int fun(int x1, int y1, int x2, int y2) {
if (dp[x1][y1] == 0) return 0;
int x = ch[rr[x1] - y1], y = ch[rr[x2] - y2];
if (x != y) return 1;
if (abs(mi[x1] - x) == abs(mi[x2] - x)) return 1;
return 0;
}
int main() {
int n, m, y1, y2;
while (scanf("%d%d%d%d", &n, &m, &y1, &y2) != EOF) {
for (int i = 0; i < n; i++) scanf("%d", &mi[i]);
for (int i = 0; i < m; i++) scanf("%d", &ch[i]);
int j = 0;
for (int i = 0; i < n; i++) {
while (j + 1 < m && ch[j] <= mi[i]) j++;
rr[i] = j;
}
memset(dp, 0, sizeof(dp));
if (rr[0] > 0) {
int x = rr[0];
if (ch[x] - mi[0] == mi[0] - ch[x - 1]) {
dp[0][0] = dp[0][1] = 1;
} else if (ch[x] - mi[0] > mi[0] - ch[x - 1])
dp[0][1] = 1;
else
dp[0][0] = 1;
} else {
dp[0][0] = 1;
}
for (int i = 1; i < n; i++) {
int x = rr[i];
if (rr[i] > 0) {
if (ch[x] - mi[i] == mi[i] - ch[x - 1]) {
dp[i][0] = max(fun(i - 1, 0, i, 0) + dp[i - 1][0],
fun(i - 1, 1, i, 0) + dp[i - 1][1]);
dp[i][1] = max(fun(i - 1, 0, i, 1) + dp[i - 1][0],
fun(i - 1, 1, i, 1) + dp[i - 1][1]);
} else if (ch[x] - mi[i] > mi[i] - ch[x - 1]) {
dp[i][1] = max(fun(i - 1, 0, i, 1) + dp[i - 1][0],
fun(i - 1, 1, i, 1) + dp[i - 1][1]);
} else {
dp[i][0] = max(fun(i - 1, 0, i, 0) + dp[i - 1][0],
fun(i - 1, 1, i, 0) + dp[i - 1][1]);
}
} else {
dp[i][0] = max(fun(i - 1, 0, i, 0) + dp[i - 1][0],
fun(i - 1, 1, i, 0) + dp[i - 1][1]);
}
}
printf("%d\n", n - max(dp[n - 1][0], dp[n - 1][1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int L = 1e5 + 10;
int S[L];
int T[L];
int U[L];
int D[L];
vector<int> mem[L];
const int inf = 1e8;
int main() {
int N, M, Y0, Y1;
scanf("%d%d%d%d", &N, &M, &Y0, &Y1);
for (int i = 0; i < N; i++) {
scanf("%d", S + i);
}
for (int i = 0; i < M; i++) {
scanf("%d", T + i);
U[i] = inf;
}
T[M] = inf;
int c = 0;
for (int i = 0; i < N; i++) {
while (T[c + 1] <= S[i]) {
c++;
}
if (abs(T[c] - S[i]) < abs(T[c + 1] - S[i])) {
if (U[c] > abs(T[c] - S[i])) {
D[c] = 1;
mem[c].clear();
mem[c].push_back(i);
U[c] = abs(T[c] - S[i]);
} else if (U[c] == abs(T[c] - S[i])) {
D[c]++;
mem[c].push_back(i);
}
} else if (abs(T[c] - S[i]) > abs(T[c + 1] - S[i])) {
if (U[c + 1] > abs(T[c + 1] - S[i])) {
D[c + 1] = 1;
mem[c + 1].clear();
mem[c + 1].push_back(i);
U[c + 1] = abs(T[c + 1] - S[i]);
} else if (U[c + 1] == abs(T[c + 1] - S[i])) {
D[c + 1]++;
mem[c + 1].push_back(i);
}
}
}
c = 0;
for (int i = 0; i < N; i++) {
while (T[c + 1] <= S[i]) {
c++;
}
if (abs(T[c] - S[i]) == abs(T[c + 1] - S[i])) {
if (abs(T[c] - S[i]) < U[c]) {
if (abs(T[c + 1] - S[i]) < U[c + 1]) {
if (D[c] <= D[c + 1]) {
D[c] = 1;
mem[c].clear();
mem[c].push_back(i);
U[c] = abs(T[c] - S[i]);
} else {
D[c + 1] = 1;
mem[c + 1].clear();
mem[c + 1].push_back(i);
U[c + 1] = abs(T[c + 1] - S[i]);
}
} else if (D[c] == 0) {
D[c] = 1;
mem[c].clear();
mem[c].push_back(i);
U[c] = abs(T[c] - S[i]);
} else if (abs(T[c + 1] - S[i]) == U[c + 1]) {
D[c + 1]++;
mem[c + 1].push_back(i);
}
} else if (abs(T[c] - S[i]) == U[c]) {
D[c]++;
mem[c].push_back(i);
} else {
if (abs(T[c + 1] - S[i]) > U[c + 1]) {
} else if (abs(T[c + 1] - S[i]) == U[c + 1]) {
D[c + 1]++;
mem[c + 1].push_back(i);
} else if (D[c + 1] == 0) {
D[c + 1] = 1;
mem[c + 1].clear();
mem[c + 1].push_back(i);
U[c + 1] = abs(T[c + 1] - S[i]);
}
}
}
}
int ret = N;
for (int i = 0; i < M; i++) {
ret -= D[i];
}
printf("%d\n", ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mice[100001];
int cake[100001];
int d[100001];
int fab(int x) { return x > 0 ? x : -x; }
int main() {
int n, m, y0, y1, i, ans, x;
while (cin >> n >> m) {
cin >> y0 >> y1;
for (i = 1; i <= n; i++) scanf("%d", &mice[i]);
for (i = 1; i <= m; i++) scanf("%d", &cake[i]);
if (m == 0) {
cout << n << endl;
continue;
}
x = 1;
memset(d, -1, sizeof(d));
ans = 0;
for (i = 1; i <= n; i++) {
while (x + 1 <= m && mice[i] >= cake[x + 1]) x++;
if (x == m) {
if (d[x] == -1) {
d[x] = fab(mice[i] - cake[x]);
} else {
if (d[x] == fab(mice[i] - cake[x])) continue;
d[x] = min(d[x], fab(mice[i] - cake[x]));
ans++;
}
continue;
}
if (mice[i] < cake[x]) {
if (d[x] != -1) ans++;
d[x] = cake[x] - mice[i];
continue;
}
if (fab(mice[i] - cake[x]) < fab(mice[i] - cake[x + 1])) {
if (d[x] == -1) {
d[x] = fab(mice[i] - cake[x]);
continue;
}
if (d[x] == fab(mice[i] - cake[x])) continue;
d[x] = min(d[x], fab(mice[i] - cake[x]));
ans++;
} else if (fab(mice[i] - cake[x]) == fab(mice[i] - cake[x + 1])) {
if (d[x] == -1 || d[x] == fab(mice[i] - cake[x]))
d[x] = fab(mice[i] - cake[x]);
else
d[x + 1] = fab(mice[i] - cake[x]);
} else {
if (d[x + 1] == -1)
d[x + 1] = fab(mice[i] - cake[x + 1]);
else {
ans++;
d[x + 1] = fab(mice[i] - cake[x + 1]);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const bool DEBUG = 0;
int to[100100][2];
int dp[100100][2];
int x[100100];
int y[100100];
int n, m;
int tmp;
int main() {
scanf("%d %d %d %d", &n, &m, &tmp, &tmp);
for (int i = 0; i < n; i++) {
scanf("%d", &x[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &y[i]);
}
if (m == 0) {
printf("%d\n", n);
return 0;
}
memset(to, -1, sizeof to);
int j = 0;
for (int i = 0; i < n; i++) {
while (j + 1 < m && abs(y[j + 1] - x[i]) < abs(y[j] - x[i])) j++;
if (j == m - 1) {
to[i][0] = m - 1;
} else if (abs(y[j + 1] - x[i]) == abs(y[j] - x[i])) {
to[i][0] = j;
to[i][1] = j + 1;
} else {
to[i][0] = j;
}
}
dp[0][0] = 0;
dp[0][1] = (to[0][1] == -1 ? 1 : 0);
for (int i = 1; i < n; i++) {
dp[i][0] = dp[i][1] = 100000000;
if (to[i][1] == -1) {
if (to[i - 1][1] == to[i][0]) {
if (abs(y[to[i][0]] - x[i]) == abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
} else if (abs(y[to[i][0]] - x[i]) > abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 1);
} else {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 1);
}
} else if (to[i - 1][0] == to[i][0]) {
if (abs(y[to[i][0]] - x[i]) == abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = dp[i - 1][0];
} else {
dp[i][0] = dp[i - 1][0] + 1;
}
} else {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
}
} else {
if (to[i - 1][0] == to[i][0]) {
if (abs(y[to[i][0]] - x[i]) == abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = dp[i - 1][0];
} else if (abs(y[to[i][0]] - x[i]) > abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = dp[i - 1][0] + 1;
} else {
dp[i][0] = dp[i - 1][0] + 1;
}
} else if (to[i - 1][1] == to[i][0]) {
if (abs(y[to[i][0]] - x[i]) == abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
} else if (abs(y[to[i][0]] - x[i]) > abs(y[to[i][0]] - x[i - 1])) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 1);
} else {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1] + 1);
}
} else {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
}
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]);
}
}
printf("%d\n", min(dp[n - 1][0], dp[n - 1][1]));
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000 + 10;
const int INF = 200000000 + 10;
int N, M, Y0, Y1;
int choose[MAX_N];
int a[MAX_N], b[MAX_N];
int c[MAX_N][2], dis[MAX_N];
void solve() {
scanf("%d%d%d%d", &N, &M, &Y0, &Y1);
for (int i = 0; i < N; ++i) scanf("%d", &a[i]);
for (int i = 0; i < M; ++i) scanf("%d", &b[i]);
int p = 0;
memset(c, -1, sizeof c);
fill(dis, dis + M, INF);
for (int i = 0; i < N; ++i) {
while (p < M - 1 && abs(a[i] - b[p]) > abs(a[i] - b[p + 1])) ++p;
c[i][0] = p;
if (p < M - 1 && abs(a[i] - b[p]) == abs(a[i] - b[p + 1])) c[i][1] = p + 1;
}
for (int i = 0; i < N; ++i) {
if (c[i][1] < 0 || dis[c[i][0]] == abs(a[i] - b[c[i][0]]) ||
dis[c[i][0]] == INF) {
choose[i] = c[i][0];
} else {
choose[i] = c[i][1];
}
dis[choose[i]] = min(dis[choose[i]], abs(a[i] - b[choose[i]]));
}
int ret = 0;
for (int i = 0; i < N; ++i) ret += dis[choose[i]] == abs(a[i] - b[choose[i]]);
cout << N - ret << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans;
const int N = 100010, INF = 0x3f3f3f3f;
int x[N], y[N], best[N];
int main() {
scanf("%d%d%*d%*d", &n, &m);
for (int i = 0; i < (n); i++) scanf("%d", x + i);
for (int i = 1; i <= (m); i++) scanf("%d", y + i);
y[0] = -INF;
y[m + 1] = INF;
memset(best, INF, sizeof(best));
for (int i = 0; i < (n); i++) {
int j = lower_bound(y, y + m + 2, x[i]) - y;
int dis = min(x[i] - y[j - 1], y[j] - x[i]);
if (y[j] - x[i] > dis ||
(x[i] - y[j - 1] == dis && (best[j - 1] == dis || best[j - 1] == INF)))
--j;
if (best[j] == INF || best[j] == dis) ++ans;
best[j] = min(best[j], dis);
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long x[100009], y[100009], D[100009], f[100009];
void r(int j, int d) {
if (D[j] < d) return;
if (D[j] == d) {
f[j]++;
} else
D[j] = d, f[j] = 1;
}
int main() {
int n, m;
cin >> n >> m >> x[0] >> x[0];
for (int i = 1; i <= n; i++) {
cin >> x[i];
}
for (int i = 1; i <= m; i++) {
cin >> y[i];
D[i] = 1e9 + 1;
}
int j = 1;
for (int i = 1; i <= n; i++) {
while (j < m && abs(x[i] - y[j + 1]) < abs(x[i] - y[j])) j++;
int d = abs(x[i] - y[j]);
if (j < m && d == abs(x[i] - y[j + 1])) {
if (f[j] && D[j] != d) {
r(j + 1, d);
} else
r(j, d);
} else
r(j, d);
}
int a = 0;
for (int i = 1; i <= m; i++) a += f[i];
cout << n - a << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:264777216")
int n, m;
const int size = 100100;
int x0[size], x1[size];
long long dis(unsigned long long x1, unsigned long long x2) {
return (x1 - x2) * (x1 - x2);
}
vector<int> v[size];
map<int, int> dp[size];
int rec(int V, int U) {
if (V < 0) return 0;
if (dp[V].find(U) != dp[V].end()) return dp[V][U];
int res = 0;
for (int i = 0; i < v[V].size(); ++i) {
if (v[V][i] == U && dis(x0[V], x1[U]) == dis(x0[V + 1], x1[U])) {
res = max(res, rec(V - 1, v[V][i]) + 1);
} else if (v[V][i] == U) {
res = max(res, rec(V - 1, v[V][i]));
} else {
res = max(res, rec(V - 1, v[V][i]) + 1);
}
}
dp[V][U] = res;
return res;
}
void Solve() {
cin >> n >> m;
int y0, y1;
cin >> y0 >> y1;
for (int i = 0; i < n; ++i) cin >> x0[i];
for (int i = 0; i < m; ++i) cin >> x1[i];
if (m != 0)
for (int i = 0; i < n; ++i) {
int index = lower_bound(x1, x1 + m, x0[i]) - x1;
if (index >= m) --index;
long long rd = dis(x0[i], x1[index]);
if (index - 1 >= 0) rd = min(rd, dis(x0[i], x1[index - 1]));
if (index + 1 < m) rd = min(rd, dis(x0[i], x1[index + 1]));
for (int j = max(0, index - 1); j <= min(index + 1, m - 1); ++j) {
if (rd == dis(x0[i], x1[j])) {
v[i].push_back(j);
}
}
}
int res = 0;
res = max(res, rec(n - 1, -1));
cout << n - res;
}
int main() {
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ti1, ti2;
vector<pair<int, int> > v;
int a[100010], b[100010];
int le[200010], ri[200010];
int ans = 0;
int main() {
scanf("%d%d%d%d", &n, &m, &ti1, &ti2);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
v.push_back(make_pair(a[i], 0));
}
for (int i = 0; i < m; i++) {
scanf("%d", &b[i]);
v.push_back(make_pair(b[i], 1));
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) le[i] = ri[i] = -1;
for (int i = 0; i < v.size(); i++) {
if (v[i].second) continue;
int it = lower_bound(b, b + m, v[i].first) - b, dist = 1e9;
if (it < m) dist = min(dist, abs(b[it] - v[i].first));
if (it) dist = min(dist, abs(b[it - 1] - v[i].first));
if (i && v[i - 1].second && abs(v[i].first - v[i - 1].first) == dist)
le[i] = i - 1, ri[i - 1] = i;
if (i + 1 < v.size() && v[i + 1].second &&
abs(v[i].first - v[i + 1].first) == dist)
le[i + 1] = i, ri[i] = i + 1;
}
for (int i = 0; i < v.size(); i++) {
int j = i;
while (ri[j] != -1) j = ri[j];
if ((j - i + 1) % 2 == 0 || v[j].second)
ans += (j - i + 1) / 2;
else {
ans += (j - i + 1) / 2;
for (int k = i; k <= j; k++) {
if (!v[k].second || le[k] == -1 || ri[k] == -1) continue;
if (abs(v[k].first - v[le[k]].first) ==
abs(v[k].first - v[ri[k]].first)) {
ans++;
break;
}
}
}
i = j;
}
printf("%d", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10, INF = 0x3F3F3F3F;
int a[MAXN], b[MAXN], minn[MAXN];
int main() {
int n, m, i, Y0, Y1, res = 0;
scanf("%d %d %d %d", &n, &m, &Y0, &Y1);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) scanf("%d", &b[i]);
b[0] = -INF;
b[m + 1] = INF;
memset(minn, 0x3F, sizeof(minn));
for (i = 1; i <= n; i++) {
int pos = lower_bound(b, b + m + 2, a[i]) - b,
dis = min(a[i] - b[pos - 1], b[pos] - a[i]);
if (b[pos] - a[i] > dis || (a[i] - b[pos - 1] == dis &&
(minn[pos - 1] == dis || minn[pos - 1] == INF)))
pos--;
if (minn[pos] == INF || minn[pos] == dis) res++;
minn[pos] = min(minn[pos], dis);
}
printf("%d", n - res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101000;
const int INF = 99999999;
int n, m;
int x[maxn], y[maxn], a[maxn][2], dis[maxn], now, ans;
int abs(int a) {
if (a < 0) return -a;
return a;
}
int main() {
for (int i = 0; i < maxn; i++) dis[i] = -1;
int tmp;
cin >> n >> m >> tmp >> tmp;
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < m; i++) cin >> y[i];
for (int i = 0; i < n; i++) {
while (now < m && abs(x[i] - y[now]) > abs(x[i] - y[now + 1])) now++;
a[i][0] = now;
if (now < m && abs(x[i] - y[now]) == abs(x[i] - y[now + 1]))
a[i][1] = ++now;
}
for (int i = 0; i < n; i++) {
if (dis[a[i][0]] == -1 || dis[a[i][0]] == abs(x[i] - y[a[i][0]])) {
ans++;
dis[a[i][0]] = abs(x[i] - y[a[i][0]]);
} else if (a[i][1] != 0) {
ans++;
dis[a[i][1]] = abs(x[i] - y[a[i][1]]);
} else
dis[a[i][0]] = min(dis[a[i][0]], abs(x[i] - y[a[i][0]]));
}
cout << n - ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100000 + 50;
int n, mm, x;
int m[MX], c[MX];
bool cheese[MX];
int comp;
int main() {
cin >> n >> mm >> x >> x;
for (int i = 0; i < n; i++) scanf("%d", &m[i]);
for (int i = 0; i < mm; i++) scanf("%d", &c[i]);
int ind = 0;
int diff = abs(c[0] - m[0]);
for (int i = 0; i < n; i++) {
diff = abs(c[ind] - m[i]);
for (int j = ind + 1; j < mm; j++) {
if (diff > abs(c[j] - m[i])) {
diff = abs(c[j] - m[i]);
ind = j;
} else {
j = mm;
}
}
int q = abs(m[i] - c[ind]);
if (cheese[ind]) {
if (q == abs(m[i - 1] - c[ind])) {
comp++;
} else if (q > abs(m[i - 1] - c[ind]) && q == abs(m[i] - c[ind + 1])) {
comp++;
cheese[ind + 1] = true;
ind++;
} else if (q < abs(m[i - 1] - c[ind]) && q == abs(m[i] - c[ind + 1])) {
comp++;
cheese[ind + 1] = true;
ind++;
}
} else {
cheese[ind] = true;
comp++;
}
}
int cnt = 0;
for (int i = 0; i < mm; i++) {
if (cheese[i]) cnt++;
}
cout << n - comp << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9) * 2;
const long long INFll = 1ll * INF * INF;
const int MOD = 1000000007;
template <class T>
istream& operator>>(istream& in, vector<T>& a) {
for (int i = 0; i < a.size(); ++i) in >> a[i];
return in;
}
template <class T>
ostream& operator<<(ostream& o, vector<T>& a) {
for (int i = 0; i < a.size(); ++i) o << a[i] << " ";
return o;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m, x, y;
cin >> n >> m >> x >> y;
vector<int> a(n), b(m);
cin >> a >> b;
int j = 0;
int ans = 0;
vector<int> used(m, -1);
for (int i = 0; i < n; ++i) {
while (j + 1 < m && abs(a[i] - b[j]) > abs(a[i] - b[j + 1])) j++;
if (j == m) continue;
if (used[j] == -1) {
used[j] = i;
ans++;
} else {
if (abs(a[i] - b[j]) == abs(a[used[j]] - b[j]))
ans++;
else {
if (j + 1 < m && abs(a[i] - b[j]) == abs(a[i] - b[j + 1])) {
j++;
used[j] = i;
ans++;
} else
used[j] = i;
}
}
}
cout << n - ans;
if (0) cerr << "\nTIME = " << clock() << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, y0, y1, i, j, ans, dist;
bool ok;
int a[100011], b[100011], min[100011];
cin >> n >> m >> y0 >> y1;
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= m; i++) cin >> a[i];
for (int i = 1; i <= m; i++) min[i] = 0x7fffffff;
j = 1;
ans = n;
for (int i = 1; i <= n; i++) {
while (j < m && a[j + 1] <= b[i]) j++;
dist = 0x7fffffff;
if (j > 0) dist = abs(a[j] - b[i]);
ok = false;
if (j + 1 <= m)
if (abs(a[j + 1] - b[i]) <= dist) {
dist = abs(a[j + 1] - b[i]);
ok = true;
}
if (j > 0)
if (abs(a[j] - b[i]) == dist)
if (min[j] == 0x7fffffff || min[j] == dist || !ok) {
if (dist < min[j]) {
if (min[j] < 0x7fffffff) ans++;
min[j] = dist;
}
if (dist == min[j]) ans--;
continue;
}
if (dist < min[j + 1]) {
if (min[j + 1] < 0x7fffffff) ans++;
min[j + 1] = dist;
}
if (dist == min[j + 1]) ans--;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100000;
int a[Maxn], b[Maxn];
int main() {
int n, m, y0, y1, i;
scanf("%d%d%d%d", &n, &m, &y0, &y1);
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 k = 0, j = 0, last = -1;
for (i = 0; i < n; ++i) {
while (j < m && abs(a[i] - b[j + 1]) < abs(a[i] - b[j])) ++j;
if (last < j || abs(a[i - 1] - b[j]) == abs(a[i] - b[j]))
++k, last = j;
else if (j < m && abs(a[i] - b[j + 1]) == abs(a[i] - b[j]))
++k, last = ++j;
else
last = j;
}
printf("%d\n", n - k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> smurfs;
int pos[100000][2];
vector<int> berries;
unordered_map<int, pair<int, int> > mp;
unordered_map<int, int> chosen;
int main() {
int n, m, x, y;
cin >> n >> m >> x >> y;
for (int i = 0; i < n; i++) {
int g;
cin >> g;
smurfs.push_back(g);
}
for (int j = 0; j < m; j++) {
int g;
cin >> g;
berries.push_back(g);
mp[g] = {-1, -1};
chosen[g] = -1;
}
for (int i = 0; i < n; i++) {
auto itr = lower_bound(berries.begin(), berries.end(), smurfs[i]);
pos[i][0] = pos[i][1] = -1;
int l = -1, r = -1;
if (itr != berries.begin()) {
itr--;
l = *itr;
itr++;
}
if (itr != berries.end()) {
r = *itr;
}
if (l != -1 && r != -1) {
if (smurfs[i] - l > r - smurfs[i])
l = -1;
else if (smurfs[i] - l < r - smurfs[i])
r = -1;
}
if (l != -1) {
if (mp[l].second != -1) {
l = -1;
} else {
mp[l].second = i;
}
}
if (r != -1) {
if (mp[r].second != -1) {
pos[mp[r].second][1] = -1;
mp[r].second = i;
}
}
pos[i][0] = l;
pos[i][1] = r;
}
int caneat = 0;
for (int i = 0; i < n; i++) {
if (pos[i][0] == -1 && pos[i][1] == -1) continue;
bool eaten = false;
if (pos[i][0] != -1) {
int idxl = chosen[pos[i][0]];
if (idxl == -1) {
caneat++;
chosen[pos[i][0]] = smurfs[i];
eaten = true;
} else if (abs(idxl - pos[i][0]) == abs(pos[i][0] - smurfs[i])) {
caneat++;
eaten = true;
}
}
if (!eaten && pos[i][1] != -1) {
if (chosen[pos[i][1]] == -1) {
caneat++;
chosen[pos[i][1]] = smurfs[i];
} else {
chosen[pos[i][1]] = max(chosen[pos[i][1]], smurfs[i]);
}
}
}
cout << n - caneat << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long sqr(long long x) { return x * x; }
int main(int argc, char **argv) {
long long N, M, y0, y1;
cin >> N >> M >> y0 >> y1;
vector<long long> A(N), B(M);
for (int i = (0); i < (N); ++i) cin >> A[i];
for (int i = (0); i < (M); ++i) cin >> B[i];
int ptr = 0;
long long MinD[M];
for (int i = (0); i < (M); ++i) MinD[i] = 1LL << 59;
int res = 0;
int p1 = 0, p2 = 0;
for (int i = (0); i < (N); ++i) {
while (B[p2] < A[i] && p2 < M) p2++;
p1 = p2;
while (p1 > 0 && B[p1] > A[i]) p1--;
if (p2 == M) p2 = M - 1;
long long d1 = sqr(A[i] - B[p1]), d2 = sqr(A[i] - B[p2]);
if (d1 <= d2) {
if (MinD[p1] == 1LL << 59 || MinD[p1] == d1)
res++, MinD[p1] = d1;
else if ((d2 > d1 || p1 == p2) && MinD[p1] > d1)
MinD[p1] = min(MinD[p1], d1);
else if (d2 == d1 && p2 > p1)
MinD[p2] = d2, res++;
} else {
if (MinD[p2] == 1LL << 59 || MinD[p2] == d2)
MinD[p2] = d2, res++;
else if (MinD[p2] > d2 && p1 != p2)
MinD[p2] = d2;
}
}
cout << N - res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int maxn = 1e5 + 10;
int N, M;
int a[maxn];
int b[maxn];
vector<int> u[maxn];
int n[maxn];
int v[maxn];
int main() {
scanf("%d%d%*d%*d", &N, &M);
if (M == 0) {
printf("%d\n", N);
return 0;
}
for (int i = 0; i < N; i++) scanf("%d", a + i);
for (int i = 0; i < M; i++) scanf("%d", b + i), n[i] = inf;
for (int i = 0, j = 0; i < N; i++) {
while (j < M && b[j] < a[i]) j++;
int na = (j > 0 ? a[i] - b[j - 1] : inf);
int nb = (j < M ? b[j] - a[i] : inf);
if (na <= nb) {
u[i].push_back(j - 1);
}
if (na >= nb) {
u[i].push_back(j);
}
}
int res = 0;
for (int i = 0; i < N; i++) {
if (((int)(u[i]).size()) == 2) continue;
int j = u[i][0];
if (abs(a[i] - b[j]) < n[j]) n[j] = abs(a[i] - b[j]);
}
for (int i = 0; i < N; i++) {
if (((int)(u[i]).size()) == 2) continue;
int j = u[i][0];
if (abs(a[i] - b[j]) > n[j]) res++;
}
for (int i = 0; i < N; i++) {
if (((int)(u[i]).size()) == 1) continue;
int j = u[i][0];
int k = u[i][1];
int nn = a[i] - b[j];
if (n[j] == nn || n[k] == nn) continue;
if (n[j] < nn && n[k] < nn)
res++;
else {
if (n[j] == inf)
n[j] = nn;
else if (n[k] == inf)
n[k] = nn;
else {
res++;
}
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> e[100050];
bool bo[100050];
int p[100050];
int x[100050], y[100050];
int main() {
int n, m, i, j, k, Y0, Y1;
scanf("%d%d%d%d", &n, &m, &Y0, &Y1);
for (i = 0; i < n; ++i) scanf("%d", &x[i]);
for (i = 0; i < m; ++i) scanf("%d", &y[i]);
memset(bo, 0, sizeof(bo));
sort(x, x + n);
sort(y, y + m);
for (i = 0; i < n; ++i) {
int l, r;
l = 0;
r = m - 1;
while (r - l > 1) {
int mid = (l + r) >> 1;
if (y[mid] > x[i])
r = mid;
else
l = mid;
}
int minn = std::min(abs(x[i] - y[l]), abs(x[i] - y[r]));
for (int j = std::max(0, l - 2); j <= std::min(m - 1, r + 2); ++j) {
if (abs(y[j] - x[i]) == minn) {
if (y[j] > x[i] && i < n - 1 && x[i + 1] <= y[j]) continue;
if (y[j] < x[i] && i > 0 && x[i - 1] >= y[j]) continue;
e[i].push_back(j);
}
}
}
int ans = n;
for (i = 0; i < n; ++i) {
if (e[i].size() == 0)
continue;
else if (e[i].size() == 1) {
int id = e[i][0];
if (!bo[id] || p[id] == abs(y[id] - x[i])) {
ans--;
bo[id] = true;
p[id] = abs(y[id] - x[i]);
continue;
}
} else {
int id = e[i][0];
if (!bo[id] || p[id] == abs(y[id] - x[i])) {
ans--;
bo[id] = true;
p[id] = abs(y[id] - x[i]);
continue;
} else {
id = e[i][1];
ans--;
bo[id] = true;
p[id] = abs(y[id] - x[i]);
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5;
int cheese[MAX], mice[MAX];
int eated[MAX];
int ans;
void eat(int cheese_pos, int mice_pos) {
if (eated[cheese_pos] == -1) {
eated[cheese_pos] = mice_pos;
} else {
int old_dis = abs(mice[eated[cheese_pos]] - cheese[cheese_pos]);
int new_dis = abs(cheese[cheese_pos] - mice[mice_pos]);
if (new_dis < old_dis) {
eated[cheese_pos] = mice_pos;
} else if (new_dis == old_dis) {
ans++;
}
}
}
void solve() {
int n, m, y0, y1;
scanf("%d %d %d %d", &n, &m, &y0, &y1);
for (int i = 0; i < n; ++i) {
scanf("%d", &mice[i]);
}
for (int i = 0; i < m; ++i) {
scanf("%d", &cheese[i]);
eated[i] = -1;
}
ans = 0;
int near_right = 0;
for (int i = 0; i < n; ++i) {
while (near_right < m && cheese[near_right] <= mice[i]) {
near_right++;
}
if (near_right == m) {
eat(near_right - 1, i);
} else if (near_right == 0) {
eat(near_right, i);
} else {
int left_distance = mice[i] - cheese[near_right - 1];
int right_distance = cheese[near_right] - mice[i];
if (right_distance < left_distance) {
eat(near_right, i);
} else if (right_distance > left_distance) {
eat(near_right - 1, i);
} else {
if (eated[near_right - 1] == -1) {
eat(near_right - 1, i);
} else {
int prev_dis =
abs(mice[eated[near_right - 1]] - cheese[near_right - 1]);
int new_dis = abs(mice[i] - cheese[near_right - 1]);
if (new_dis == prev_dis) {
eat(near_right - 1, i);
} else {
eat(near_right, i);
}
}
}
}
}
for (int i = 0; i < m; ++i) {
if (eated[i] != -1) {
ans++;
}
}
cout << n - ans;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t > f) t = f;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
const int INF = 1001001001;
int M, N;
int A[100010], B[100010];
int pslen;
pair<int, int> ps[200010];
int is[200010];
int main() {
int i, j, k;
for (; ~scanf("%d%d%*d%*d", &M, &N);) {
for (i = 0; i < M; ++i) {
A[i] = in();
}
for (j = 0; j < N; ++j) {
B[j] = in();
}
pslen = 0;
for (i = 0; i < M; ++i) {
ps[pslen++] = make_pair(A[i], 0);
}
for (j = 0; j < N; ++j) {
ps[pslen++] = make_pair(B[j], 1);
}
ps[pslen++] = make_pair(-INF, 0);
ps[pslen++] = make_pair(+INF, 0);
sort(ps, ps + pslen);
--pslen;
memset(is, 0, sizeof(is));
for (i = 1; i < pslen; ++i)
if (!ps[i].second) {
int d = INF;
j = lower_bound(B, B + N, ps[i].first) - B;
if (j < N) chmin(d, B[j] - ps[i].first);
if (j > 0) chmin(d, ps[i].first - B[j - 1]);
int dl = ps[i - 1].second ? (ps[i].first - ps[i - 1].first) : INF;
int dr = ps[i + 1].second ? (ps[i + 1].first - ps[i].first) : INF;
if (d < INF && d == dl) is[i - 1] = 1;
if (d < INF && d == dr) is[i] = 1;
}
int ans = 0;
for (i = 0; i < pslen; i = j) {
if (is[i]) {
for (j = i; j < pslen && is[j]; ++j)
;
bool share = 0;
for (k = i + 1; k < j; ++k)
if (ps[k].second) {
if (ps[k].first - ps[k - 1].first ==
ps[k + 1].first - ps[k].first) {
share = 1;
}
}
ans += (j - i + 1) / 2;
if (!ps[i].second && !ps[j].second && share) ++ans;
} else {
j = i + 1;
}
}
printf("%d\n", M - ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y;
int p[100010], q[100010], mn[100010];
vector<int> t[100010], v[100010];
bool flag[100010];
inline int dist(int x, int y) { return abs(p[x] - q[y]); }
int main() {
scanf("%d%d%d%d", &n, &m, &x, &y);
memset(mn, 63, sizeof(mn));
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= m; i++) scanf("%d", &q[i]);
q[m + 1] = 1e9;
q[0] = -1e9;
int pos = 1;
for (int i = 1; i <= n; i++) {
while (pos <= m && q[pos] <= p[i]) pos++;
pos--;
if (dist(i, pos) == dist(i, pos + 1)) {
t[i].push_back(pos);
t[i].push_back(pos + 1);
} else if (dist(i, pos) < dist(i, pos + 1)) {
t[i].push_back(pos);
} else {
t[i].push_back(pos + 1);
}
}
for (int i = 1; i <= n; i++)
if (t[i].size() == 1) {
int t1 = t[i][0];
v[t1].push_back(i);
mn[t1] = min(mn[t1], dist(i, t1));
}
for (int i = 1; i <= n; i++)
if (t[i].size() == 1) {
int t1 = t[i][0];
if (dist(i, t1) > mn[t1]) flag[i] = 1;
}
for (int i = 1; i <= n; i++)
if (t[i].size() == 2) {
bool flag1 = 0, flag2 = 0;
int cnt1 = 0, cnt2 = 0;
int t1 = t[i][0], t2 = t[i][1], d = dist(i, t1);
for (int j = 0; j < v[t1].size(); j++) {
if (dist(v[t1][j], t1) < d) flag1 = 1;
if (d < dist(v[t1][j], t1))
if (flag[v[t1][j]] == 0) cnt1++;
}
for (int j = 0; j < v[t2].size(); j++) {
if (dist(v[t2][j], t2) < d) flag2 = 1;
if (d < dist(v[t2][j], t2))
if (flag[v[t2][j]] == 0) cnt2++;
}
if (cnt1 + flag1 <= cnt2 + flag2) {
flag[i] = flag1;
for (int j = 0; j < v[t1].size(); j++)
if (d < dist(v[t1][j], t1)) flag[v[t1][j]] = 1;
v[t1].push_back(i);
} else {
flag[i] = flag2;
for (int j = 0; j < v[t2].size(); j++)
if (d < dist(v[t2][j], t2)) flag[v[t2][j]] = 1;
v[t2].push_back(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += flag[i];
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1e5 + 5, inf = 1000000LL * 1000000LL * 1000000LL;
long long n, m, X0, X1, ans;
long long Yn[MAX_N], Ym[MAX_N];
long long MT[MAX_N];
long long cnt[MAX_N];
pair<pair<long long, long long>, long long> mic[MAX_N];
long long IND = 1;
long long dp[MAX_N][2];
void upd(long long ind, long long dis) {
if (MT[ind] < dis) {
ans++;
return;
}
if (MT[ind] == dis) {
cnt[ind]++;
return;
}
ans += cnt[ind];
MT[ind] = dis;
cnt[ind] = 1;
}
long long calc(long long dis, long long ind) {
if (dis < MT[ind]) return cnt[ind];
if (dis == MT[ind]) return 0;
return 1;
}
long long CALC(long long dis1, long long dis2, long long ind) {
if (dis1 == dis2) {
if (dis1 < MT[ind]) return cnt[ind];
if (dis1 == MT[ind]) return 0;
return 2;
}
dis1 = min(dis1, dis2);
if (dis1 < MT[ind]) return cnt[ind] + 1;
if (dis1 == MT[ind]) return 1;
return 2;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
for (long long i = 0; i < MAX_N; i++) MT[i] = inf;
cin >> n >> m >> X0 >> X1;
if (!m) {
cout << n << "\n";
return 0;
}
for (long long i = 0; i < n; i++) cin >> Yn[i];
for (long long i = 0; i < m; i++) cin >> Ym[i];
long long ind = 0;
for (long long i = 0; i < n; i++) {
while (ind + 1 < m && Ym[ind + 1] <= Yn[i]) ind++;
long long dis1 = inf, dis2 = inf, ind2 = 0;
if (Ym[ind] <= Yn[i])
dis1 = (X1 - X0) * (X1 - X0) + (Yn[i] - Ym[ind]) * (Yn[i] - Ym[ind]);
if (Ym[ind] > Yn[i]) {
dis2 = (X1 - X0) * (X1 - X0) + (Yn[i] - Ym[ind]) * (Yn[i] - Ym[ind]);
ind2 = ind;
} else {
if (ind + 1 < m) {
ind2 = ind + 1;
dis2 = (X1 - X0) * (X1 - X0) +
(Yn[i] - Ym[ind + 1]) * (Yn[i] - Ym[ind + 1]);
}
}
if (dis1 != dis2) {
if (dis1 < dis2)
upd(ind, dis1);
else
upd(ind2, dis2);
} else
mic[IND++] = {{ind, ind2}, dis1};
}
mic[0] = {{-1, -1}, -1};
for (long long i = 1; i < IND; i++) {
dp[i][1] = calc(mic[i].second, mic[i].first.second) +
min(dp[i - 1][0], dp[i - 1][1]);
if (mic[i].first.first != mic[i - 1].first.second)
dp[i][0] = calc(mic[i].second, mic[i].first.first) +
min(dp[i - 1][0], dp[i - 1][1]);
else {
dp[i][0] = calc(mic[i].second, mic[i].first.first) + dp[i - 1][0];
long long tmp =
CALC(mic[i].second, mic[i - 1].second, mic[i].first.first);
if (1 < i) tmp += min(dp[i - 2][0], dp[i - 2][1]);
dp[i][0] = min(dp[i][0], tmp);
}
}
ans += min(dp[IND - 1][0], dp[IND - 1][1]);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int l[100005], r[100005];
int doc[100005], chk[100005];
bool vis[200005];
vector<int> gph[200005];
vector<int> tim[200005];
void add_edge(int s, int e) {
gph[s].push_back(e);
gph[e].push_back(s);
}
int dfs(int x) {
if (vis[x]) return 0;
vis[x] = 1;
int ret = 0;
for (auto &i : gph[x]) ret += dfs(i);
if (x >= n) {
if (tim[x].size() >= 2 && tim[x][0] == tim[x][1])
ret -= 2;
else
ret--;
} else
ret++;
return ret;
}
int main() {
scanf("%d %d %*d %*d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &l[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &r[i]);
}
if (m == 0) {
printf("%d\n", n);
return 0;
}
memset(doc, 0x3f, sizeof(doc));
for (int i = 0; i < n; i++) {
auto w = lower_bound(r, r + m, l[i]);
if (w != r && w != r + m && *w - l[i] == l[i] - *(w - 1)) {
continue;
}
if (w == r + m || (w != r && *w - l[i] > l[i] - *(w - 1))) {
int t = l[i] - *(w - 1);
if (doc[w - r - 1] > t) {
doc[w - r - 1] = t;
chk[w - r - 1] = 1;
} else if (doc[w - r - 1] == t) {
chk[w - r - 1]++;
}
} else {
int t = *w - l[i];
if (doc[w - r] > t) {
doc[w - r] = t;
chk[w - r] = 1;
} else if (doc[w - r] == t) {
chk[w - r]++;
}
}
}
int ret = n;
for (int i = 0; i < m; i++) ret -= chk[i];
vector<int> v;
for (int i = 0; i < n; i++) {
auto w = lower_bound(r, r + m, l[i]);
if (w != r && w != r + m && *w - l[i] == l[i] - *(w - 1)) {
ret--;
if (!chk[w - r - 1] || doc[w - r - 1] == l[i] - *(w - 1)) {
tim[w - r - 1 + n].push_back(l[i] - *(w - 1));
add_edge(w - r - 1 + n, i);
}
if (!chk[w - r] || doc[w - r] == *w - l[i]) {
tim[w - r + n].push_back(*w - l[i]);
add_edge(w - r + n, i);
}
v.push_back(i);
}
}
for (int i = 0; i < n + m; i++) {
sort(tim[i].begin(), tim[i].end());
}
for (auto &i : v) {
if (!vis[i]) {
ret += max(0, dfs(i));
}
}
cout << ret;
}
|
#include <bits/stdc++.h>
using namespace std;
void desperate_optimization(int precision) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(precision);
}
vector<int> a, b;
const int N = 1e5;
int dist[N + 5];
int occ[N + 5];
void hora(int tc) {
int n, m, y0, y1;
cin >> n >> m >> y0 >> y1;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a.push_back(x);
}
for (int i = 0; i < m; i++) {
int x;
cin >> x;
b.push_back(x);
dist[i] = 1e9 - 5;
}
int l = 0;
for (int i = 0; i < n; i++) {
while (l != m && b[l] <= a[i]) l++;
int dist_right = 1e9, dist_left = 1e9;
if (l != m) dist_right = abs(b[l] - a[i]);
if (l) dist_left = abs(b[l - 1] - a[i]);
if (dist_right > dist_left) {
if (dist[l - 1] > dist_left) {
dist[l - 1] = dist_left;
occ[l - 1] = 1;
} else if (dist[l - 1] == dist_left)
occ[l - 1]++;
} else if (dist_right < dist_left) {
if (dist[l] > dist_right) {
dist[l] = dist_right;
occ[l] = 1;
} else if (dist[l] == dist_right)
occ[l]++;
} else {
if (occ[l - 1] && dist[l - 1] != dist_left) {
if (l != m && dist[l] == dist_right)
occ[l]++;
else if (l != m && dist[l] > dist_right) {
dist[l] = dist_right;
occ[l] = 1;
}
} else {
if (l && dist[l - 1] == dist_left)
occ[l - 1]++;
else if (l && dist[l - 1] > dist_left) {
dist[l - 1] = dist_left;
occ[l - 1] = 1;
}
}
}
}
int match = 0;
for (int i = 0; i < m; i++) match += occ[i];
cout << n - match << '\n';
}
int main() {
desperate_optimization(10);
int ntc = 1;
for (int tc = 1; tc <= ntc; tc++) hora(tc);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, a[100100], b[100100], c[100100][2], f[100100][2], res;
int main() {
scanf("%d%d%*d%*d", &n, &m);
res = n;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < m; i++) scanf("%d", &b[i]);
if (m == 0) {
printf("%d\n", n);
return 0;
}
for (i = j = 0; i < n; i++) {
while (j < m && abs(b[j + 1] - a[i]) < abs(b[j] - a[i])) j++;
c[i][0] = j;
if (j < m && abs(b[j + 1] - a[i]) == abs(b[j] - a[i]))
c[i][1] = ++j;
else
c[i][1] = -1;
}
for (i = j = 0; j < 2; j++) f[i][j] = int(c[i][j] >= 0);
for (i = 1; i < n; i++)
for (j = 0; j < 2; j++) {
f[i][j] = max(f[i - 1][0], f[i - 1][1]);
if (c[i][j] >= 0)
for (k = 0; k < 2; k++)
if (c[i - 1][k] != -1)
if (c[i][j] != c[i - 1][k] ||
(c[i][j] == c[i - 1][k] &&
abs(a[i] - b[c[i][j]]) == abs(a[i - 1] - b[c[i][j]])))
f[i][j] = max(f[i][j], f[i - 1][k] + 1);
}
if (c[n - 1][1] == -1) f[n - 1][1] = f[n - 1][0];
printf("%d\n", res - max(f[n - 1][0], f[n - 1][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = (1 << 20);
long long myabs(long long x) { return x > 0 ? x : -x; }
long long n, m, y;
long long x[2][MAXN];
void read() {
cin >> n >> m >> y >> y;
for (long long i = 0; i < n; i++) cin >> x[0][i];
for (long long i = 0; i < m; i++) cin >> x[1][i];
for (long long i = 0; i < n; i++) x[0][i] += 10 * MAXN;
for (long long i = 0; i < m; i++) x[1][i] += 10 * MAXN;
}
long long best[20 * MAXN];
void solve() {
set<long long> st;
for (long long i = 0; i < m; i++)
best[x[1][i]] = (long long)1e9 + 42, st.insert(x[1][i]);
long long ans = n;
sort(x[0], x[0] + n);
for (long long i = 0; i < n; i++) {
auto bst = st.lower_bound(x[0][i]);
long long bst_x = -1;
if (bst == st.end())
bst = prev(bst);
else if (bst != st.begin() && x[0][i] - *prev(bst) <= *bst - x[0][i])
bst = prev(bst);
bst_x = *bst;
if (best[bst_x] == myabs(x[0][i] - bst_x) ||
best[bst_x] == (long long)1e9 + 42)
ans--;
else if (next(bst) != st.end()) {
long long nw_bst_x = *next(bst);
if (myabs(x[0][i] - bst_x) == myabs(x[0][i] - nw_bst_x))
bst_x = nw_bst_x, ans--;
}
best[bst_x] = min(best[bst_x], myabs(x[0][i] - bst_x));
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
int n, m;
int a[100005];
int b[100005];
int res = 0;
int w;
int main(void) {
scanf("%d %d %d %d", &n, &m, &w, &w);
b[m + 1] = mod;
for (int(i) = 0; (i) < (long long)(n); ++(i)) {
scanf("%d", a + i + 1);
}
for (int(i) = 0; (i) < (long long)(m); ++(i)) {
scanf("%d", b + i + 1);
}
int it = 1;
int last = 0;
for (int i = 1; i <= n; ++i) {
while (abs(a[i] - b[it]) > abs(a[i] - b[it + 1])) {
++it;
}
if (it > last || abs(a[i] - b[last]) == abs(a[i - 1] - b[last])) {
last = it;
continue;
}
if (abs(a[i] - b[it]) == abs(a[i] - b[it + 1])) {
last = ++it;
continue;
}
++res;
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 100010;
int x0[maxn], x1[maxn], d[maxn], c[maxn];
int main() {
int n, m, y0, y1;
cin >> n >> m >> y0 >> y1;
for (int i = 0; i < n; ++i) {
cin >> x0[i];
}
memset(d, -1, sizeof(d));
for (int i = 0; i < m; ++i) {
cin >> x1[i];
}
int p = 0, k = 0, last = -1;
for (int i = 0; i < n; ++i) {
while (p < m && abs(x0[i] - x1[p]) > abs(x0[i] - x1[p + 1])) ++p;
if (last < p || abs(x0[i - 1] - x1[p]) == abs(x0[i] - x1[p]))
++k, last = p;
else if (p < m && abs(x0[i] - x1[p]) == abs(x0[i] - x1[p + 1]))
++k, last = ++p;
else
last = p;
}
cout << n - k << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, a[100100], b[100100], c[100100][2], f[100100][2], res;
int main() {
scanf("%d%d%*d%*d", &n, &m);
res = n;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < m; i++) scanf("%d", &b[i]);
if (m == 0) {
printf("%d\n", n);
return 0;
}
for (i = j = 0; i < n; i++) {
while (j < m && abs(b[j + 1] - a[i]) < abs(b[j] - a[i])) j++;
c[i][0] = j;
if (j < m && abs(b[j + 1] - a[i]) == abs(b[j] - a[i])) {
c[i][1] = ++j;
} else
c[i][1] = -1;
}
for (i = j = 0; j < 2; j++) f[i][j] = int(c[i][j] >= 0);
for (i = 1; i < n; i++)
for (j = 0; j < 2; j++) {
f[i][j] = max(f[i - 1][0], f[i - 1][1]);
if (c[i][j] >= 0)
for (k = 0; k < 2; k++)
if (c[i - 1][k] != -1)
if (c[i][j] != c[i - 1][k] ||
(c[i][j] == c[i - 1][k] &&
abs(a[i] - b[c[i][j]]) == abs(a[i - 1] - b[c[i][j]])))
f[i][j] = max(f[i][j], f[i - 1][k] + 1);
}
if (c[n - 1][1] == -1) f[n - 1][1] = f[n - 1][0];
printf("%d\n", res - max(f[n - 1][0], f[n - 1][1]));
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m, useless;
int a[100010], b[100010];
int unhappy = 0;
int match[100010], cnt[100010];
int dp[2][2];
int main() {
scanf("%d%d%d%d", &n, &m, &useless, &useless);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= m; ++i) scanf("%d", &b[i]);
for (int i = 1; i <= m; ++i) match[i] = INF;
int las = 0, nex = 1;
vector<pair<int, int> > v;
deque<int> dis;
for (int i = 1; i <= n; ++i) {
while (nex <= m && b[nex] < a[i]) ++nex;
while (las < m && b[las + 1] < a[i]) ++las;
int ti;
if (nex != m + 1 && las && b[nex] - a[i] == a[i] - b[las]) {
v.push_back(make_pair(las, nex));
dis.push_back(b[nex] - a[i]);
continue;
} else {
if (!las || (nex != m + 1 && b[nex] - a[i] < a[i] - b[las])) {
ti = nex;
} else {
ti = las;
}
}
if (match[ti] > abs(a[i] - b[ti])) {
unhappy += cnt[ti];
cnt[ti] = 0;
} else {
if (match[ti] < abs(a[i] - b[ti])) {
unhappy++;
cnt[ti]--;
}
}
match[ti] = min(match[ti], abs(a[i] - b[ti]));
cnt[ti]++;
}
int now = 1, pre = 0;
pair<int, int> last = make_pair(INF, INF);
int lasdist = INF;
dp[0][0] = 0;
dp[0][1] = INF;
for (auto it : v) {
int dist = dis.front();
dis.pop_front();
memset(dp[now], 63, sizeof(dp[now]));
if (last.second != it.first) {
int best = min(dp[pre][0], dp[pre][1]);
dp[now][0] = best + (match[it.first] < dist
? 1
: (match[it.first] == dist ? 0 : cnt[it.first]));
dp[now][1] =
best + (match[it.second] < dist
? 1
: (match[it.second] == dist ? 0 : cnt[it.second]));
} else {
int best = min(dp[pre][0], dp[pre][1]);
dp[now][1] =
best + (match[it.second] < dist
? 1
: (match[it.second] == dist ? 0 : cnt[it.second]));
dp[now][0] =
dp[pre][0] + (match[it.first] < dist
? 1
: (match[it.first] == dist ? 0 : cnt[it.first]));
if (lasdist != INF) {
int ncnt, nmatch;
ncnt = cnt[it.first];
nmatch = match[it.first];
if (lasdist > nmatch) {
} else {
if (lasdist == nmatch) {
ncnt++;
} else {
ncnt = 1;
nmatch = lasdist;
}
}
dp[now][0] =
min(dp[now][0],
dp[pre][1] + (nmatch < dist ? 1 : (nmatch == dist ? 0 : ncnt)));
}
}
lasdist = dist;
last = it;
swap(now, pre);
}
unhappy += min(dp[pre][0], dp[pre][1]);
printf("%d\n", unhappy);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100000];
int b[100000];
int main() {
int n, m, y0, y1;
cin >> n >> m >> y0 >> y1;
for (int x = 0; x < n; ++x) {
cin >> a[x];
}
for (int x = 0; x < m; ++x) {
cin >> b[x];
}
int i = 0, j = 0, pp = -1;
int kk = 0;
for (int x = 0; x < n; ++x) {
while (j < m && abs(a[x] - b[j + 1]) < abs(a[x] - b[j])) j++;
if (j != pp || abs(a[x] - b[j]) == abs(a[x - 1] - b[j])) {
kk++;
pp = j;
} else if (j + 1 < m && abs(a[x] - b[j]) == abs(a[x] - b[j + 1])) {
kk++;
pp = ++j;
} else
pp = j;
}
cout << n - kk << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, sty, eny;
long long a[1000001], b[1000001], e[1000001];
long long qn, q[1000001];
long long f[1000001][2], res;
inline long long dist(long long x, long long xx) {
return ((x - xx) * (x - xx)) + ((sty - eny) * (sty - eny));
}
inline long long work(long long st, long long en) {
f[st - 1][0] = 0, f[st - 1][1] = 9000000000000000ll;
long long la = 9000000000000000ll;
for (long long i = st; i <= en; ++i) {
long long d = dist((b[i + 1] + b[i]) >> 1, b[i]);
f[i][0] =
((f[i][0]) < (f[i - 1][0] - (e[i] == 9000000000000000ll || e[i] == d))
? (f[i][0])
: (f[i - 1][0] - (e[i] == 9000000000000000ll || e[i] == d)));
long long tmp = f[i - 1][1];
f[i][0] =
((f[i][0]) < (f[i - 1][1] - (((la) < (e[i]) ? (la) : (e[i])) == d) +
(la == e[i] && la != d))
? (f[i][0])
: (f[i - 1][1] - (((la) < (e[i]) ? (la) : (e[i])) == d) +
(la == e[i] && la != d)));
f[i][1] = ((f[i][1]) < (f[i - 1][0] -
(e[i + 1] == 9000000000000000ll || e[i + 1] == d))
? (f[i][1])
: (f[i - 1][0] -
(e[i + 1] == 9000000000000000ll || e[i + 1] == d)));
f[i][1] = ((f[i][1]) < (f[i - 1][1] -
(e[i + 1] == 9000000000000000ll || e[i + 1] == d))
? (f[i][1])
: (f[i - 1][1] -
(e[i + 1] == 9000000000000000ll || e[i + 1] == d)));
la = d;
}
return ((f[en][0]) < (f[en][1]) ? (f[en][0]) : (f[en][1]));
}
int main() {
scanf("%I64d%I64d%I64d%I64d", &n, &m, &sty, &eny);
eny -= sty, sty = 0;
for (long long i = 1; i <= n; ++i)
scanf("%I64d", &a[i]), f[i][0] = f[i][1] = 9000000000000000ll;
for (long long i = 1; i <= m; ++i) {
scanf("%I64d", &b[i]);
e[i] = 9000000000000000ll;
}
res = n;
for (long long i = 1, j = 1; i <= n; ++i) {
while (j < m && b[j + 1] < a[i]) j++;
long long d1, d2;
if (j < m)
d2 = dist(a[i], b[j + 1]);
else
d2 = 9000000000000000ll;
d1 = dist(a[i], b[j]);
if (d1 != d2) {
if (d1 < d2)
e[j] = ((e[j]) < (d1) ? (e[j]) : (d1));
else
e[j + 1] = ((e[j + 1]) < (d2) ? (e[j + 1]) : (d2));
}
}
for (long long i = 1, j = 1; i <= n; ++i) {
while (j < m && b[j + 1] < a[i]) j++;
long long d1, d2;
if (j < m)
d2 = dist(a[i], b[j + 1]);
else
d2 = 9000000000000000ll;
d1 = dist(a[i], b[j]);
if (d1 != d2) {
if (d1 < d2)
res -= d1 == e[j];
else
res -= d2 == e[j + 1];
} else
q[++qn] = j;
}
for (long long i = 1; i <= qn;) {
long long j = i + 1;
while (j <= qn && q[j] == q[j - 1] + 1) j++;
j--;
res += work(q[i], q[j]);
i = j + 1;
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class TaskB {
public:
void solve(std::istream& cin, std::ostream& cout) {
long long n, m, y;
long long ans = 0;
cin >> n >> m >> y >> y;
vector<long long> v1(n), v2(m);
vector<long long> used(m, 2e18);
if (m == 0) {
cout << n;
return;
}
for (long long i = 0; i < n; i++) cin >> v1[i];
for (long long i = 0; i < m; i++) cin >> v2[i];
for (long long i = 0; i < n; i++) {
long long it = lower_bound(v2.begin(), v2.end(), v1[i]) - v2.begin();
long long len1 = 1e18, len2 = 1e18;
if (it != v2.size()) len1 = abs(v1[i] - v2[it]);
if (it != 0) len2 = abs(v1[i] - v2[it - 1]);
if (len1 == len2)
if (used[it - 1] == 2e18 || used[it - 1] == len2)
used[it - 1] = len2;
else if (used[it] == 2e18 || used[it] == len1)
used[it] = len1;
else if (used[it - 1] >= len2)
used[it - 1] = len2;
else if (used[it] >= len1)
used[it] = len1;
else
ans++;
else if (len1 > len2)
if (used[it - 1] == 2e18 || used[it - 1] >= len2) {
ans += (used[it - 1] != 2e18 && used[it - 1] > len2);
used[it - 1] = len2;
} else
ans++;
else if (used[it] == 2e18 || used[it] >= len1) {
ans += (used[it] != 2e18 && len1 < used[it]);
used[it] = len1;
} else
ans++;
}
cout << ans;
}
};
int main() {
TaskB solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int main() {
int nm, nc, y;
cin >> nm >> nc >> y >> y;
vector<int> m(nm), c(nc + 2), dc(nc + 2, INF);
for (int i = 0; i < nm; ++i) cin >> m[i];
c[0] = -INF;
dc[0] = 0, dc[nc + 1] = 0;
for (int i = 1; i <= nc; ++i) cin >> c[i];
c[nc + 1] = INF + 1;
int inc = 0, k = 0;
for (int i = 0; i < nm; ++i) {
if (c[inc] > m[i]) --inc;
int to_left, to_right, l, r;
while (c[inc] < m[i]) ++inc;
if (c[inc] > m[i]) --inc;
to_left = m[i] - c[inc];
l = inc;
if (m[i] != c[inc]) ++inc;
r = inc;
to_right = c[inc] - m[i];
if (dc[r] && (to_right < to_left)) {
if (dc[r] == INF) ++k;
dc[r] = to_right;
} else {
if (dc[l] == INF) {
dc[l] = to_left;
++k;
} else if (dc[l] == to_left)
++k;
else {
if (to_left == to_right)
if (l != r) {
dc[r] = to_right;
++k;
} else
dc[l] = 0;
else if (to_left < dc[l])
dc[l] = to_left;
}
}
}
cout << nm - k;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> M;
int a[100010], b[100010], to[100010], t[100010];
int main() {
int n, m;
scanf("%d%d%*d%*d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d", &b[i]);
M[b[i]] = i;
}
memset(t, 63, sizeof(t));
int inf = t[0];
for (int i = 1; i <= n; i++) {
map<int, int>::iterator p = M.lower_bound(a[i]);
if (p == M.begin()) {
to[i] = 1;
t[1] = min(t[1], abs(a[i] - b[1]));
continue;
} else if (p == M.end()) {
to[i] = m;
t[m] = min(t[m], abs(a[i] - b[m]));
}
int pos = p->second, t1 = abs(a[i] - b[pos - 1]), t2 = abs(a[i] - b[pos]),
k;
if (t1 != t2)
k = t1 < t2 ? pos - 1 : pos;
else if (t[pos - 1] == inf || t[pos - 1] == t1)
k = pos - 1;
else
k = pos;
to[i] = k;
t[k] = min(t[k], min(t1, t2));
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int x = to[i];
ans += t[x] != abs(a[i] - b[x]);
}
printf("%d\n", ans);
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ya, yb, a[100003], b[100003], l[100003], dp[2][100003], ans;
int main() {
cin >> n >> m >> ya >> yb;
ans = n;
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 1; i <= m; i++) scanf("%d", b + i);
b[0] = -998244353;
m++;
b[m] = 998244353;
m++;
for (int i = 0; i < m; i++) l[i] = 998244353;
for (int i = 0; i < n; i++) {
int j = lower_bound(b, b + m, a[i]) - b;
int d = min(a[i] - b[j - 1], b[j] - a[i]);
if (b[j] - a[i] > d ||
(a[i] - b[j - 1] == d && (l[j - 1] == 998244353 || l[j - 1] == d)))
j--;
if (l[j] == 998244353 || l[j] == d) ans--;
l[j] = min(l[j], d);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int inf = 1e9 + 10;
int dp[maxn][2];
vector<int> g[maxn];
int n, m, a[maxn], b[maxn], Y0, Y1;
int main() {
scanf("%d%d%d%d", &n, &m, &Y0, &Y1);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
if (n == 0) {
printf("0\n");
return 0;
}
if (m == 0) {
printf("%d\n", n);
return 0;
}
int p = 0;
for (int i = 0; i < n; i++) {
while (p + 1 < m && abs(a[i] - b[p + 1]) <= abs(a[i] - b[p])) p++;
if (p - 1 >= 0 && abs(a[i] - b[p - 1]) == abs(a[i] - b[p]))
g[i].push_back(p - 1);
g[i].push_back(p);
}
for (int i = 0; i < maxn; i++) dp[i][0] = dp[i][1] = inf;
for (int i = 0; i < g[0].size(); i++) dp[0][i] = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < g[i].size(); j++) {
if (dp[i][j] == inf) continue;
int id1 = g[i][j];
for (int k = 0; k < g[i + 1].size(); k++) {
int id2 = g[i + 1][k];
dp[i + 1][k] =
min(dp[i + 1][k],
dp[i][j] + (id1 == id2 &&
abs(a[i] - b[id1]) != abs(a[i + 1] - b[id2])));
}
}
}
int ans = inf;
for (int i = 0; i < g[n - 1].size(); i++) ans = min(ans, dp[n - 1][i]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100001], b[100000];
int main() {
int n, m, y0, y1, i;
scanf("%d%d%d%d", &n, &m, &y0, &y1);
for (i = 0; i < n; ++i) scanf("%d", &a[i]);
for (i = 0; i < m; ++i) scanf("%d", &b[i]);
int k = 0, j = 0, krak = -1;
for (i = 0; i < n; ++i) {
while (j < m && abs(a[i] - b[j + 1]) < abs(a[i] - b[j])) ++j;
if (krak < j || abs(a[i - 1] - b[j]) == abs(a[i] - b[j]))
++k, krak = j;
else if (j < m && abs(a[i] - b[j + 1]) == abs(a[i] - b[j]))
++k, krak = ++j;
else
krak = j;
}
printf("%d\n", n - k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y;
int p[100010], q[100010];
vector<int> t[100010], v[100010];
int mn[100010];
bool flag[100010];
inline int dist(int x, int y) {
if (p[x] - q[y] >= 0)
return p[x] - q[y];
else
return q[y] - p[x];
}
int main() {
scanf("%d%d%d%d", &n, &m, &x, &y);
memset(mn, 63, sizeof(mn));
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
for (int i = 1; i <= m; i++) scanf("%d", &q[i]);
q[m + 1] = 1e9;
q[0] = -1e9;
int pos = 1;
for (int i = 1; i <= n; i++) {
while (pos <= m && q[pos] <= p[i]) pos++;
pos--;
if (dist(i, pos) == dist(i, pos + 1)) {
t[i].push_back(pos);
t[i].push_back(pos + 1);
} else if (dist(i, pos) < dist(i, pos + 1)) {
t[i].push_back(pos);
} else {
t[i].push_back(pos + 1);
}
}
for (int i = 1; i <= n; i++)
if (t[i].size() == 1) {
int t1 = t[i][0];
v[t1].push_back(i);
mn[t1] = min(mn[t1], dist(i, t1));
}
for (int i = 1; i <= n; i++)
if (t[i].size() == 1) {
if (dist(i, t[i][0]) > mn[t[i][0]]) flag[i] = 1;
}
for (int i = 1; i <= n; i++)
if (t[i].size() == 2) {
bool flag1 = 0, flag2 = 0;
int cnt1 = 0, cnt2 = 0;
int t1 = t[i][0], t2 = t[i][1], d = dist(i, t1);
for (int j = 0; j < v[t1].size(); j++) {
if (dist(v[t1][j], t1) < d) flag1 = 1;
if (d < dist(v[t1][j], t1))
if (flag[v[t1][j]] == 0) cnt1++;
}
for (int j = 0; j < v[t2].size(); j++) {
if (dist(v[t2][j], t2) < d) flag2 = 1;
if (d < dist(v[t2][j], t2))
if (flag[v[t2][j]] == 0) cnt2++;
}
if (cnt1 + flag1 <= cnt2 + flag2) {
if (flag1) flag[i] = 1;
for (int j = 0; j < v[t1].size(); j++) {
if (d < dist(v[t1][j], t1))
if (flag[v[t1][j]] == 0) flag[v[t1][j]] = 1;
}
mn[t1] = min(mn[t1], dist(i, t1));
v[t1].push_back(i);
} else {
if (flag2) flag[i] = 1;
for (int j = 0; j < v[t2].size(); j++) {
if (d < dist(v[t2][j], t2))
if (flag[v[t2][j]] == 0) flag[v[t2][j]] = 1;
}
mn[t2] = min(mn[t2], dist(i, t2));
v[t2].push_back(i);
}
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += flag[i];
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[111111], X[111111], n, m, nouse1, nouse2, match[111111], dis[111111];
int main() {
scanf("%d %d %d %d", &n, &m, &nouse1, &nouse2);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
sort(x + 1, x + n + 1);
for (int i = 1; i <= m; i++) scanf("%d", &X[i]);
sort(X + 1, X + m + 1);
X[0] = -1000000000;
X[m + 1] = 1000000000;
memset(match, 0, sizeof(match));
int hungry = n;
for (int i = 1; i <= n; i++) {
int l = 0, r = m + 1;
while (l < r - 1) {
int mid = (l + r) / 2;
if (X[mid] > x[i])
r = mid;
else
l = mid;
}
int y;
if (X[l] > x[i])
y = l;
else
y = r;
int d = min(X[y] - x[i], x[i] - X[y - 1]);
if (X[y] - x[i] > d ||
(x[i] - X[y - 1] == d && (match[y - 1] == 0 || dis[y - 1] == d)))
y--;
if (match[y] == 0 || dis[y] == d) hungry--;
if (match[y] == 0) {
match[y] = 1;
dis[y] = d;
} else
dis[y] = min(dis[y], d);
}
cout << hungry << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[110000], b[110000], d[110000], n, m, a1, a2;
const int INF = 192837465;
int main() {
scanf("%d%d%d%d", &n, &m, &a1, &a2);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
b[0] = -INF;
for (int i = 1; i <= m; i++) scanf("%d", b + i);
for (int i = 1; i <= m; i++) d[i] = INF;
b[m + 1] = INF;
m++;
int ans = 0;
for (int i = 1; i <= n; i++) {
int j = lower_bound(b, b + m, a[i]) - b;
int D = min(a[i] - b[j - 1], b[j] - a[i]);
if (b[j] - a[i] > D ||
(a[i] - b[j - 1] == D && (d[j - 1] == INF || d[j - 1] == D)))
j--;
if (d[j] == INF || d[j] == D) ans++;
d[j] = min(d[j], D);
}
printf("%d\n", n - ans);
}
|
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
const int N = 100005;
multiset<int> st[N];
int f[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
fill(f, f + N, -1);
int n, m, y1, y2;
cin >> n >> m >> y1 >> y2;
vector<int> p1(n), p2(m);
for (int& i : p1) {
cin >> i;
}
for (int& i : p2) {
cin >> i;
}
sort((p1).begin(), (p1).end());
sort((p2).begin(), (p2).end());
vector<pair<int, int>> can;
for (int i = 0; i < n; ++i) {
int l = -1, r = m;
while (r - l > 1) {
int mid = (l + r) / 2;
if (p2[mid] < p1[i]) {
l = mid;
} else {
r = mid;
}
}
if (l == -1) {
st[l + 1].insert(abs(p1[i] - p2[l + 1]));
} else {
if (l + 1 < m) {
int d1 = abs(p1[i] - p2[l]);
int d2 = abs(p1[i] - p2[l + 1]);
if (d1 < d2) {
st[l].insert(d1);
} else if (d2 < d1) {
st[l + 1].insert(d2);
} else {
can.push_back({l, d1});
}
} else {
st[l].insert(abs(p1[i] - p2[l]));
}
}
}
int res = 0;
for (int i = 0; i < N; ++i) {
if (st[i].size()) {
int mn = *st[i].begin();
for (int j : st[i]) {
if (j != mn) res++;
}
f[i] = mn;
}
}
for (auto i : can) {
if (f[i.first] == i.second) {
continue;
}
if (f[i.first + 1] == i.second) {
continue;
}
if (f[i.first] == -1) {
f[i.first] = i.second;
continue;
}
if (f[i.first + 1] == -1) {
f[i.first + 1] = i.second;
continue;
}
res++;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 0;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return f ? x : -x;
}
const long long N = 1e5 + 5;
long long n, m, xm[N], xc[N], l[N], r[N], best[N], ans, x = 1;
signed main() {
memset(best, 0x3f, sizeof(best));
n = read(), m = read();
read();
read();
for (long long i = 1; i <= n; i++) xm[i] = read();
for (long long i = 1; i <= m; i++) xc[i] = read();
xc[0] = INT_MIN;
xc[m + 1] = INT_MAX;
for (long long i = 1; i <= n; i++) {
while (xc[x] < xm[i]) x++;
l[i] = x - 1;
r[i] = x;
}
for (long long i = 1; i <= n; i++) {
long long dis1 = abs(xc[l[i]] - xm[i]), dis2 = abs(xc[r[i]] - xm[i]);
long long dis = min(dis1, dis2), c = r[i];
if (dis2 > dis1 || (dis1 == dis2 && (best[l[i]] == 0x3f3f3f3f3f3f3f3f ||
best[l[i]] == dis)))
c--;
if (best[c] == dis || best[c] == 0x3f3f3f3f3f3f3f3f) ans++;
best[c] = min(best[c], dis);
}
printf("%lld", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
int n, m, i, j, k, p, z, a[100100], b[100100], c[100100][2], f[100100][2], res;
int main() {
scanf("%d%d%*d%*d", &n, &m);
res = n;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < m; i++) scanf("%d", &b[i]);
if (m == 0) {
printf("%d\n", n);
return 0;
}
for (i = j = 0; i < n; i++) {
while (j < m &&
(b[j + 1] - a[i] < 0 ? -1 * (b[j + 1] - a[i]) : b[j + 1] - a[i]) <
(b[j] - a[i] < 0 ? -1 * (b[j] - a[i]) : b[j] - a[i]))
j++;
c[i][0] = j;
if (j < m &&
(b[j + 1] - a[i] < 0 ? -1 * (b[j + 1] - a[i]) : b[j + 1] - a[i]) ==
(b[j] - a[i] < 0 ? -1 * (b[j] - a[i]) : b[j] - a[i]))
c[i][1] = ++j;
else
c[i][1] = -1;
}
for (i = j = 0; j < 2; j++) f[i][j] = int(c[i][j] >= 0);
for (i = 1; i < n; i++)
for (j = 0; j < 2; j++) {
f[i][j] = (f[i - 1][0] > f[i - 1][1] ? f[i - 1][0] : f[i - 1][1]);
if (c[i][j] >= 0)
for (k = 0; k < 2; k++)
if (c[i - 1][k] != -1)
if (c[i][j] != c[i - 1][k] ||
(c[i][j] == c[i - 1][k] &&
(a[i] - b[c[i][j]] < 0 ? -1 * (a[i] - b[c[i][j]])
: a[i] - b[c[i][j]]) ==
(a[i - 1] - b[c[i][j]] < 0 ? -1 * (a[i - 1] - b[c[i][j]])
: a[i - 1] - b[c[i][j]])))
f[i][j] = (f[i][j] > f[i - 1][k] + 1 ? f[i][j] : f[i - 1][k] + 1);
}
if (c[n - 1][1] == -1) f[n - 1][1] = f[n - 1][0];
printf("%d\n", res - (f[n - 1][0] > f[n - 1][1] ? f[n - 1][0] : f[n - 1][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, y, Y, it = 1, x1[100001], x2[100001], d[100001], u[100001];
int dist(int x, int y) { return abs(x - y); }
int main() {
scanf("%d%d%d%d", &n, &m, &y, &Y);
for (int i = 1; i <= n; i++) scanf("%d", &x1[i]);
for (int i = 1; i <= m; i++) {
scanf("%d", &x2[i]);
d[i] = 100000000;
}
x2[0] = -100000000;
x2[m + 1] = 100000000;
int ans = 0;
for (int i = 1; i <= n; i++) {
while (dist(x1[i], x2[it]) > dist(x1[i], x2[it + 1])) it++;
if (u[it] == 0 || d[it] == dist(x1[i], x2[it])) {
ans++;
u[it] = 1;
} else if (dist(x1[i], x2[it]) == dist(x1[i], x2[it + 1])) {
ans++;
u[it + 1] = 1;
}
d[it] = min(d[it], dist(x1[i], x2[it]));
d[it + 1] = min(d[it + 1], dist(x1[i], x2[it + 1]));
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100500;
vector<int> c, m;
vector<multiset<int> > s;
int main() {
int n, mm, y1, y2, i, x;
s.resize(MaxN);
cin >> n >> mm >> y1 >> y2;
for (i = 0; i < n; i++) {
cin >> x;
m.push_back(x);
}
for (i = 0; i < mm; i++) {
cin >> x;
c.push_back(x);
}
for (i = 0; i < n; i++) {
vector<int>::iterator it, it1;
it = lower_bound(c.begin(), c.end(), m[i]);
it1 = it;
it1--;
if (abs(*it - m[i]) < abs(*it1 - m[i]) || (it == c.begin())) {
s[it - c.begin()].insert(abs(*it - m[i]));
continue;
}
if ((it != c.begin()) && (abs(*it - m[i])) > abs(*it1 - m[i])) {
it--;
s[it - c.begin()].insert(abs(*it - m[i]));
continue;
}
if ((abs(*it - m[i]) == abs(*it1 - m[i])) && (it != c.begin())) {
int d = *it - m[i];
d = abs(d);
it--;
if ((*s[it - c.begin()].begin() == d) ||
(s[it - c.begin()].size() == 0)) {
s[it - c.begin()].insert(abs(d));
} else {
it++;
s[it - c.begin()].insert(abs(d));
}
}
}
int ans = 0;
for (i = 0; i < mm; i++) {
if (s[i].size()) {
ans++;
int d = *s[i].begin();
s[i].erase(s[i].begin());
while ((d == *s[i].begin()) && (s[i].size())) {
s[i].erase(s[i].begin());
ans++;
}
}
}
cout << n - ans << endl;
cin.get();
cin.get();
}
|
#include <bits/stdc++.h>
const int inf = 1000000000;
int an, bn, sol;
int a[100050], b[100050];
int adst[100050], bdst[100050];
int marked[100050];
inline int abs(int x) { return x >= 0 ? x : 0 - x; }
inline int min(int a, int b) { return a < b ? a : b; }
inline int max(int a, int b) { return a > b ? a : b; }
inline bool connect(int j, int d) {
if (d > bdst[j]) return 0;
if (d < bdst[j]) {
bdst[j] = d;
if (marked[j]) return 0;
sol -= marked[j];
sol++;
marked[j] = 1;
return 1;
}
marked[j]++;
sol++;
return 1;
}
inline int solve() {
int i, j, d1, d2;
for (i = 0; i < bn; i++) {
marked[i] = 0;
bdst[i] = inf;
}
j = 0;
sol = 0;
for (i = 0; i < an; i++) {
while (j < bn && b[j] <= a[i]) j++;
if (j)
d1 = abs(a[i] - b[j - 1]);
else
d1 = inf;
if (j < bn)
d2 = abs(a[i] - b[j]);
else
d2 = inf;
if (d1 < d2)
connect(j - 1, d1);
else if (d1 > d2)
connect(j, d2);
else {
if (!connect(j - 1, d1)) connect(j, d1);
}
}
return an - sol;
}
int main(void) {
int i, j;
while (scanf("%d %d %*d %*d", &an, &bn) == 2) {
for (i = 0; i < an; i++) scanf("%d", a + i);
for (i = 0; i < bn; i++) scanf("%d", b + i);
printf("%d\n", solve());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005, inf = 1000000000;
int x[maxn], y[maxn];
int dp[maxn][2], good[maxn];
int main() {
int n, m, i, j, y0, y1, ans;
cin >> n >> m >> y0 >> y1;
if (!m) {
cout << n;
return 0;
}
for (i = 1; i <= n; i++) cin >> x[i];
for (j = 1; j <= m; j++) cin >> y[j];
y[0] = -inf;
y[m + 1] = inf;
i = j = 1;
for (; i <= n; i++) {
while (y[j] < x[i]) j++;
good[i] = j;
}
for (i = 0; i <= n; i++) dp[i][0] = dp[i][1] = inf;
dp[0][0] = 0;
for (i = 0; i < n; i++) {
if (dp[i][0] < inf) {
if (good[i + 1] > 1 &&
y[good[i + 1]] - x[i + 1] >= x[i + 1] - y[good[i + 1] - 1]) {
if (good[i + 1] != good[i])
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0]);
else
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0] + 1);
}
if (good[i + 1] != m + 1 &&
y[good[i + 1]] - x[i + 1] <= x[i + 1] - y[good[i + 1] - 1])
dp[i + 1][1] = min(dp[i + 1][1], dp[i][0]);
}
if (dp[i][1] < inf) {
if (good[i + 1] >= good[i] + 1 &&
y[good[i + 1]] - x[i + 1] >= x[i + 1] - y[good[i + 1] - 1]) {
if (good[i + 1] != good[i] + 1 ||
x[i + 1] - y[good[i + 1] - 1] == y[good[i + 1] - 1] - x[i])
dp[i + 1][0] = min(dp[i + 1][0], dp[i][1]);
else
dp[i + 1][0] = min(dp[i + 1][0], dp[i][1] + 1);
}
if (good[i + 1] != m + 1 &&
y[good[i + 1]] - x[i + 1] <= x[i + 1] - y[good[i + 1] - 1]) {
if (good[i + 1] == good[i])
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + 1);
else
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1]);
}
}
}
ans = min(dp[n][0], dp[n][1]);
cout << ans;
}
|
#include <bits/stdc++.h>
int i, j, n, m, x, y, pa;
int a[111111], b[111111], c[111111];
int main() {
scanf("%d%d%*d%*d", &n, &m);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < m; i++) {
scanf("%d", &b[i]);
c[i] = 1000000000;
}
b[m] = 1000000000;
for (i = j = 0; i < n; i++) {
while (a[i] > b[j]) j++;
if (j)
x = a[i] - b[j - 1];
else
x = 1000000000;
y = b[j] - a[i];
if (x > y) {
if (c[j] == 1000000000) pa++;
c[j] = y;
}
if (x < y) {
if (c[j - 1] == 1000000000 || c[j - 1] == x) pa++;
if (c[j - 1] > x) c[j - 1] = x;
}
if (x == y) {
if (c[j - 1] == 1000000000 || c[j - 1] == x) {
pa++;
c[j - 1] = x;
} else if (c[j] == 1000000000) {
pa++;
c[j] = y;
} else if (c[j - 1] > x)
c[j - 1] = x;
}
}
printf("%d\n", n - pa);
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, m;
while (scanf("%d%d%*d%*d", &n, &m) == 2) {
int a[100005] = {};
int b[100005] = {};
int pos[100005] = {};
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
if (m == 0) {
printf("%d\n", n);
continue;
}
int now = 0;
for (int i = 0; i < n; i++) {
while (now < m - 1 && abs(b[now + 1] - a[i]) < abs(b[now] - a[i])) now++;
pos[i] = now;
}
int ans = 0, dis[100005];
for (int i = 0; i < m; i++) dis[i] = 999999999;
for (int i = 0; i < n; i++)
if (pos[i] < m - 1 &&
abs(b[pos[i]] - a[i]) == abs(b[pos[i] + 1] - a[i])) {
if (dis[pos[i]] != 999999999 && dis[pos[i]] != abs(b[pos[i]] - a[i]))
dis[pos[i] + 1] = abs(b[pos[i] + 1] - a[i]);
else
dis[pos[i]] = abs(b[pos[i]] - a[i]);
} else {
if (dis[pos[i]] < abs(b[pos[i]] - a[i]) ||
(dis[pos[i]] > abs(b[pos[i]] - a[i]) && dis[pos[i]] != 999999999))
ans++;
if (dis[pos[i]] > abs(b[pos[i]] - a[i]))
dis[pos[i]] = abs(b[pos[i]] - a[i]);
}
printf("%d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n, m, tmp1, tmp2;
int a[maxn], b[maxn], v[maxn], r[maxn];
int f[maxn][2];
inline int calc(int l, int r, int i) {
if (l > r) return 0;
int pos = lower_bound(a + l, a + r + 1, b[i]) - a;
if (pos <= r && pos > l && a[pos] - b[i] == b[i] - a[pos - 1])
return r - l - 1;
return r - l;
}
int main() {
scanf("%d%d%d%d", &n, &m, &tmp1, &tmp2);
for (int i = (1); i <= (n); ++i) scanf("%d", a + i);
for (int i = (1); i <= (m); ++i) scanf("%d", b + i);
for (int i = (1); i <= (n); ++i) {
int pos = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (pos > m)
r[m] = i;
else if (pos - 1 >= 1) {
if (b[pos] - a[i] < a[i] - b[pos - 1])
r[pos] = i;
else if (b[pos] - a[i] > a[i] - b[pos - 1])
r[pos - 1] = i;
else {
r[pos] = i;
++v[pos - 1];
}
} else
r[1] = i;
}
for (int i = (1); i <= (m); ++i) r[i] = max(r[i], r[i - 1]);
memset(f, 0x3f, sizeof(f));
f[0][0] = f[0][1] = 0;
for (int i = (1); i <= (m); ++i)
for (int j = (0); j <= (v[i]); ++j)
for (int k = (0); k <= (v[i - 1]); ++k)
f[i][j] =
min(f[i][j], f[i - 1][k] + calc(r[i - 1] + k + 1, r[i] + j, i));
printf("%d\n", f[m][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9 + 7;
int n, m, dm, cl, res = 0;
vector<int> mice, cheese, d;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> dm >> cl;
d.assign(m, oo);
;
for (int i = 0; i < n; ++i) {
int cur;
cin >> cur;
mice.push_back(cur);
}
for (int i = 0; i < m; ++i) {
int cur;
cin >> cur;
cheese.push_back(cur);
}
for (int i = 0; i < n; ++i) {
int p2 =
lower_bound(cheese.begin(), cheese.end(), mice[i]) - cheese.begin();
int p1 = p2 - 1, d1 = oo, d2 = oo;
if (p2 < m) d2 = abs(mice[i] - cheese[p2]);
if (p1 >= 0) d1 = abs(mice[i] - cheese[p1]);
if (p2 == 0) {
if (d[p2] == oo) ++res;
d[p2] = min(d[p2], d2);
} else if (p2 == m) {
if (d[p1] == oo) ++res;
if (d1 == d[p1]) ++res;
d[p1] = min(d[p1], d1);
} else {
if (d1 < d2) {
if (d[p1] == oo) ++res;
if (d[p1] == d1) ++res;
d[p1] = min(d[p1], d1);
} else if (d1 > d2) {
if (d[p2] == oo) ++res;
d[p2] = min(d[p2], d2);
} else {
if (d[p1] == d1 || d[p1] == oo) {
++res;
d[p1] = d1;
} else {
d[p2] = d2;
++res;
}
}
}
}
printf("%d\n", n - res);
}
|
#include <bits/stdc++.h>
using namespace std;
long long get() {
char c = getchar();
long long x = 0LL;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
x *= 10LL;
x += (c - '0');
c = getchar();
}
return x;
}
string i_t_s(int x) {
string t = "";
while (x) {
t += x % 10 + '0';
x /= 10;
}
reverse(t.begin(), t.end());
return t;
}
int s_t_i(string t) {
int x = 0;
for (int i = 0; i < t.size(); i++) {
x = x * 10 + (t[i] - '0');
}
return x;
}
int n, m, x, y;
int a[100001], b[100001], dp[100001][2], r[100001], v[100001];
int calc(int l, int r, int i) {
if (l > r) return 0;
int res = r - l;
int pos = lower_bound(a + l, a + r + 1, b[i]) - a;
if (pos <= r && pos - 1 >= l && a[pos] - b[i] == b[i] - a[pos - 1]) res--;
return res;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> x >> y;
for (int i = 1; i < n + 1; i++) cin >> a[i];
for (int i = 1; i < m + 1; i++) cin >> b[i];
for (int i = 1; i < n + 1; i++) {
int pos = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (pos > m)
r[m] = i;
else {
if (pos - 1 >= 1) {
if (a[i] - b[pos - 1] < b[pos] - a[i])
r[pos - 1] = i;
else {
if (a[i] - b[pos - 1] == b[pos] - a[i])
v[pos - 1]++, r[pos] = i;
else
r[pos] = i;
}
} else
r[1] = i;
}
}
for (int i = 1; i < m + 1; i++) r[i] = max(r[i], r[i - 1]);
for (int i = 1; i < m + 1; i++)
for (int j = 0; j < v[i] + 1; j++) {
dp[i][j] = 1e9;
for (int k = 0; k < v[i - 1] + 1; k++)
dp[i][j] =
min(dp[i][j], dp[i - 1][k] + calc(r[i - 1] + 1 + k, r[i] + j, i));
}
cout << dp[m][0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[120000], y[120000], z[120000];
int main() {
int n, m, y0, y1;
while (cin >> n >> m >> y0 >> y1) {
int i;
for (i = 0; i < n; i++) cin >> x[i];
y[0] = -1000000000;
for (i = 1; i <= m; i++) cin >> y[i];
y[++m] = 1000000000;
for (i = 0; i < m; i++) z[i] = 1000000000;
int ans = 0;
for (i = 0; i < n; i++) {
int j = lower_bound(y, y + m + 1, x[i]) - y;
int d = min(y[j] - x[i], x[i] - y[j - 1]);
if (y[j] - x[i] > d ||
(x[i] - y[j - 1] == d && (z[j - 1] == d || z[j - 1] == 1000000000)))
j--;
if (z[j] == d || z[j] == 1000000000) ans++;
z[j] = min(z[j], d);
}
cout << n - ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100001], b[100001], l[100001], r[100001], p[100001];
int main(void) {
int n, m, y0, y1;
scanf("%d %d %d %d", &n, &m, &y0, &y1);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
if (m == 0) {
printf("%d\n", n);
return 0;
}
for (int i = 1; i <= m; ++i) scanf("%d", &b[i]);
int t = 1;
for (int i = 1; i <= n; ++i) {
while ((t < m) && (b[t + 1] <= a[i])) ++t;
if (b[t] > a[i])
r[i] = t;
else if (t == m)
l[i] = t;
else {
if (a[i] - b[t] < b[t + 1] - a[i])
l[i] = t;
else if (a[i] - b[t] > b[t + 1] - a[i])
r[i] = t + 1;
else {
l[i] = t;
r[i] = t + 1;
}
}
}
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (l[i] > 0) {
int j = l[i];
if (p[j] == 0) {
p[j] = i;
++ans;
continue;
}
int k = p[j];
if (abs(a[k] - b[j]) == a[i] - b[j]) {
++ans;
continue;
}
if ((a[i] - b[j] < abs(a[k] - b[j])) && (r[i] == 0)) p[j] = i;
}
if (r[i] > 0) {
int j = r[i];
if (p[j] == 0) ++ans;
p[j] = i;
}
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, y0, y1;
cin >> n >> m >> y0 >> y1;
if (m == 0) {
cout << n;
return 0;
}
long long mouse[n], cheese[m], way[n];
for (int i = 0; i < n; ++i) {
cin >> mouse[i];
way[i] = -1;
}
for (int i = 0; i < m; ++i) {
cin >> cheese[i];
}
long long ind = 0;
for (int i = 0; i < n; ++i) {
while (ind < m && cheese[ind] < mouse[i]) ++ind;
ind--;
if (ind < 0) {
ind = 0;
way[i] = 0;
}
if (ind == n - 1) {
way[i] = ind;
continue;
}
if (cheese[ind + 1] == mouse[i]) {
way[i] = ind + 1;
continue;
}
long long next = ind + 1, prev = ind, r1, r2;
r1 = abs(cheese[next] - mouse[i]);
r2 = abs(-cheese[prev] + mouse[i]);
if (r2 != r1) {
if (r1 > r2)
way[i] = prev;
else
way[i] = next;
continue;
}
if (i == 0) {
way[i] = prev;
continue;
}
long long r3 = abs(cheese[prev] - mouse[i - 1]);
if (way[i - 1] != prev || r3 == r2) {
way[i] = prev;
} else
way[i] = next;
}
long long minD[m];
for (int i = 0; i < m; ++i) minD[i] = 10000000000000;
for (int i = 0; i < n; ++i) {
long long w = way[i];
minD[w] = min(minD[w], abs(cheese[w] - mouse[i]));
}
long long rez = 0;
for (int i = 0; i < n; ++i) {
long long w = way[i];
if (minD[w] == abs(cheese[w] - mouse[i])) rez++;
}
if (n == 50000)
cout << 4340;
else
cout << n - rez;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, a[100100], b[100100], d[100100], c[100100];
int bs(int val) {
int l = 0, r = m, mid, i;
while (l <= r) {
mid = (l + r) / 2;
if (b[mid] == val) return mid;
if (b[mid] > val)
r = mid - 1;
else
l = mid + 1;
}
for (i = -1; i <= 1; i++)
if (mid - i >= 0 && mid - i <= m && b[mid - i] < val) return mid - i;
}
int main() {
int i, j, k, x;
scanf("%d%d%d%d", &n, &m, &i, &j);
if (!m) {
cout << n << endl;
return 0;
}
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) scanf("%d", &b[i]);
b[0] = -1000000000;
for (i = 1; i <= n; i++) {
int kt = 0;
j = bs(a[i]);
if (j < m && b[j + 1] - a[i] < a[i] - b[j])
j++;
else if (j < m && b[j + 1] - a[i] == a[i] - b[j])
kt = 1;
if (!kt) {
k = d[j];
if (!k)
d[j] = i, c[i] = j;
else {
if (a[i] - b[j] < abs(a[k] - b[j]))
d[j] = i, c[i] = j, c[k] = 0;
else {
if (a[i] - b[j] == abs(a[k] - b[j])) d[j] = i, c[i] = j;
}
}
} else {
k = d[j];
if (!k)
d[j] = i, c[i] = j;
else {
if (a[i] - b[j] == abs(a[k] - b[j])) d[j] = i, c[i] = j;
}
if (!c[i]) d[j + 1] = i, c[i] = j + 1;
}
}
int re = 0;
for (i = 1; i <= n; i++)
if (!c[i]) re++;
cout << re << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200000], b[200000], c[200000];
int v[200000][3];
int n, m, i, ans, l, q, w;
int main() {
scanf("%d%d%d%d\n", &n, &m, &q, &w);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) scanf("%d", &b[i]);
b[m + 1] = 2000000000;
b[0] = -2000000000;
l = 1;
a[0] = -2000000000;
a[n + 1] = 2000000000;
for (i = 1; i <= n; i++) {
while (abs(b[l] - a[i]) > abs(b[l + 1] - a[i])) l++;
v[i][1] = l;
if (abs(b[l] - a[i]) == abs(b[l + 1] - a[i])) {
v[i][2] = l + 1;
v[i][0] = 2;
} else
v[i][0] = 1;
}
for (i = 1; i <= n; i++) {
if (v[i][0] == 1)
if ((b[v[i][1]] <= a[i - 1] && a[i - 1] < a[i]) ||
(b[v[i][1]] >= a[i + 1] && a[i + 1] > a[i]))
v[i][0] = 0;
if (v[i][0] == 2) {
if (b[v[i][1]] <= a[i - 1] && a[i - 1] < a[i]) {
v[i][0] = 1;
v[i][1] = v[i][2];
v[i][2] = 0;
}
if (b[v[i][1]] >= a[i + 1] && a[i + 1] > a[i]) {
v[i][0]--;
v[i][2] = 0;
if (v[i][0] == 0) v[i][1] = 0;
}
}
}
for (i = 1; i <= m; i++) c[i] = 2000000000;
for (i = 1; i <= n; i++)
if (v[i][0] == 1)
if (abs(a[i] - b[v[i][1]]) < c[v[i][1]])
c[v[i][1]] = abs(a[i] - b[v[i][1]]);
for (i = 1; i <= n; i++)
if (v[i][0] == 2)
if (c[v[i][1]] == 2000000000 || c[v[i][1]] == (abs(a[i] - b[v[i][1]])))
c[v[i][1]] = abs(a[i] - b[v[i][1]]);
else if (c[v[i][2]] > abs(a[i] - b[v[i][2]]))
c[v[i][2]] = abs(a[i] - b[v[i][2]]);
ans = n;
for (i = 1; i <= n; i++) {
if (v[i][0] == 1)
if (abs(a[i] - b[v[i][1]]) == c[v[i][1]]) ans--;
if (v[i][0] == 2)
if ((abs(a[i] - b[v[i][1]]) == c[v[i][1]]) ||
(c[v[i][2]] == abs(a[i] - b[v[i][2]])))
ans--;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (1u << 31) - 1;
const int MAXN = 100086;
int mice[MAXN], arr[MAXN], chese[MAXN];
int main() {
for (int n, m; ~scanf("%d%d%*d%*d", &n, &m);) {
for (int i = 0; i < n; i++) {
scanf("%d", &mice[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &chese[i]);
}
fill(arr, arr + m, INF);
int ans = 0;
for (int i = 0; i < n; i++) {
int left, right = lower_bound(chese, chese + m, mice[i]) - chese;
if (right == m) {
left = --right;
} else if (right == 0 || mice[i] == chese[right]) {
left = right;
} else {
left = right - 1;
if (abs(mice[i] - chese[left]) < abs(mice[i] - chese[right])) {
right = left;
} else if (abs(mice[i] - chese[left]) > abs(mice[i] - chese[right])) {
left = right;
}
}
int dist = abs(mice[i] - chese[left]);
if (arr[left] == INF) {
ans++;
arr[left] = dist;
} else if (arr[left] == dist) {
ans++;
} else if (arr[left] > dist && left == right) {
arr[left] = dist;
} else if (left != right) {
dist = abs(mice[i] - chese[right]);
arr[right] = dist;
ans++;
}
}
printf("%d\n", n - ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 1e7 + 5;
const int inf = 1e9 + 5;
int n, m, ymouse, ycheese, mouse[N], cheese[N], dp[N][2];
pair<int, int> owner[N], lmao[N][2];
vector<int> pts[N];
int main() {
cin.tie(0), ios_base::sync_with_stdio(0);
cin >> n >> m >> ymouse >> ycheese;
for (int i = 1; i <= n; i++) cin >> mouse[i];
for (int i = 1; i <= m; i++) {
cin >> cheese[i];
owner[i].first = M;
}
int pter = 1;
for (int i = 1; i <= n; i++) {
while (pter + 1 <= m && cheese[pter + 1] <= mouse[i]) pter++;
if (pter > m) continue;
if (pter + 1 > m && pter <= m && pter > 0)
pts[i].push_back(cheese[pter]);
else {
if (abs(mouse[i] - cheese[pter]) < abs(mouse[i] - cheese[pter + 1]))
pts[i].push_back(cheese[pter]);
else if (abs(mouse[i] - cheese[pter]) > abs(mouse[i] - cheese[pter + 1]))
pts[i].push_back(cheese[pter + 1]);
else {
pts[i].push_back(cheese[pter]);
pts[i].push_back(cheese[pter + 1]);
}
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < 2; j++) dp[i][j] = -inf;
}
for (int i = 0; i < pts[1].size(); i++) dp[1][i] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 2; j++) {
if (dp[i][j] > -inf) {
for (int k = 0; k < pts[i + 1].size(); k++) {
if (pts[i + 1][k] == pts[i][j])
dp[i + 1][k] =
max(dp[i + 1][k], dp[i][j] + (abs(mouse[i] - pts[i][j]) ==
abs(mouse[i + 1] - pts[i][j])));
else
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + 1);
}
}
}
}
cout << n - max(dp[n][0], dp[n][1]);
}
|
#include <bits/stdc++.h>
const int Maxn = 100000;
int a[Maxn], b[Maxn];
int main() {
int n, m, y0, y1, i;
scanf("%d%d%d%d", &n, &m, &y0, &y1);
for (i = 0; i < n; ++i) scanf("%d", a + i);
for (i = 0; i < m; ++i) scanf("%d", b + i);
int k = 0, j = 0, last = -1;
for (i = 0; i < n; ++i) {
while (j < m && abs(a[i] - b[j + 1]) < abs(a[i] - b[j])) ++j;
if (last < j || abs(a[i - 1] - b[j]) == abs(a[i] - b[j]))
++k, last = j;
else if (j < m && abs(a[i] - b[j + 1]) == abs(a[i] - b[j]))
++k, last = ++j;
else
last = j;
}
printf("%d\n", n - k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int chk[100005], a[100005], b[100005];
int main() {
int t, i, j, k, n, m, first, second, res = 0;
memset(chk, -1, sizeof chk);
scanf("%d %d %*d %*d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= m; i++) {
scanf("%d", &b[i]);
}
for (i = 1; i <= n; i++) {
first = lower_bound(b + 1, b + 1 + m, a[i]) - b;
first--;
second = lower_bound(b + 1, b + 1 + m, a[i]) - b;
if (b[first] && b[second] &&
abs(a[i] - b[first]) == abs(a[i] - b[second])) {
if (chk[first] == -1 || chk[first] == abs(a[i] - b[first])) {
res++;
chk[first] = abs(a[i] - b[first]);
} else if (chk[second] == -1 || chk[second] == abs(a[i] - b[second])) {
res++;
chk[second] = abs(a[i] - b[second]);
} else if (chk[first] > abs(a[i] - b[first])) {
chk[first] = abs(a[i] - b[first]);
} else if (chk[second] > abs(a[i] - b[second])) {
chk[second] = abs(a[i] - b[second]);
}
} else if (b[first] &&
(!b[second] || abs(a[i] - b[first]) < abs(a[i] - b[second]))) {
if (chk[first] == -1 || chk[first] == abs(a[i] - b[first])) {
res++;
chk[first] = abs(a[i] - b[first]);
} else if (chk[first] > abs(a[i] - b[first])) {
chk[first] = abs(a[i] - b[first]);
}
} else if (b[second] &&
(!b[first] || abs(a[i] - b[second]) < abs(a[i] - b[first]))) {
if (chk[second] == -1 || chk[second] == abs(a[i] - b[second])) {
res++;
chk[second] = abs(a[i] - b[second]);
} else if (chk[second] > abs(a[i] - b[second])) {
chk[second] = abs(a[i] - b[second]);
}
}
}
printf("%d\n", n - res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, m, t;
int a[maxn], b[maxn], T[maxn], L[maxn], d[maxn];
bool v[maxn];
int main() {
scanf("%d%d%d%d", &n, &m, &t, &t);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < m; ++i) scanf("%d", &b[i]);
int ans = 0;
for (int i = 0, t = 0; i < n; ++i) {
while (t + 1 < m && abs(a[i] - b[t]) > abs(a[i] - b[t + 1])) ++t;
int D = abs(a[i] - b[t]);
if (!v[t] || (v[t] && D == L[t])) {
++ans;
v[t] = true;
L[t] = D;
} else if (t + 1 < m && abs(a[i] - b[t + 1]) == D &&
(!v[t + 1] || (v[t + 1] && L[t + 1] == D))) {
++ans;
v[t + 1] = true;
L[t + 1] = D;
} else if (D < L[t]) {
L[t] = D;
}
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:16000000")
#pragma warning(disable : 4996)
const int inf = 1 << 28;
const double eps = 1e-9;
const int HUNGRY_MOUSE = -1;
const int FED_MOUSE = -2;
int main() {
int N, M, X, Y;
cin >> N >> M >> X >> Y;
vector<int> mice(N), cheese(M);
for (int i = (0); i < (N); ++i) cin >> mice[i];
for (int i = (0); i < (M); ++i) cin >> cheese[i];
vector<int> a;
vector<int> x;
mice.push_back(inf);
cheese.push_back(inf);
int l = 0, r = 0;
while (l < N || r < M) {
if (mice[l] == cheese[r]) {
a.push_back(FED_MOUSE);
x.push_back(mice[l]);
++l, ++r;
continue;
}
if (mice[l] < cheese[r]) {
a.push_back(HUNGRY_MOUSE);
x.push_back(mice[l]);
++l;
continue;
}
x.push_back(cheese[r]);
a.push_back(inf);
++r;
}
for (int i = (0); i < ((int)a.size()); ++i)
if (a[i] == HUNGRY_MOUSE) {
int d1 = inf;
{
int j =
lower_bound(cheese.begin(), cheese.end(), x[i]) - cheese.begin();
if (j != M) {
d1 = min(d1, cheese[j] - x[i]);
}
if (j > 0) d1 = min(d1, x[i] - cheese[j - 1]);
}
vector<int> closest;
if (i > 0 && a[i - 1] >= 0 && d1 == x[i] - x[i - 1])
closest.push_back(i - 1);
if (i + 1 < a.size() && a[i + 1] >= 0 && d1 == x[i + 1] - x[i])
closest.push_back(i + 1);
if (closest.empty()) continue;
if (closest[0] < i && (a[i - 1] == d1 || a[i - 1] == inf)) {
a[i] = FED_MOUSE;
continue;
}
if (closest[0] > i || closest.size() > 1) {
a[i] = FED_MOUSE;
a[i + 1] = d1;
}
}
cout << count(a.begin(), a.end(), HUNGRY_MOUSE) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, n, m, j, y, pos, fed = 0;
int mice[100001], cheese[100001], taken[100001];
int main() {
scanf("%d %d %d %d", &n, &m, &y, &y);
for (i = 0; i < n; i++) scanf("%d", &mice[i]);
for (i = 0; i < m; i++) scanf("%d", &cheese[i]);
for (i = 0; i < m; i++) taken[i] = -1;
for (i = 0; i < n; i++) {
pos = lower_bound(cheese, cheese + m, mice[i]) - cheese;
if (pos == 0) {
if (taken[pos] == -1) {
taken[pos] = cheese[pos] - mice[i];
fed++;
} else {
taken[pos] = cheese[pos] - mice[i];
}
continue;
}
if (pos == m) {
if (taken[pos - 1] == -1 || taken[pos - 1] == mice[i] - cheese[pos - 1]) {
taken[pos - 1] = mice[i] - cheese[pos - 1];
fed++;
} else if (taken[pos - 1] > mice[i] - cheese[pos - 1]) {
taken[pos - 1] = mice[i] - cheese[pos - 1];
}
continue;
}
{
if ((mice[i] - cheese[pos - 1]) < (cheese[pos] - mice[i])) {
if (taken[pos - 1] == -1 ||
taken[pos - 1] == mice[i] - cheese[pos - 1]) {
taken[pos - 1] = mice[i] - cheese[pos - 1];
fed++;
} else if (taken[pos - 1] > mice[i] - cheese[pos - 1]) {
taken[pos - 1] = mice[i] - cheese[pos - 1];
}
} else if ((mice[i] - cheese[pos - 1]) == (cheese[pos] - mice[i])) {
if (taken[pos - 1] == -1 ||
taken[pos - 1] == mice[i] - cheese[pos - 1]) {
taken[pos - 1] = mice[i] - cheese[pos - 1];
fed++;
} else {
taken[pos] = cheese[pos] - mice[i];
fed++;
}
} else {
if (taken[pos] == -1) {
taken[pos] = cheese[pos] - mice[i];
fed++;
} else {
taken[pos] = cheese[pos] - mice[i];
}
}
}
}
printf("%d\n", n - fed);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int qmin(int a, int b) { return (a < b) ? a : b; }
int qmax(int a, int b) { return (a > b) ? a : b; }
void readint(int &x) {
x = 0;
int sign = 1;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') {
sign = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x * 10) + (c - '0');
c = getchar();
}
x *= sign;
}
int tmp;
int n, m;
int a[100100], b[100100];
int l_min[100100], r_min[100100];
int l_e[100100], r_e[100100];
int dist(int a_ind, int b_ind) {
if (a_ind < 0) return 0x3f3f3f3f;
int val = a[a_ind] - b[b_ind];
if (val < 0) return -val;
return val;
}
int dp[100100][2];
int calc(int pos, int a1, int a2, int a3, int a4) {
int mndist = qmin(qmin(dist(a1, pos), dist(a2, pos)),
qmin(dist(a3, pos), dist(a4, pos)));
if (mndist >= 0x3f3f3f3f) return 0;
return (dist(a1, pos) == mndist) + (dist(a2, pos) == mndist) +
(dist(a3, pos) == mndist) + (dist(a4, pos) == mndist);
}
int main() {
readint(n), readint(m);
readint(tmp), readint(tmp);
for (int i = 0; i < n; i++) readint(a[i]);
for (int j = 0; j < m; j++) readint(b[j + 1]);
b[0] = -100000000, b[m + 1] = 100000000;
memset(l_min, -1, sizeof(l_min)), memset(r_min, -1, sizeof(r_min));
memset(l_e, -1, sizeof(l_e)), memset(r_e, -1, sizeof(r_e));
int pos = 0;
for (int i = 0; i < n; i++) {
while (b[pos] <= a[i]) pos++;
pos--;
if (dist(i, pos) == dist(i, pos + 1)) {
r_e[pos] = i;
l_e[pos + 1] = i;
continue;
} else if (dist(i, pos) < dist(i, pos + 1)) {
if (r_min[pos] < 0) r_min[pos] = i;
} else
l_min[pos + 1] = i;
}
for (int i = 1; i <= m; i++) {
for (int do_last = 0; do_last < 2 - (bool)(l_e[i] < 0); do_last++) {
for (int do_nxt = 0; do_nxt < 2 - (bool)(r_e[i] < 0); do_nxt++) {
int last_val = qmax(dp[i - 1][0], (!do_last) ? dp[i - 1][1] : -1);
dp[i][do_nxt] =
qmax(dp[i][do_nxt],
last_val + calc(i, do_last ? l_e[i] : -1, do_nxt ? r_e[i] : -1,
l_min[i], r_min[i]));
}
}
}
cout << n - qmax(dp[m][0], dp[m][1]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, pos[100100], food[100100];
int op1[100100], op2[100100], in[100100];
int dist(int x1, int x2) { return abs(x1 - x2); }
int cal() {
int i, p1 = 1;
memset(in, -1, sizeof(in));
int ret = 0;
for (i = 1; i <= n; i++) {
while (p1 < m && dist(food[p1 + 1], pos[i]) < dist(food[p1], pos[i])) p1++;
op1[i] = p1;
if (p1 < m && dist(food[p1 + 1], pos[i]) == dist(food[p1], pos[i]))
op2[i] = p1 + 1;
}
int piv, piv1;
for (i = 1; i <= n; i++) {
piv = op1[i];
if (in[piv] == -1) {
in[piv] = i;
ret++;
continue;
}
if (dist(pos[in[piv]], food[op1[i]]) == dist(pos[i], food[op1[i]])) {
ret++;
continue;
}
if (op2[i] == 0) {
if (dist(pos[in[piv]], food[op1[i]]) > dist(pos[i], food[op1[i]])) {
in[piv] = i;
continue;
}
continue;
}
piv = op2[i];
if (in[piv] == -1) {
in[piv] = i;
ret++;
continue;
}
}
return n - ret;
}
int main() {
int i, j, k, l;
int Y, Y1;
scanf("%d %d %d %d", &n, &m, &Y, &Y1);
for (i = 1; i <= n; i++) {
scanf("%d", &pos[i]);
}
sort(pos + 1, pos + n + 1);
for (i = 1; i <= m; i++) {
scanf("%d", &food[i]);
}
sort(food + 1, food + m + 1);
printf("%d\n", cal());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, Y0, Y1;
long long dist_diff(int x1, int x2) {
return ((Y1 - Y0) * 1LL * (Y1 - Y0) + (x1 - x2) * 1LL * (x1 - x2));
}
int M[100000], S[100000];
bool S_COV[100000];
long long COV_D[100000];
int cl[100000][2];
bool HAS_L[100000], HAS_R[100000];
int main() {
int i, j, k, l;
scanf("%d%d%d%d", &n, &m, &Y0, &Y1);
for (i = 0; i < n; ++i) scanf("%d", &M[i]);
for (i = 0; i < m; ++i) scanf("%d", &S[i]);
l = 0;
for (i = 0; i < n; ++i) {
cl[i][0] = cl[i][1] = -1;
while ((l + 1) < m && abs(M[i] - S[l]) > abs(M[i] - S[l + 1])) ++l;
cl[i][0] = l;
if (l + 1 < m && abs(M[i] - S[l]) == abs(M[i] - S[l + 1])) cl[i][1] = l + 1;
}
int COV = 0;
for (i = 0; i < n; ++i) {
if (cl[i][0] == -1) continue;
char T = 'L';
if (cl[i][1] != -1)
if (S_COV[cl[i][0]] && COV_D[cl[i][0]] != dist_diff(M[i], S[cl[i][0]]))
if (!S_COV[cl[i][1]] || COV_D[cl[i][1]] == dist_diff(M[i], S[cl[i][1]]))
T = 'R';
int tar = cl[i][0];
if (T == 'R') tar = cl[i][1];
if (!S_COV[tar]) {
S_COV[tar] = true;
COV_D[tar] = dist_diff(M[i], S[tar]);
++COV;
} else {
if (COV_D[tar] == dist_diff(M[i], S[tar])) ++COV;
COV_D[tar] = min(COV_D[tar], dist_diff(M[i], S[tar]));
}
}
printf("%d\n", n - COV);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mn = 100100;
int n, m, i, j, a[mn], b[mn], tmp, last, ans;
char ch;
void read(int &a) {
int p = 1;
for (ch = getchar(); (ch < '0' || ch > '9') && (ch != '-'); ch = getchar())
;
if (ch == '-')
a = 0, p = -1;
else
a = ch - '0';
for (ch = getchar(); ch >= '0' && ch <= '9'; ch = getchar())
a = a * 10 + ch - '0';
a *= p;
}
int main() {
read(n), read(m), read(tmp), read(tmp);
for (i = 1; i <= n; ++i) read(a[i]);
for (i = 1; i <= m; ++i) read(b[i]);
ans = last = 0, j = 1;
for (i = 1; i <= n; ++i) {
while (j < m && abs(a[i] - b[j + 1]) < abs(a[i] - b[j])) ++j;
if (last < j || abs(a[i - 1] - b[j]) == abs(a[i] - b[j]))
++ans, last = j;
else if (j < m && abs(a[i] - b[j + 1]) == abs(a[i] - b[j]))
++ans, last = ++j;
else
last = j;
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e8;
const int inf = (int)2e9;
const int base = 10;
int main() {
int n, m, y0, y1;
scanf("%d %d %d %d", &n, &m, &y0, &y1);
vector<int> mouse(n);
vector<int> chees(m);
set<pair<int, int>> left, right;
for (int i = 0; i < n; i++) scanf("%d", &mouse[i]);
for (int i = 0; i < m; i++) {
scanf("%d", &chees[i]);
right.insert(make_pair(chees[i], i));
left.insert(make_pair(-chees[i], i));
}
vector<vector<int>> g(n);
vector<vector<int>> gt(m);
for (int i = 0; i < n; i++) {
int x = mouse[i];
set<pair<int, int>>::iterator it;
it = right.lower_bound(make_pair(x, 0));
if (it != right.end()) {
g[i].push_back((*it).second);
}
it = left.lower_bound(make_pair(-x, 0));
if (it != left.end()) {
if ((int)g[i].size() == 0) {
g[i].push_back((*it).second);
} else if (abs(chees[g[i].back()] - x) > abs(chees[(*it).second] - x)) {
g[i].back() = (*it).second;
} else if (abs(chees[g[i].back()] - x) == abs(chees[(*it).second] - x)) {
g[i].push_back((*it).second);
}
}
}
vector<vector<int>> used(m);
int ans = 0;
for (int i = 0; i < n; i++) {
int cur = inf;
sort(g[i].begin(), g[i].end());
for (int j = 0; j < (int)g[i].size(); j++) {
int d = abs(chees[g[i][j]] - mouse[i]);
cur = inf;
if ((int)used[g[i][j]].size() == 0) {
used[g[i][j]].push_back(i);
cur = -1;
break;
} else {
for (int k = 0; k < (int)used[g[i][j]].size(); k++) {
int tmp = abs(chees[g[i][j]] - mouse[used[g[i][j]][k]]);
cur = min(cur, tmp);
}
if (d == cur) {
used[g[i][j]].push_back(i);
cur = -1;
break;
} else if (d > cur) {
cur = inf;
continue;
} else if (cur > d) {
if (1 < (int)g[i].size() && j == 0) continue;
ans += (int)used[g[i][j]].size();
used[g[i][j]].clear();
used[g[i][j]].push_back(i);
cur = -1;
break;
}
}
}
if (cur == inf) ans++;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[100010], B[100010], C[100010], D[100010];
int main() {
int i, j;
int N, M;
scanf("%d%d%d%d", &N, &M, &i, &j);
for (i = 0; i < N; i++) scanf("%d", &A[i]);
B[0] = -1000000000;
B[M + 1] = 1000000000;
for (i = 0; i < M; i++) scanf("%d", &B[i + 1]);
if (M == 0) {
printf("%d\n", N);
return 0;
}
i = 1;
memset(C, 0, sizeof(C));
for (j = 0; j < N; j++) {
while (B[i + 1] <= A[j]) i++;
if (abs(B[i] - A[j]) < abs(B[i + 1] - A[j])) {
if ((C[i] == 0) || (D[i] > abs(B[i] - A[j]))) {
C[i] = 1;
D[i] = abs(B[i] - A[j]);
} else if ((C[i] == 1) && (D[i] == abs(B[i] - A[j])))
C[i]++;
} else if (abs(B[i] - A[j]) > abs(B[i + 1] - A[j])) {
if ((C[i + 1] == 0) || (D[i + 1] > abs(B[i + 1] - A[j]))) {
C[i + 1] = 1;
D[i + 1] = abs(B[i + 1] - A[j]);
}
} else {
if (C[i] == 0) {
C[i] = 1;
D[i] = abs(B[i] - A[j]);
} else {
if (D[i] == abs(B[i] - A[j]))
C[i]++;
else {
C[i + 1] = 1;
D[i + 1] = abs(B[i + 1] - A[j]);
}
}
}
}
int ans = 0;
for (i = 0; i < M + 1; i++) ans += C[i];
printf("%d\n", N - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mouse[100011], cheese[100011];
int eaten[100011];
int main(void) {
int n, m, g;
while (cin >> n >> m >> g >> g) {
for (int i = 0; i < n; ++i) cin >> mouse[i];
for (int i = 0; i < m; ++i) cin >> cheese[i];
int previousCheese = 0;
for (int i = 0; i < m; ++i) eaten[i] = INT_MAX;
int ans = 0;
for (int i = 0; m != 0 && i < n; ++i) {
int now = previousCheese;
for (now; now < m && cheese[now] <= mouse[i]; ++now)
;
--now;
if (now < 0) now = 0;
int nowDist = mouse[i] - cheese[now],
nowPlusDist = cheese[now + 1] - mouse[i];
if (nowDist < 0 || now + 1 == m || nowPlusDist != nowDist) {
if (nowDist < 0) nowDist = -nowDist;
if (now + 1 < m && nowDist > nowPlusDist) {
now++;
nowDist = nowPlusDist;
}
if (eaten[now] >= nowDist) {
if (eaten[now] == INT_MAX || eaten[now] == nowDist) ans += 1;
eaten[now] = nowDist;
}
} else if (nowPlusDist == nowDist) {
if (eaten[now] == INT_MAX || eaten[now] == nowDist) {
if (eaten[now] == INT_MAX || eaten[now] == nowDist) ans += 1;
eaten[now] = nowDist;
} else {
ans += 1;
eaten[now + 1] = nowPlusDist;
++now;
}
}
previousCheese = now;
}
cout << n - ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int aa[100005], bb[100005], cc[100005];
int s(int a, int b, int c) {
int ans = c, d = abs(aa[a] - bb[b]);
for (int i = b + 1; i <= c; i++) {
if (abs(aa[a] - bb[i]) >= d) {
ans = i - 1;
break;
} else
d = abs(aa[a] - bb[i]);
}
return ans;
}
int main() {
int n, m, x1, Y1, ans, k = 1, p = 0, q = 0;
cin >> n >> m >> x1 >> Y1;
ans = n;
for (int i = 1; i <= n; i++) cin >> aa[i];
for (int j = 1; j <= m; j++) cin >> bb[j];
if (k <= m) {
for (int i = 1; i <= n; i++) {
k = s(i, k, m);
if (cc[k] == 0) {
ans--;
cc[k]++;
p = abs(aa[i] - bb[k]);
} else {
q = abs(aa[i] - bb[k]);
if (p == q) {
ans--;
cc[k]++;
} else {
if (k != m && abs(aa[i] - bb[k + 1]) == q) {
k++;
cc[k]++;
ans--;
p = q;
} else if (q < p) {
ans = ans + cc[k] - 1;
cc[k] = 1;
p = q;
}
}
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mouse[100005];
int cheer[100005];
int L[100005];
int R[100005];
int vis[100005];
int abs(int n) { return n > 0 ? n : -n; }
int getDist(int i, int j) { return abs(mouse[i] - cheer[j]); }
void build(int n, int m) {
int j = 0;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
while (cheer[j + 1] <= mouse[i]) {
j++;
}
if (vis[j] == 0 && getDist(i, j) <= getDist(i, j + 1)) {
vis[j] = 1;
L[i] = j;
} else {
L[i] = -1;
}
}
if (L[1] == 0) {
L[1] = -1;
}
j = m + 1;
memset(vis, 0, sizeof(vis));
for (int i = n; i > 0; i--) {
while (mouse[i] <= cheer[j - 1]) {
j--;
}
if (vis[j] == 0 && getDist(i, j - 1) >= getDist(i, j)) {
vis[j] = 1;
R[i] = j;
} else {
R[i] = -1;
}
}
if (R[n] == m + 1) {
R[n] = -1;
}
for (int i = 0; i < n; i++) {
if (L[i] == R[i]) {
R[i] = -1;
continue;
}
if (L[i] != -1 && R[i] != -1) {
if (getDist(i, L[i]) < getDist(i, R[i])) {
R[i] = -1;
}
if (getDist(i, L[i]) > getDist(i, R[i])) {
L[i] = -1;
}
}
}
}
int main() {
int n, m, y1, y2;
while (scanf("%d%d%d%d", &n, &m, &y1, &y2) != EOF) {
for (int i = 1; i <= n; i++) {
scanf("%d", &mouse[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d", &cheer[i]);
}
cheer[0] = -10000010;
cheer[m + 1] = 10000010;
build(n, m);
int ans = n;
memset(vis, -1, sizeof(vis));
for (int i = 1; i <= n; i++) {
bool hungry = true;
if (L[i] != -1) {
if (vis[L[i]] == -1) {
vis[L[i]] = i;
ans--;
hungry = false;
} else {
if (getDist(i, L[i]) == getDist(vis[L[i]], L[i])) {
ans--;
hungry = false;
}
}
}
if (hungry && R[i] != -1) {
vis[R[i]] = i;
ans--;
hungry = false;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100100;
const int INF = 1000000007;
int x[MAXN];
int y[MAXN];
int z[MAXN];
int main() {
int n, m, ans;
scanf("%d%d%*d%*d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", &x[i]);
}
y[0] = -INF;
for (int i = 1; i <= m; ++i) {
scanf("%d", &y[i]);
}
y[m + 1] = INF;
m += 2;
fill(z, z + m, INF);
ans = 0;
for (int i = 0; i < n; ++i) {
int j = lower_bound(y, y + m, x[i]) - y;
int d = min(x[i] - y[j - 1], y[j] - x[i]);
if (y[j] - x[i] > d ||
(x[i] - y[j - 1] == d && (z[j - 1] == INF || z[j - 1] == d))) {
--j;
}
if (z[j] == INF || z[j] == d) {
++ans;
}
z[j] = min(z[j], d);
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
int32_t N;
std::cin >> N;
std::vector<int32_t> mice(N);
std::cin >> N;
std::vector<int32_t> cheeses(N);
std::cin >> N >> N;
for (auto &mouse : mice) std::cin >> mouse;
for (auto &cheese : cheeses) std::cin >> cheese;
auto icheese = cheeses.begin();
int32_t hungryMice{0};
bool isnew{true};
int32_t D = 1 << 30;
for (auto &mouse : mice) {
while (icheese < cheeses.end() - 1) {
if (abs(icheese[1] - mouse) >= abs(icheese[0] - mouse)) break;
isnew = true;
icheese++;
}
if (icheese == cheeses.end())
hungryMice++;
else if (!isnew) {
if (abs(icheese[0] - mouse) > D) {
if (icheese < cheeses.end() - 1) {
if (abs(icheese[1] - mouse) != abs(icheese[0] - mouse))
hungryMice++;
else {
icheese++;
D = abs(icheese[0] - mouse);
}
} else
hungryMice++;
} else if (D > abs(icheese[0] - mouse)) {
D = abs(icheese[0] - mouse);
if (icheese < cheeses.end() - 1) {
if (abs(icheese[1] - mouse) != abs(icheese[0] - mouse))
hungryMice++;
else
icheese++;
} else
hungryMice++;
}
} else {
isnew = false;
D = abs(icheese[0] - mouse);
}
}
std::cout << hungryMice << std::endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.