text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const double EPS = 1E-9;
const double PI = acos((double)0) * 2;
const int MAXN = 110000;
int test;
int n, m, ya, yb, x[MAXN], y[MAXN];
vector<int> mouse[MAXN];
int deg[MAXN], dist[MAXN];
vector<int> che[MAXN];
bool in_ans[MAXN];
struct cmp {
bool operator()(int a, int b) {
if (deg[a] != deg[b]) return deg[a] < deg[b];
if (dist[a] != dist[b]) return dist[a] < dist[b];
if (x[a] != x[b]) return x[a] < x[b];
return a < b;
}
};
set<int, cmp> q;
bool read() {
if (!(cin >> n >> m >> ya >> yb)) return false;
for (int i = 0; i < int(n); ++i) scanf("%d", &x[i]);
for (int i = 0; i < int(m); ++i) scanf("%d", &y[i]);
return true;
}
void rebuild(int id, int to) {
q.erase(id);
for (int i = 0; i < int(mouse[id].size()); ++i)
if (mouse[id][i] == to) {
mouse[id].erase(mouse[id].begin() + i);
break;
}
deg[id] = (int)mouse[id].size();
if (deg[id] == 0 || in_ans[id]) return;
q.insert(id);
}
void solve() {
if (m == 0) {
printf("%d\n", n);
return;
}
for (int i = 0; i < int(m); ++i) {
che[i].clear();
mouse[i].clear();
}
q.clear();
memset(in_ans, 0, sizeof in_ans);
for (int i = 0; i < int(n); ++i) {
deg[i] = 0;
int id = int(lower_bound(y, y + m, x[i]) - y);
vector<pair<int, int> > v;
if (id != m) v.push_back(make_pair(abs(x[i] - y[id]), id));
if (id > 0) v.push_back(make_pair(abs(x[i] - y[id - 1]), id - 1));
sort(v.begin(), v.end());
if (v.size() == 2 && v[1].first > v[0].first) v.pop_back();
mouse[i].clear();
dist[i] = v[0].first;
for (int j = 0; j < int(v.size()); ++j) {
che[v[j].second].push_back(i);
mouse[i].push_back(v[j].second);
}
deg[i] = (int)mouse[i].size();
}
for (int i = 0; i < int(n); ++i) q.insert(i);
for (int i = 0; i < int(n); ++i) {
if (q.empty()) break;
int id = *q.begin();
q.erase(q.begin());
if (deg[id] == 0 || in_ans[id]) continue;
int to = mouse[id][0];
for (int j = 0; j < int(che[to].size()); ++j) {
int k = che[to][j];
if (dist[k] != dist[id])
rebuild(k, to);
else {
q.erase(k);
in_ans[k] = true;
}
}
}
cout << n - count(in_ans, in_ans + n, true) << endl;
}
int main() {
while (read()) {
++test;
solve();
}
}
|
#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;
}
for (i = 0; i < n; ++i) {
for (j = 0; j < 2; ++j) {
if (cl[i][j] != -1 && S[cl[i][j]] <= M[i]) {
if (HAS_L[cl[i][j]])
cl[i][j] = -1;
else
HAS_L[cl[i][j]] = 1;
}
}
}
for (i = n - 1; i >= 0; --i) {
for (j = 1; j >= 0; --j) {
if (cl[i][j] != -1 && S[cl[i][j]] >= M[i]) {
if (HAS_R[cl[i][j]])
cl[i][j] = -1;
else
HAS_R[cl[i][j]] = 1;
}
}
}
for (i = 0; i < n; ++i)
if (cl[i][0] == -1) {
cl[i][0] = cl[i][1];
cl[i][1] = -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;
bool Comp(const pair<int, int>& a, const pair<int, int>& b) {
return (a.first < b.first);
}
int dist(int x1, int x2) { return (abs(x1 - x2)); }
int main() {
int N, M, Y1, Y2;
cin >> N >> M >> Y1 >> Y2;
if (M == 0) {
cout << N;
return 0;
}
vector<int> VN(N);
for (int i = 0; i < N; i++) cin >> VN[i];
vector<pair<int, int> > VM(M, make_pair(0, INT_MAX));
for (int i = 0; i < M; i++) cin >> VM[i].first;
int res = 0;
for (int i = 0; i < N; i++) {
vector<pair<int, int> >::iterator it =
upper_bound(VM.begin(), VM.end(), make_pair(VN[i], 0), Comp);
if (it == VM.begin()) {
int d = dist(VN[i], it->first);
if (it->second == INT_MAX || it->second == d) {
} else
res++;
it->second = d;
continue;
}
if (it == VM.end()) {
--it;
int d = dist(VN[i], it->first);
if (it->second == INT_MAX || it->second == d) {
} else
res++;
it->second = d;
continue;
}
int d1 = dist(VN[i], (it - 1)->first);
int d2 = dist(VN[i], (it)->first);
if (d1 < d2) {
--it;
if (it->second == INT_MAX || it->second == d1) {
} else
res++;
it->second = d1;
continue;
}
if (d1 > d2) {
if (it->second == INT_MAX || it->second == d2) {
} else
res++;
it->second = d2;
continue;
}
--it;
if (it->second == INT_MAX || it->second == d1)
it->second = d1;
else {
++it;
it->second = d2;
}
}
cout << res;
exit:
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500020;
int n, m;
int a[N], b[N], C[N], D[N];
int main() {
scanf("%d %d", &n, &m);
if (m == 0) return printf("0"), 0;
int x;
scanf("%d %d", &x, &x);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= m; ++i) scanf("%d", &b[i]), C[i] = 2e8;
C[0] = C[m + 1] = 2e8;
b[0] = -1000000007;
b[m + 1] = 1000000007;
int now = 1;
for (int i = 1; i <= n; ++i) {
while (b[now] < a[i]) now++;
if (a[i] - b[now - 1] < b[now] - a[i]) {
if (C[now - 1] == a[i] - b[now - 1]) D[now - 1] = 2;
if (C[now - 1] > a[i] - b[now - 1])
D[now - 1] = 1, C[now - 1] = a[i] - b[now - 1];
continue;
}
if (a[i] - b[now - 1] > b[now] - a[i]) {
if (C[now] == b[now] - a[i]) D[now] = 2;
if (C[now] > b[now] - a[i]) D[now] = 1, C[now] = b[now] - a[i];
continue;
}
if (C[now - 1] == a[i] - b[now - 1] || D[now - 1] == 0) {
if (C[now - 1] > a[i] - b[now - 1])
D[now - 1] = 1;
else
D[now - 1] = 2;
C[now - 1] = a[i] - b[now - 1];
continue;
}
D[now] = 1, C[now] = b[now] - a[i];
}
int answer = n;
for (int i = 1; i <= m; ++i) answer -= D[i];
cout << answer;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, inf = 1e9;
int n, m, a[N], b[N], ans, v[N], p = 1;
int main() {
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]);
for (int i = 1; i <= m; i++) v[i] = inf;
for (int i = 1; i <= n; i++) {
while (p < m && abs(a[i] - b[p + 1]) < abs(a[i] - b[p])) p++;
int l = p,
r = ((p < m && abs(a[i] - b[p]) == abs(a[i] - b[p + 1])) ? p + 1 : p),
d = abs(a[i] - b[p]);
if (v[l] == inf) {
v[l] = d;
ans++;
} else if (v[l] == d)
ans++;
else if (v[l] > d && l == r)
v[l] = d;
else if (l != r) {
v[r] = d;
ans++;
}
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[100100], y[100100];
vector<int> nex[100100];
int miny[100100];
const int inf = 1000000000;
inline int ABS(int a) { return a > 0 ? a : -a; }
int main() {
int n, m, i, j;
scanf("%d%d%*d%*d", &n, &m);
for (i = 0; i < n; i++) scanf("%d", &x[i]);
for (i = 0; i < m; i++) scanf("%d", &y[i]);
j = 0;
for (i = 0; i < n; i++) {
if (j < 0) j = 0;
while (j < m && y[j] <= x[i]) j++;
j--;
int mm = inf;
if (j >= 0) mm = min(mm, x[i] - y[j]);
if (j < m - 1) mm = min(mm, y[j + 1] - x[i]);
if (j >= 0 && x[i] - y[j] == mm) nex[i].push_back(j);
if (j < m - 1 && y[j + 1] - x[i] == mm) nex[i].push_back(j + 1);
}
int ans = 0;
for (i = 0; i < m; i++) miny[i] = inf;
for (i = 0; i < n; i++) {
if (nex[i].size() == 0)
while (1) puts("!");
if (nex[i].size() == 1 || miny[nex[i][0]] == inf ||
miny[nex[i][0]] == ABS(x[i] - y[nex[i][0]])) {
miny[nex[i][0]] = min(miny[nex[i][0]], ABS(x[i] - y[nex[i][0]]));
} else {
miny[nex[i][1]] = min(miny[nex[i][1]], ABS(x[i] - y[nex[i][1]]));
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < nex[i].size(); j++) {
int q = nex[i][j];
if (ABS(x[i] - y[q]) == miny[q]) break;
}
if (j == nex[i].size()) ans++;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long maxmax = 1000000000;
const long N = 200000;
long n, m, yy1, yy2, xm[N], xc[N], cnt, got[N], p[N][3], go[N];
void read_data() {
scanf("%ld%ld%ld%ld", &n, &m, &yy1, &yy2);
for (long k = 1; k <= n; k++) scanf("%ld", &xm[k]);
for (long k = 1; k <= m; k++) scanf("%ld", &xc[k]);
}
void work() {
xc[0] = -maxmax;
xc[m + 1] = maxmax;
xm[0] = -maxmax;
xm[n + 1] = maxmax;
for (long k = 1; k <= n; k++) {
long l = 0;
long r = m + 1;
while (l < r - 1) {
long med = (l + r) / 2;
if (xc[med] <= xm[k]) {
l = med;
} else {
r = med;
};
}
if (abs(xm[k] - xc[l]) == abs(xm[k] - xc[r])) {
p[k][0] = 2;
p[k][1] = l;
p[k][2] = r;
};
if (abs(xm[k] - xc[l]) < abs(xm[k] - xc[r])) {
p[k][0] = 1;
p[k][1] = l;
p[k][2] = l;
};
if (abs(xm[k] - xc[l]) > abs(xm[k] - xc[r])) {
p[k][0] = 1;
p[k][1] = r;
p[k][2] = r;
};
}
for (long k = 1; k <= n; k++) {
long i = p[k][1];
long j = p[k][2];
if (got[i] == 0 || abs(xm[got[i]] - xc[i]) == abs(xm[k] - xc[i])) {
go[k] = i;
got[i] = k;
} else if (p[k][1] != p[k][2] ||
abs(xm[got[i]] - xc[i]) > abs(xm[k] - xc[i])) {
go[k] = j;
got[j] = k;
};
}
for (long k = 1; k <= n; k++)
if (abs(xm[got[go[k]]] - xc[go[k]]) == abs(xm[k] - xc[go[k]])) cnt++;
cout << n - cnt << endl;
}
int main() {
read_data();
work();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, m, a[maxn], b[maxn], x, y, T[maxn], ans, M[maxn];
bool v[maxn];
int main() {
cin.sync_with_stdio(false);
cin >> n >> m >> x >> y;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
memset(T, 60, sizeof(T));
for (int i = 0, now = 0; i < m; i++) {
while (now < n - 1 && abs(a[now] - b[i]) > abs(a[now + 1] - b[i])) now++;
T[i] = abs(a[now] - b[i]);
}
for (int i = 0, now = 0; i < n; i++) {
while (now < m - 1 && abs(a[i] - b[now]) > abs(a[i] - b[now + 1])) now++;
int D = abs(a[i] - b[now]);
if (!v[now] || (v[now] && D == M[now]))
v[now] = true, M[now] = D, ans++;
else if (now + 1 < m && abs(a[i] - b[now + 1]) == D &&
(!v[now + 1] || (v[now + 1] && D == M[now + 1])))
v[now + 1] = true, M[now + 1] = D, ans++;
else if (D < M[now])
M[now] = D;
}
cout << n - ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 1e7 + 100;
unordered_map<int, int> vis, Cnt;
vector<int> Mice;
vector<int> Cheese;
int main() {
int n, m, y0, y1;
scanf("%d%d%d%d", &n, &m, &y0, &y1);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
Mice.push_back(x);
}
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
Cheese.push_back(x);
}
int Ans = 0;
for (int x : Mice) {
int L = INF, R = INF;
auto it = lower_bound(Cheese.begin(), Cheese.end(), x);
if (it != Cheese.end()) R = *it;
if (it != Cheese.begin()) it--;
L = *it;
int cur = min(abs(x - L), abs(R - x));
if (x - L == R - x) {
if (!vis.count(L))
vis[L] = x - L, Cnt[L] = 1;
else {
if (vis[L] == x - L)
Cnt[L]++;
else {
if (!vis.count(R))
vis[R] = cur, Cnt[R] = 1;
else if (vis[R] > cur) {
Ans += vis[R];
vis[R] = cur;
Cnt[R] = 1;
} else if (vis[R] == cur)
Cnt[R]++;
else
Ans++;
}
}
} else {
int d = (x - L < R - x ? L : R);
if (!vis.count(d))
vis[d] = cur, Cnt[d] = 1;
else {
if (vis[d] > cur) {
Ans += Cnt[d];
vis[d] = cur;
Cnt[d] = 1;
} else if (vis[d] < cur)
Ans++;
else
Cnt[d]++;
}
}
}
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace {
static const int mo = 1e9 + 7;
void add(int &x, int y) {
if ((x += y) >= mo) x -= mo;
}
void sub(int &x, int y) {
if ((x -= y) < 0) x += mo;
}
int mul(int x, int y) { return 1ll * x * y % mo; }
int pw(int b, int p, int mo) {
if (p < 2) return p ? b : 1;
long long t = pw(b, p >> 1, mo);
t = t * t % mo;
return p & 1 ? t * b % mo : t;
}
void upd(int &x, int y) { add(x, y); }
} // namespace
const int N = 100005;
int n, m, ans, a[N], b[N], lf[N], rt[N];
bool vis[N], used[N];
int main() {
cin >> n >> m >> ans >> ans, ans = 0;
a[n + 1] = 1e9;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
b[0] = -1e9, b[m + 1] = 1e9;
for (int i = 1; i <= m; ++i) scanf("%d", &b[i]);
for (int i = 1; i <= n; ++i) {
int pre = upper_bound(b, b + m + 2, a[i]) - b - 1;
int suc = lower_bound(b, b + m + 2, a[i]) - b;
lf[i] = pre, rt[i] = suc;
}
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
vis[i] = 1;
if (lf[i] != 0 && !used[lf[i]]) {
if (a[i] - b[lf[i]] <= b[rt[i]] - a[i]) {
++ans, used[lf[i]] = 1;
continue;
}
}
if (rt[i] != m + 1 && !used[rt[i]]) {
if (a[i] - b[lf[i]] >= b[rt[i]] - a[i]) {
bool ok = 1;
for (int j = i + 1; j <= n; ++j)
if (!vis[j]) {
if (a[j] - b[rt[i]] >= b[rt[i]] - a[i]) break;
if (rt[i] == lf[j] && rt[i] == rt[j]) {
ok = 0;
break;
}
if (rt[i] == lf[j]) {
if (a[j] - b[lf[j]] < b[rt[j]] - a[j]) {
ok = 0;
break;
}
}
if (rt[i] == rt[j]) {
if (a[j] - b[lf[j]] > b[rt[j]] - a[j]) {
ok = 0;
break;
}
}
}
if (!ok) continue;
++ans, used[rt[i]] = 1;
int oth = lower_bound(a + 1, a + n + 2, b[rt[i]] * 2 - a[i]) - a;
if (a[oth] == b[rt[i]] * 2 - a[i] && b[rt[i]] == b[lf[oth]] &&
a[oth] - b[rt[i]] <= b[rt[oth]] - a[oth])
++ans, vis[oth] = 1;
}
}
}
cout << n - ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 95542721;
const int INF = 2e9;
const long long INF64 = 2e18;
const long double EPS = 1e-16;
const long long MD = 1551513443;
const long long T = 2543;
const int N = 200011;
const int M = 23;
const int DEBUG = 0;
const int MAGIC = 320;
int n, m, sdkfaslhagaklsldk, aasdfasdfasdf, a[N], b[N], dp[N], d[N];
inline int dist(int x1, int x2) { return abs(x1 - x2); }
int main() {
cin >> n >> m >> sdkfaslhagaklsldk >> aasdfasdfasdf;
for (int i = 0; i < int(n); i++) cin >> a[i];
for (int i = 0; i < int(m); i++) cin >> b[i];
int j = 0, ans = 0;
fill(d, d + m, INF);
for (int i = 0; i < int(n); i++) {
while (j + 1 < m && dist(a[i], b[j]) > dist(a[i], b[j + 1])) j++;
if (j + 1 < m && dist(a[i], b[j]) == dist(a[i], b[j + 1])) {
if (dp[j]) {
if (d[j] == dist(a[i], b[j])) {
dp[j]++;
ans++;
} else {
j++;
d[j] = dist(a[i], b[j]);
ans++;
dp[j] = 1;
}
} else {
d[j] = dist(a[i], b[j]);
ans++;
dp[j] = 1;
}
} else {
if (d[j] > dist(a[i], b[j])) {
d[j] = dist(a[i], b[j]);
ans -= dp[j];
ans++;
dp[j] = 1;
} else if (d[j] == dist(a[i], b[j])) {
ans++;
dp[j]++;
}
}
}
cout << n - ans;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 100005;
int dx[maxn], dy[maxn], flag[maxn], ans[maxn], n, m;
int abs(int a) { return a < 0 ? -a : a; }
void init() {
int y1, y2;
scanf("%d%d%d%d", &n, &m, &y1, &y2);
for (int i = 0; i < n; i++) scanf("%d", &dx[i]);
for (int i = 0; i < m; i++) scanf("%d", &dy[i]);
}
int find(int key, int f) {
int lower = 0, upper = m - 1, ret = -1;
while (lower <= upper) {
int mid = (lower + upper) >> 1;
if (!f) {
if (dy[mid] <= key) {
ret = mid;
lower = mid + 1;
} else
upper = mid - 1;
} else {
if (dy[mid] >= key) {
ret = mid;
upper = mid - 1;
} else
lower = mid + 1;
}
}
return ret;
}
void work() {
memset(flag, -1, sizeof(flag));
for (int i = 0; i < n; i++) {
int t1 = find(dx[i], 0), t2 = find(dx[i], 1);
if (t1 == t2 || t1 == -1 || t2 == -1 ||
abs(dx[i] - dy[t1]) != abs(dx[i] - dy[t2])) {
int t;
if (t1 == -1)
t = t2;
else if (t2 == -1)
t = t1;
else if (abs(dx[i] - dy[t1]) < abs(dx[i] - dy[t2]))
t = t1;
else
t = t2;
if (flag[t] == -1 || flag[t] > abs(dx[i] - dy[t])) {
ans[t] = 1;
flag[t] = abs(dx[i] - dy[t]);
} else
ans[t] += flag[t] == abs(dx[i] - dy[t]);
} else {
if (flag[t1] == -1 || flag[t1] == abs(dx[i] - dy[t1])) {
ans[t1]++;
flag[t1] = abs(dx[i] - dy[t1]);
} else if (flag[t2] == -1 || flag[t2] > abs(dx[i] - dy[t2])) {
ans[t2] = 1;
flag[t2] = abs(dx[i] - dy[t2]);
}
}
}
int tot = 0;
for (int i = 0; i < m; i++) tot += ans[i];
printf("%d\n", n - tot);
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long x0[N], x1[N];
long long n, m;
long long dist(long long i, long long j) {
return j < m ? abs(x0[i] - x1[j]) : -1u / 2;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long y1, y2;
cin >> n >> m >> y1 >> y2;
for (long long i = 0; i < n; ++i) cin >> x0[i];
for (long long j = 0; j < m; ++j) cin >> x1[j];
long long res = n, last = -1, last_dist = -1;
for (long long i = 0, j = 0; i < n && j < m; ++i) {
for (; j + 1 < m && x1[j + 1] <= x0[i]; ++j)
;
long long d1 = dist(i, j), d2 = dist(i, j + 1);
if (d2 < d1) {
d1 = d2;
d2 = -1u / 2;
++j;
}
if (j != last || d1 == last_dist || d1 == d2 && ++j) {
--res;
last_dist = d1;
last = j;
} else {
if (d1 < last_dist) last_dist = d1;
}
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[101010], b[101010], r[101010], v[101010], dp[101010][2];
int js(int l, int r, int i) {
if (l > r) {
return 0;
}
int rt = r - l, p = lower_bound(a + l, a + r + 1, b[i]) - a;
if (p <= r && p >= l + 1 && a[p] - b[i] == b[i] - a[p - 1]) {
rt--;
}
return rt;
}
int main() {
int yy1, yy2;
cin >> n >> m >> yy1 >> yy2;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= m; i++) {
cin >> b[i];
}
for (int i = 1; i <= n; i++) {
int p = lower_bound(b + 1, b + m + 1, a[i]) - b;
if (p > m) {
r[m] = i;
} else if (p >= 2) {
if (a[i] - b[p - 1] < b[p] - a[i]) {
r[p - 1] = i;
} else if (a[i] - b[p - 1] == b[p] - a[i]) {
v[p - 1]++;
r[p] = i;
} else {
r[p] = i;
}
} else {
r[1] = i;
}
}
for (int i = 1; i <= m; i++) {
r[i] = max(r[i], r[i - 1]);
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j <= v[i]; j++) {
dp[i][j] = 1e9;
for (int k = 0; k <= v[i - 1]; k++) {
dp[i][j] =
min(dp[i][j], dp[i - 1][k] + js(r[i - 1] + 1 + k, r[i] + j, i));
}
}
}
cout << dp[m][0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N], b[N], d[N], used[N], dis[N], ANS[N], dlt[N];
int n, m, Y0, Y1, lft, ans;
vector<int> ch[N], fa[N];
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
int ABS(int x) {
if (x >= 0)
return x;
else
return -x;
}
int lnk(int x, int y) {
ch[x].push_back(y);
fa[y].push_back(x);
return ABS(b[x] - a[y]);
}
int avi(int x) {
int ret = 0;
for (int i = 0; i < int(fa[x].size()); i++) {
int to = fa[x][i];
if (used[to] == -1 || used[to] == dis[x]) ret++;
}
return ret;
}
int main() {
scanf("%d%d%d%d", &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);
for (int i = 1; i <= m; i++) used[i] = -1;
for (int i = 1; i <= n; i++) {
int x = lower_bound(b + 1, b + 1 + m, a[i]) - b - 1;
int y = x + 1;
if (x == 0)
dis[i] = lnk(y, i);
else if (y == m + 1)
dis[i] = lnk(x, i);
else if (a[i] - b[x] < b[y] - a[i])
dis[i] = lnk(x, i);
else if (a[i] - b[x] > b[y] - a[i])
dis[i] = lnk(y, i);
else {
dis[i] = lnk(x, i);
lnk(y, i);
}
if (avi(i) == 1) {
dlt[i] = 1;
pq.push(make_pair(dis[i], i));
}
}
lft = n;
while (!pq.empty()) {
int D = pq.top().first, x = pq.top().second, y;
pq.pop();
lft--;
if (avi(x) == 0) continue;
for (int i = 0; i < int(fa[x].size()); i++) {
y = fa[x][i];
if (used[y] == -1 || used[y] == D) break;
}
used[y] = D;
ANS[y]++;
for (int i = 0; i < int(ch[y].size()); i++) {
int to = ch[y][i];
if (dis[to] != D && !dlt[to] && avi(to) == 1) {
dlt[to] = 1;
pq.push(make_pair(dis[to], to));
}
}
}
for (int i = 1; i <= m; i++) ans += ANS[i];
ans += lft;
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:10000000")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
const int INF = (int)1E9 + 7;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int NMAX = 200 * 1000;
int n, m;
int a[NMAX], b[NMAX], minD[NMAX], cmin[NMAX], dm[NMAX], cm[NMAX], to[NMAX];
int d[NMAX][2];
int main() {
int y0, y1;
cin >> n >> m >> y0 >> y1;
for (int i = 0; i < int(n); ++i) scanf("%d", &a[i]);
for (int i = 0; i < int(m); ++i) scanf("%d", &b[i]);
if (m == 0) {
cout << n << endl;
exit(0);
}
sort(a, a + n);
sort(b, b + m);
int ans = 0;
memset(dm, 63, sizeof dm);
memset(minD, 63, sizeof minD);
memset(to, -1, sizeof to);
vector<int> bad;
for (int i = 0; i < int(n); ++i) {
int pos = lower_bound(b, b + m, a[i]) - b;
for (int j = max(pos - 4, 0); j <= min(pos + 4, m - 1); j++) {
int cd = abs(b[j] - a[i]);
if (cd <= dm[i]) {
if (dm[i] == cd)
cm[i]++;
else
dm[i] = cd, cm[i] = 1, to[i] = j;
}
}
assert(cm[i] <= 2);
assert(to[i] != -1);
if (cm[i] == 1) {
int j = to[i];
if (dm[i] <= minD[j]) {
if (minD[j] == dm[i])
cmin[j]++;
else
ans += cmin[j], minD[j] = dm[i], cmin[j] = 1;
} else
ans++;
} else
bad.push_back(i);
}
if (bad.empty()) {
cout << ans << endl;
} else {
memset(d, 63, sizeof d);
for (int i = 0; i < int(int((bad).size())); ++i) {
for (int forw = 0; forw < int(2); ++forw) {
int to = a[bad[i]] + (forw ? dm[bad[i]] : -dm[bad[i]]);
int j = lower_bound(b, b + m, to) - b;
for (int pforw = 0; pforw < int(2); ++pforw) {
int prev = 0;
if (i == 0)
prev = ans;
else
prev = d[i - 1][pforw];
if (i > 0 && forw == 0 && pforw == 1 &&
a[bad[i - 1]] + dm[bad[i - 1]] == a[bad[i]] - dm[bad[i]]) {
int cnt = prev;
if (min(minD[j], dm[bad[i - 1]]) != dm[bad[i]]) {
if (min(minD[j], dm[bad[i - 1]]) < dm[bad[i]])
cnt++;
else {
if (minD[j] == dm[bad[i - 1]])
cnt += cmin[j] + 1;
else {
if (minD[j] < dm[bad[i - 1]])
cnt += cmin[j];
else
cnt++;
}
}
}
d[i][forw] = min(d[i][forw], cnt);
} else {
int cnt = prev;
if (minD[j] != dm[bad[i]]) {
if (minD[j] > dm[bad[i]])
cnt += cmin[j];
else
cnt++;
}
d[i][forw] = min(d[i][forw], cnt);
}
}
}
}
ans = min(d[int((bad).size()) - 1][0], d[int((bad).size()) - 1][1]);
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long n, m, tt, zz;
cin >> n >> m >> tt >> zz;
int 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 l = 0;
int d[m];
for (int i = 0; i < m; i++) d[i] = 1e9;
int res = 0;
for (int i = 0; i < n; i++) {
int l = 0, r = m - 1;
while (l < r) {
int mid = (l + r) / 2;
mid++;
if (b[mid] > a[i])
r = mid - 1;
else
l = mid;
}
if (b[l] > a[i]) {
if (d[l] == 1e9) res++;
d[l] = min(d[l], b[l] - a[i]);
} else {
if (l + 1 < m) {
int d1 = a[i] - b[l], d2 = b[l + 1] - a[i];
if (d1 < d2) {
if (d[l] == 1e9 || d[l] == d1) res++;
d[l] = min(d[l], d1);
} else if (d1 > d2) {
if (d[l + 1] == 1e9) res++;
d[l + 1] = min(d[l + 1], d2);
} else {
if (d[l] == d1 || d[l] == 1e9) {
res++;
d[l] = d1;
continue;
} else {
if (d[l + 1] == 1e9) res++;
d[l + 1] = b[l + 1] - a[i];
}
}
} else {
if (d[l] == 1e9 || d[l] == a[i] - b[l]) res++;
d[l] = min(d[l], a[i] - b[l]);
}
}
}
cout << n - res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 100 + 3, inf = 1000 * 1000 * 100;
int n, m, a[MAXN], b[MAXN], t[MAXN], ans = 0, y, z;
int main() {
cin >> n >> m >> y >> z;
for (int i = 0; i < n; i++) cin >> a[i];
b[0] = -inf;
b[m + 1] = inf;
for (int i = 1; i <= m; i++) cin >> b[i];
for (int i = 0; i <= m; i++) t[i] = -1;
for (int i = 0; i < n; i++) {
int ind = lower_bound(b, b + m + 2, a[i]) - b;
int nex = b[ind], prev = b[ind - 1];
if (nex - a[i] < a[i] - prev) {
if (t[ind] != -1) ans++;
t[ind] = nex - a[i];
} else if (nex - a[i] > a[i] - prev) {
if (t[ind - 1] != -1 && t[ind - 1] < a[i] - prev) {
ans++;
} else {
if (t[ind - 1] > a[i] - prev) ans++;
t[ind - 1] = a[i] - prev;
}
} else {
if (t[ind - 1] == -1 || t[ind - 1] == a[i] - prev) {
t[ind - 1] = a[i] - prev;
} else {
t[ind] = nex - a[i];
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, Y0, Y1;
typedef struct CHEES {
int pos;
int time;
};
CHEES chess[100002];
int mice[100002][3];
int min(int x, int y) { return x < y ? x : y; }
void inputData() {
int i;
for (i = 1; i <= N; i++) {
scanf("%d", &(mice[i][0]));
mice[i][1] = -1;
mice[i][2] = -1;
}
for (i = 1; i <= M; i++) {
scanf("%d", &(chess[i].pos));
chess[i].time = -1;
}
}
void computeDistance() {
int i, j, pre = 1, k = 0;
for (i = 1; i <= N; i++) {
int dis = abs(mice[i][0] - chess[pre].pos);
while (pre + 1 <= M && dis > abs(mice[i][0] - chess[pre + 1].pos)) {
dis = abs(mice[i][0] - chess[pre + 1].pos);
pre++;
}
if (pre < M && dis == abs(mice[i][0] - chess[pre + 1].pos)) {
mice[i][1] = pre;
mice[i][2] = pre + 1;
pre++;
} else if (pre < M && dis > abs(mice[i][0] - chess[pre + 1].pos)) {
mice[i][1] = pre + 1;
mice[i][2] = -1;
pre++;
} else if ((pre < M && dis < abs(mice[i][0] - chess[pre + 1].pos)) ||
pre >= M) {
mice[i][1] = pre;
mice[i][2] = -1;
}
}
}
int binarySearch() {
int ans = 0;
for (int i = 1; i <= N; i++) {
if (chess[mice[i][1]].time == -1 ||
chess[mice[i][1]].time == abs(mice[i][0] - chess[mice[i][1]].pos)) {
ans++;
chess[mice[i][1]].time = abs(mice[i][0] - chess[mice[i][1]].pos);
} else if (mice[i][2] != -1) {
ans++;
chess[mice[i][2]].time = abs(mice[i][0] - chess[mice[i][2]].pos);
} else {
chess[mice[i][1]].time =
min(chess[mice[i][1]].time, abs(mice[i][0] - chess[mice[i][1]].pos));
}
}
return ans;
}
int main() {
while (scanf("%d%d%d%d", &N, &M, &Y0, &Y1) != EOF) {
inputData();
computeDistance();
int maxMice = binarySearch();
printf("%d\n", N - maxMice);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, Y0, Y1, ans;
int a[N], b[N], used[N];
int ABS(int x) {
if (x >= 0)
return x;
else
return -x;
}
void solve(int x, int y) {
if (!~used[y])
used[y] = ABS(b[y] - a[x]);
else if (used[y] != ABS(b[y] - a[x])) {
ans++;
used[y] = min(used[y], ABS(b[y] - a[x]));
}
}
int main() {
scanf("%d%d%d%d", &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);
for (int i = 1; i <= m; i++) used[i] = -1;
for (int i = 1; i <= n; i++) {
int r = lower_bound(b + 1, b + 1 + m, a[i]) - b;
int l = r - 1;
if (l == 0)
solve(i, r);
else if (r == m + 1)
solve(i, l);
else if (a[i] - b[l] < b[r] - a[i])
solve(i, l);
else if (a[i] - b[l] > b[r] - a[i])
solve(i, r);
else if (!~used[l] || used[l] == a[i] - b[l])
used[l] = a[i] - b[l];
else
used[r] = b[r] - a[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> mice, cheese;
map<int, int> dch;
int n, m, a[111111], wtf;
inline int shortest(set<int> &s, int who) {
set<int>::iterator it = s.lower_bound(who);
int ans = 1000000000;
if (*it != 1000000000) ans = min(ans, *it - who);
it--;
if (*it != -1000000000) ans = min(ans, who - *it);
return ans;
}
int main() {
scanf("%d%d%d%d", &n, &m, &wtf, &wtf);
for (int(i) = 0; (i) < (n); ++(i)) {
scanf("%d", &a[i]);
mice.insert(a[i]);
}
for (int(i) = 0; (i) < (m); ++(i)) {
int x;
scanf("%d", &x);
cheese.insert(x);
}
mice.insert(1000000000);
mice.insert(-1000000000);
cheese.insert(1000000000);
cheese.insert(-1000000000);
int ans = n;
for (int(i) = 0; (i) < (n); ++(i)) {
int dst = shortest(cheese, a[i]);
int d = dst;
if (cheese.find(a[i] - d) != cheese.end() &&
*mice.lower_bound(a[i] - d) == a[i] &&
(dch.find(a[i] - d) == dch.end() || dch[a[i] - d] == dst)) {
ans--;
dch[a[i] - dst] = dst;
} else if (cheese.find(a[i] + d) != cheese.end() &&
*mice.upper_bound(a[i]) > a[i] + d &&
(dch.find(a[i] + d) == dch.end() || dch[a[i] + d] == dst)) {
ans--;
dch[a[i] + dst] = dst;
}
}
cout << ans << endl;
}
|
#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;
}
}
previousCheese = now;
}
cout << n - ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 1e7 + 100;
unordered_map<int, int> vis, Cnt;
vector<int> Mice;
vector<int> Cheese;
int main() {
int n, m, y0, y1;
scanf("%d%d%d%d", &n, &m, &y0, &y1);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
Mice.push_back(x);
}
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
Cheese.push_back(x);
}
int Ans = 0;
for (int x : Mice) {
int L = INF, R = INF;
auto it = lower_bound(Cheese.begin(), Cheese.end(), x);
if (it != Cheese.end()) R = *it;
if (it != Cheese.begin()) it--;
L = *it;
int cur = min(abs(x - L), abs(R - x));
if (x - L == R - x) {
if (!vis.count(L))
vis[L] = x - L, Cnt[L] = 1;
else {
if (vis[L] == x - L)
Cnt[L]++;
else {
if (!vis.count(R))
vis[R] = cur, Cnt[R] = 1;
else if (vis[R] > cur) {
Ans += vis[R];
vis[R] = cur;
Cnt[R] = 1;
} else if (vis[R] == cur)
Cnt[R]++;
else
Ans++;
}
}
} else {
int d = (x - L < R - x ? L : R);
if (!vis.count(d))
vis[d] = cur, Cnt[d] = 1;
else {
if (vis[d] > cur) {
Ans += Cnt[d];
vis[d] = cur;
Cnt[d] = 1;
} else if (vis[d] < cur)
Ans++;
else
Cnt[d]++;
}
}
}
printf("%d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, t, ans;
int main() {
vector<pair<int, int> > g;
vector<int> napr, used;
cin >> n >> m >> t >> t;
for (int i = 0; i < n; i++) {
cin >> t;
g.push_back(make_pair(t, 1));
}
for (int i = 0; i < m; i++) {
cin >> t;
g.push_back(make_pair(t, 0));
}
napr.resize(n + m, 0);
used.resize(n + m, 0);
sort(g.begin(), g.end());
for (int i = 0; i < n + m; i++)
if (g[i].second == 1) {
if (i && g[i - 1].second == 0 &&
(i == n + m - 1 || g[i + 1].second == 1)) {
int d = abs(g[i - 1].first - g[i].first);
napr[i] = 1;
for (int j = i; j < n + m; j++)
if (g[j].second == 0) {
if (d > abs(g[i].first - g[j].first)) napr[i] = 0;
break;
}
}
if (i != n + m - 1 && g[i + 1].second == 0 &&
(i == 0 || g[i - 1].second == 1)) {
int d = abs(g[i + 1].first - g[i].first);
napr[i] = 2;
for (int j = i; j >= 0; j--)
if (g[j].second == 0) {
if (d > abs(g[i].first - g[j].first)) napr[i] = 0;
break;
}
}
if (i && i < n + m - 1 && g[i - 1].second == 0 && g[i + 1].second == 0)
if (abs(g[i + 1].first - g[i].first) < abs(g[i - 1].first - g[i].first))
napr[i] = 2;
else if (abs(g[i + 1].first - g[i].first) >
abs(g[i - 1].first - g[i].first))
napr[i] = 1;
else
napr[i] = 12;
}
for (int i = 0; i < n + m; i++)
if (g[i].second == 1 && !used[i]) {
if (napr[i] == 0) {
ans++;
continue;
}
if (i && (napr[i] == 1 || napr[i] == 12) && g[i - 1].second == 0) {
if (!used[i - 1] || (used[i - 1] == abs(g[i].first - g[i - 1].first))) {
used[i - 1] = abs(g[i].first - g[i - 1].first);
continue;
} else {
if (used[i - 1] >= abs(g[i].first - g[i - 1].first) && napr[i] == 1) {
ans++;
continue;
}
}
}
if (i < n + m - 1 && (napr[i] == 2 || napr[i] == 12) &&
g[i + 1].second == 0 && !used[i + 1]) {
used[i + 1] = abs(g[i].first - g[i + 1].first);
continue;
}
ans++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m;
long long Y0, Y1, a[N], b[N];
vector<int> ve[N], mice;
int choice[N], num[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> Y0 >> Y1;
for (int i = (0); i < (n); i++) cin >> a[i];
for (int i = (0); i < (m); i++) cin >> b[i];
int cheese = 0;
for (int i = (0); i < (n); i++) {
while (cheese < m && b[cheese] < a[i]) cheese++;
if (cheese < m && cheese > 0 && b[cheese] - a[i] == a[i] - b[cheese - 1]) {
mice.push_back(i);
choice[i] = cheese;
} else if (cheese == m || (cheese < m && cheese > 0 &&
b[cheese] - a[i] > a[i] - b[cheese - 1])) {
ve[cheese - 1].push_back(a[i] - b[cheese - 1]);
} else {
ve[cheese].push_back(b[cheese] - a[i]);
}
}
for (int i = (0); i < (m); i++) {
sort((ve[i]).begin(), (ve[i]).end());
num[i] = !ve[i].empty();
if (((int)(ve[i]).size()) >= 2 && ve[i][0] == ve[i][1]) num[i] = 2;
}
auto delta = [&](int cheese, int i) {
if (ve[cheese].empty()) return 1;
long long dist = abs(b[cheese] - a[i]);
if (dist < ve[cheese][0])
return 1 - num[cheese];
else if (dist == ve[cheese][0])
return 1 + num[cheese];
else
return 0;
};
auto upd = [&](int cheese, int i) {
long long dist = abs(b[cheese] - a[i]);
ve[cheese].push_back(dist);
sort((ve[cheese]).begin(), (ve[cheese]).end());
num[cheese] = 1;
if (((int)(ve[cheese]).size()) >= 2 && ve[cheese][0] == ve[cheese][1])
num[cheese] = 2;
};
for (int i : mice) {
int d1 = delta(choice[i], i);
int d2 = delta(choice[i] - 1, i);
if (d1 > d2) {
upd(choice[i], i);
} else {
upd(choice[i] - 1, i);
}
}
int ans = n;
for (int i = (0); i < (m); i++) ans -= num[i];
cout << ans << endl;
}
|
#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;
scanf("%d %d %d %d", &n, &m, &y0, &y1);
for (int i = 0; i < n; ++i) {
scanf("%d", &x0[i]);
}
memset(d, -1, sizeof(d));
for (int i = 0; i < m; ++i) {
scanf("%d", &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;
}
printf("%d\n", n - k);
return 0;
}
|
#include <bits/stdc++.h>
const int MAX = 100000;
int pos1[MAX];
int pos2[MAX];
int main() {
int n, m, y0, y1;
while (scanf("%d%d%d%d", &n, &m, &y0, &y1) == 4) {
for (int i = 0; i < n; ++i) scanf("%d", &pos1[i]);
for (int i = 0; i < m; ++i) scanf("%d", &pos2[i]);
int idx1 = 0, idx2 = 0;
int full = 0;
int lastIdx = -1;
int lastDis = -1;
for (; idx1 < n; ++idx1) {
if (idx2 < m) {
while (idx2 + 1 < m &&
abs(pos2[idx2 + 1] - pos1[idx1]) < abs(pos2[idx2] - pos1[idx1]))
++idx2;
int dis = abs(pos2[idx2] - pos1[idx1]);
if (lastIdx == idx2) {
if (lastDis < dis) {
if (idx2 + 1 < m && abs(pos2[idx2 + 1] - pos1[idx1]) == dis) {
++idx2;
lastDis = abs(pos2[idx2] - pos1[idx1]);
lastIdx = idx2;
++full;
}
} else if (lastDis > dis) {
if (idx2 + 1 < m && abs(pos2[idx2 + 1] - pos1[idx1]) == dis) {
++idx2;
lastDis = abs(pos2[idx2] - pos1[idx1]);
lastIdx = idx2;
++full;
} else {
lastIdx = idx2;
lastDis = dis;
}
} else {
lastIdx = idx2;
lastDis = dis;
++full;
}
} else {
lastIdx = idx2;
lastDis = dis;
++full;
}
}
}
printf("%d\n", n - full);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x[100010], y[100010], dist[100010];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
int rubbish;
cin >> rubbish >> rubbish;
for (int i = 1; i <= n; i++) {
cin >> x[i];
}
y[0] = -(1e9);
for (int i = 1; i <= m; i++) {
cin >> y[i];
}
y[m + 1] = (1e9);
for (int i = 0; i <= m + 1; i++) {
dist[i] = (1e9);
}
int res = n;
for (int i = 1; i <= n; i++) {
int pos = lower_bound(y, y + m + 2, x[i]) - y;
int a = x[i] - y[pos - 1], b = y[pos] - x[i];
int mn = min(a, b);
if ((b > a) ||
((a == b) && (dist[pos - 1] == (1e9) || dist[pos - 1] == mn))) {
pos--;
}
if (dist[pos] == (1e9) || dist[pos] == mn) {
res--;
}
dist[pos] = min(dist[pos], mn);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[100005], a[100005], v[100005];
int main() {
int n, m, y0, y1, i;
while (~scanf("%d%d%d%d", &n, &m, &y0, &y1)) {
for (i = 0; i < n; i++) scanf("%d", a + i);
for (i = 1; i <= m; i++) scanf("%d", c + i);
c[0] = -0x3f3f3f3f, c[m + 1] = 0x3f3f3f3f;
int t = 0, res = n;
memset(v, 0, sizeof(v));
for (i = 0; i < n; i++) {
int x = abs(a[i] - c[t]), y = 0;
while (1) {
y = abs(a[i] - c[t + 1]);
if (y >= x) break;
x = y;
t++;
}
if (v[t] == 0)
res--, v[t] = x + 1;
else if (v[t] == x + 1)
res--;
else if (y == x)
res--, v[t + 1] = x + 1;
else
v[t] = min(v[t], x + 1);
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 100050;
int a[mx];
int b[mx];
int main() {
int n, m, y, yy;
scanf("%d %d %d %d", &n, &m, &y, &yy);
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, last = -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 != last || abs(a[x] - b[j]) == abs(a[x - 1] - b[j]))
kk++, last = j;
else if (j + 1 < m && abs(a[x] - b[j]) == abs(a[x] - b[j + 1]))
kk++, last = ++j;
else
last = j;
}
cout << n - kk << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, Y1, Y2;
int chees[100000];
int mouses[100000];
int mins[100000];
int counts[100000];
bool middle[100000];
int main() {
scanf("%d%d%d%d", &N, &M, &Y1, &Y2);
for (int i = 0; i < N; i++) scanf("%d", &mouses[i]);
for (int i = 0; i < M; i++) scanf("%d", &chees[i]);
for (int i = 0; i < 100000; i++) {
mins[i] = 1000000000;
counts[i] = 0;
middle[i] = false;
}
int cheesIndex = 0;
for (int i = 0; i < N; i++) {
while (cheesIndex + 1 < M && chees[cheesIndex + 1] <= mouses[i])
cheesIndex++;
if (mouses[i] < chees[cheesIndex]) {
mins[0] = chees[cheesIndex] - mouses[i];
counts[0] = 1;
continue;
}
bool mid = false;
int x = mouses[i] - chees[cheesIndex];
int y = -1;
if (cheesIndex + 1 < M) {
y = chees[cheesIndex + 1] - mouses[i];
if (x == y) mid = true;
}
if (mid)
middle[i] = true;
else {
int index;
int a;
if (y == -1 || y > x) {
index = cheesIndex;
a = x;
} else {
index = cheesIndex + 1;
a = y;
}
if (mins[index] > a) {
mins[index] = a;
counts[index] = 1;
} else if (mins[index] == a) {
counts[index]++;
}
}
}
cheesIndex = 0;
for (int i = 0; i < N; i++)
if (middle[i]) {
while (cheesIndex + 1 < M && chees[cheesIndex + 1] <= mouses[i])
cheesIndex++;
if (mins[cheesIndex] == 1000000000) {
counts[cheesIndex] = 1;
mins[cheesIndex] = mouses[i] - chees[cheesIndex];
} else if (mins[cheesIndex] == mouses[i] - chees[cheesIndex]) {
counts[cheesIndex]++;
} else if (cheesIndex + 1 < M && mins[cheesIndex + 1] == 1000000000) {
counts[cheesIndex + 1] = 1;
mins[cheesIndex + 1] = chees[cheesIndex + 1] - mouses[i];
} else if (cheesIndex + 1 < M &&
mins[cheesIndex + 1] == chees[cheesIndex + 1] - mouses[i]) {
counts[cheesIndex + 1]++;
}
}
int res = N;
for (int i = 0; i < M; i++) res -= counts[i];
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dis(int A, int B) { return abs(A - B); }
int bt[100005];
int main() {
int n, m;
scanf("%d %d", &n, &m);
;
int Y0, Y1;
scanf("%d %d", &Y0, &Y1);
;
vector<int> v, v2;
for (int i = 0; i < n; i++) {
int tmp;
scanf("%d", &tmp);
;
v.push_back(tmp);
}
for (int i = 0; i <= 100000; i++) bt[i] = INT_MAX;
for (int i = 0; i < m; i++) {
int tmp;
scanf("%d", &tmp);
;
v2.push_back(tmp);
}
int p1 = 0, p2 = 1;
int ans = 0;
for (int i = 0; i < n; i++) {
while (dis(v2[p1], v[i]) > dis(v2[p2], v[i])) {
p1++;
p2++;
}
int A, B;
A = dis(v2[p1], v[i]);
B = dis(v2[p2], v[i]);
if (A < B) {
if (bt[p1] == A || bt[p1] == INT_MAX) {
bt[p1] = A;
ans++;
} else if (A < bt[p1]) {
bt[p1] = A;
}
}
if (A == B) {
if (bt[p1] == A) {
ans++;
} else if (bt[p1] == INT_MAX) {
bt[p1] = A;
ans++;
} else if (bt[p2] == INT_MAX) {
bt[p2] = B;
ans++;
}
}
if (A > B) {
if (bt[p2] == INT_MAX) {
bt[p2] = B;
ans++;
}
}
}
printf("%d\n", n - ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
int x[MAXN + 10], y[MAXN + 10], d[MAXN + 10];
int main() {
int i, j, k, n, m, Y0, Y1;
while (scanf("%d%d", &n, &m) != EOF) {
scanf("%d%d", &Y0, &Y1);
memset(d, -1, sizeof(d));
for (i = 0; i < n; i++) scanf("%d", x + i);
for (i = 0; i < m; i++) scanf("%d", y + i);
j = 0;
int tt = 0;
for (i = 0; i < n; i++) {
while (y[j] < x[i] && j < m) j++;
if (j > 0) {
if (abs(y[j] - x[i]) < abs(y[j - 1] - x[i])) {
if (d[j] == -1 || abs(x[d[j]] - y[j]) == abs(x[i] - y[j])) {
d[j] = i;
tt++;
} else if (abs(x[d[j]] - y[j]) > abs(x[i] - y[j])) {
d[j] = i;
}
} else if (abs(x[i] - y[j]) > abs(x[i] - y[j - 1])) {
if (d[j - 1] == -1 ||
abs(x[d[j - 1]] - y[j - 1]) == abs(x[i] - y[j - 1])) {
d[j - 1] = i;
tt++;
} else if (abs(x[d[j - 1]] - y[j - 1]) > abs(x[i] - y[j - 1])) {
d[j - 1] = i;
}
} else {
if (d[j - 1] == -1 ||
abs(x[d[j - 1]] - y[j - 1]) == abs(x[i] - y[j - 1])) {
d[j - 1] = i;
tt++;
} else {
d[j] = i;
tt++;
}
}
} else {
if (d[j] == -1 || abs(x[d[j]] - y[j]) == abs(x[i] - y[j])) {
d[j] = i;
tt++;
} else if (abs(x[d[j]] - y[j]) > abs(x[i] - y[j]))
d[j] = i;
}
}
cout << n - tt << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, y0, y1;
cin >> n >> m >> y0 >> y1;
vector<int> mice(n), ch(m), chmdist(m, 0x7fffffff), mcnt(m, 0);
for (int i = 0; i < n; i++) cin >> mice[i];
for (int i = 0; i < m; i++) cin >> ch[i];
int ch_ptr = 0, nh = 0;
for (int i = 0; i < n; i++) {
while (ch_ptr < m - 1 && ch[ch_ptr + 1] <= mice[i]) ch_ptr++;
int left_dist = abs(mice[i] - ch[ch_ptr]), right_dist = 0x7fffffff;
if (ch_ptr < m - 1) right_dist = ch[ch_ptr + 1] - mice[i];
if (left_dist < right_dist)
if (left_dist > chmdist[ch_ptr])
nh++;
else if (left_dist < chmdist[ch_ptr]) {
chmdist[ch_ptr] = left_dist;
nh += mcnt[ch_ptr];
mcnt[ch_ptr] = 1;
} else
mcnt[ch_ptr]++;
else if (right_dist < left_dist)
if (right_dist > chmdist[ch_ptr + 1])
nh++;
else if (right_dist < chmdist[ch_ptr + 1]) {
chmdist[ch_ptr + 1] = right_dist;
nh += mcnt[ch_ptr + 1];
mcnt[ch_ptr + 1] = 1;
} else
mcnt[ch_ptr + 1]++;
else if (left_dist == chmdist[ch_ptr] || chmdist[ch_ptr] == 0x7fffffff) {
chmdist[ch_ptr] = left_dist;
mcnt[ch_ptr]++;
} else if (right_dist == chmdist[ch_ptr + 1])
mcnt[ch_ptr + 1]++;
else if (right_dist < chmdist[ch_ptr + 1]) {
chmdist[ch_ptr + 1] = right_dist;
nh += mcnt[ch_ptr + 1];
mcnt[ch_ptr + 1] = 1;
} else
nh++;
}
cout << nh << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void init() {}
int tonum_int(const string& str) {
int num;
stringstream ss(str);
ss >> num;
return num;
}
int mice[100001];
int cheese[100001];
list<int> g[100001];
bool visit[200001];
int mini[100001];
bool haveeat[100001];
int com1;
int com2;
vector<int> ee[200001];
bool fa[200001];
void addedge(int x, int y) {
g[y].push_back(x);
mini[y] = min(mini[y], abs(cheese[y] - mice[x]));
}
void ae(int a, int b) {
ee[a].push_back(b);
ee[b].push_back(a);
}
void dfs(int node) {
visit[node] = true;
if (node < 100000) {
com1++;
} else {
com2++;
}
for (int i = 0; i < ee[node].size(); ++i) {
int to = ee[node][i];
if (!visit[to]) {
dfs(to);
}
}
}
int main() {
init();
int n, m, y0, y1;
cin >> 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]);
mini[i] = 999999999;
}
if (m == 0) {
cout << n << endl;
return 0;
}
int yind = 0;
for (int i = 0; i < n; ++i) {
while (yind < m && cheese[yind] <= mice[i]) {
yind++;
}
if (yind == m) {
addedge(i, yind - 1);
} else if (yind == 0) {
addedge(i, 0);
} else {
int adif = abs(cheese[yind] - mice[i]);
int bdif = abs(cheese[yind - 1] - mice[i]);
if (adif < bdif) {
addedge(i, yind);
} else if (bdif < adif) {
addedge(i, yind - 1);
} else {
addedge(i, yind);
addedge(i, yind - 1);
}
}
}
int eat = 0;
for (int i = 0; i < 100000; ++i) {
int ct = 0;
for (list<int>::iterator itr = g[i].begin(); itr != g[i].end(); ++itr) {
int m = (*itr);
if (!haveeat[m] && abs(mice[m] - cheese[i]) == mini[i]) {
ct++;
}
}
if (ct == 2) {
for (list<int>::iterator itr = g[i].begin(); itr != g[i].end();) {
int m = (*itr);
if (!haveeat[m] && abs(mice[m] - cheese[i]) == mini[i]) {
haveeat[m] = true;
g[i].erase(itr++);
} else {
itr++;
}
}
eat += 2;
fa[i] = true;
}
}
for (int i = 0; i < 100000; ++i) {
if (fa[i]) continue;
for (list<int>::iterator itr = g[i].begin(); itr != g[i].end(); ++itr) {
int m = (*itr);
if (!haveeat[m]) {
ae(i, m + 100000);
}
}
}
for (int i = 0; i < 200000; ++i) {
if (!visit[i]) {
com1 = com2 = 0;
dfs(i);
eat += min(com1, com2);
}
}
cout << n - eat << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, M, x, y, m[200000], c[200000], mc[200000][4], time1[200000],
tin[200000], ans;
bool used[200000];
int main() {
cin >> N >> M >> x >> y;
for (int i = 1; i <= N; i++) cin >> m[i];
for (int i = 1; i <= M; i++) cin >> c[i];
long long idx = 1;
c[0] = -2000000000;
m[0] = -2000000000;
m[N + 1] = 2000000000;
c[M + 1] = 2000000000;
c[0] *= 1000000000;
c[M + 1] *= 1000000000;
m[0] *= 1000000000;
m[N + 1] *= 100000000;
for (int i = 1; i <= N; i++)
for (int j = idx; j <= M + 1; j++) {
if (abs(m[i] - c[j]) >= abs(m[i] - c[j - 1])) {
idx = j - 1;
if (abs(m[i] - c[j]) == abs(m[i] - c[j - 1])) {
mc[i][1] = j - 1;
mc[i][2] = j;
} else if (m[i] >= c[j - 1])
mc[i][1] = j - 1;
else
mc[i][2] = j - 1;
break;
}
}
long long ans = 0;
for (int i = 1; i <= M; i++) tin[i] = -1;
ans = 0;
for (int i = 1; i <= N; i++) {
if (tin[mc[i][1]] == -1 || tin[mc[i][1]] == abs(c[mc[i][1]] - m[i]))
tin[mc[i][1]] = abs(c[mc[i][1]] - m[i]);
else if (tin[mc[i][2]] == -1 || tin[mc[i][2]] == abs(c[mc[i][2]] - m[i]))
tin[mc[i][2]] = abs(c[mc[i][2]] - m[i]);
else if (tin[mc[i][1]] > abs(c[mc[i][1]] - m[i])) {
tin[mc[i][1]] = abs(c[mc[i][1]] - m[i]);
ans++;
} else if (tin[mc[i][2]] > abs(c[mc[i][2]] - m[i])) {
tin[mc[i][2]] = abs(c[mc[i][2]] - m[i]);
ans++;
} else
ans++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, _, a[100004], b[100004];
int used[100004], ans;
int main() {
scanf("%d%d%d%d", &n, &m, &_, &_);
if (m == 0) {
printf("%d", n);
return 0;
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
int pos = 1;
memset(used, -1, sizeof(used));
for (int i = 1; i <= n; i++) {
while (pos <= m && b[pos] <= a[i]) pos++;
int L = pos - 1, R = pos;
if (L > 0 && (R > m || abs(b[L] - a[i]) < abs(b[R] - a[i]))) {
if (used[L] < 0)
used[L] = abs(b[L] - a[i]);
else if (used[L] != abs(b[L] - a[i]))
used[L] = min(abs(b[L] - a[i]), used[L]), ans++;
} else if (R <= m && (L == 0 || abs(b[L] - a[i]) > abs(b[R] - a[i]))) {
if (used[R] < 0)
used[R] = abs(b[R] - a[i]);
else if (used[R] != abs(b[R] - a[i]))
used[R] = min(abs(b[R] - a[i]), used[R]), ans++;
} else {
if (used[L] < 0 || used[L] == abs(b[L] - a[i])) {
used[L] = abs(b[L] - a[i]);
} else {
if (used[R] < 0)
used[R] = abs(b[R] - a[i]);
else if (used[R] != abs(b[R] - a[i]))
used[R] = min(abs(b[R] - a[i]), used[R]), ans++;
}
}
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b;
scanf("%d%d%d%d", &n, &m, &a, &b);
if (m == 0) {
printf("%d\n", n);
}
vector<int> mice(n), cheese(m), dist(n), choose(n), c2(n, -1);
for (int i = 0; i < n; ++i) {
scanf("%d", &mice[i]);
}
for (int i = 0; i < m; ++i) {
scanf("%d", &cheese[i]);
}
int p = 0;
for (int i = 0; i < n; ++i) {
while (p + 1 < m && cheese[p + 1] <= mice[i]) {
++p;
}
dist[i] = abs(cheese[p] - mice[i]);
choose[i] = p;
if (p + 1 < m) {
int d = abs(cheese[p + 1] - mice[i]);
if (d < dist[i]) {
choose[i] = ++p;
dist[i] = d;
} else if (d == dist[i]) {
c2[i] = ++p;
}
}
}
int ans = 1;
for (int i = 1; i < n; ++i) {
if (choose[i] == choose[i - 1] && dist[i] == dist[i - 1]) {
ans++;
} else if (choose[i] != choose[i - 1]) {
ans++;
} else if (c2[i] != -1) {
choose[i] = c2[i];
ans++;
} else {
dist[i] = min(dist[i], dist[i - 1]);
}
}
printf("%d\n", n - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int N, M;
bool cleft[MAX], cright[MAX];
int dleft[MAX], dright[MAX];
int ileft[MAX], iright[MAX];
bool eaten[MAX];
int main() {
memset(dleft, 0x3F, sizeof dleft);
memset(dright, 0x7F, sizeof dright);
memset(ileft, -1, sizeof ileft);
memset(iright, -1, sizeof iright);
scanf("%d %d %*d %*d", &N, &M);
vector<int> mice;
for (int i = int(0); i < int(N); i++) {
int cur;
scanf("%d", &cur);
mice.push_back(cur);
}
vector<int> cheeses;
for (int i = int(0); i < int(M); i++) {
int cur;
scanf("%d", &cur);
cheeses.push_back(cur);
}
if (M == 0) {
printf("%d\n", N);
return 0;
}
for (int i = int(0); i < int(N); i++) {
auto it = lower_bound(cheeses.begin(), cheeses.end(), mice[i]);
if (it != cheeses.begin()) {
auto prev_it = prev(it);
if (i == 0 || (mice[i - 1] < *prev_it)) {
cleft[i] = true;
}
dleft[i] = mice[i] - *prev_it;
ileft[i] = prev_it - cheeses.begin();
}
if (it != cheeses.end()) {
if (i == N - 1 || (mice[i + 1] > *it)) {
cright[i] = true;
}
dright[i] = *it - mice[i];
iright[i] = it - cheeses.begin();
}
if (dright[i] > dleft[i]) {
cright[i] = false;
} else if (dleft[i] > dright[i]) {
cleft[i] = false;
}
}
int ans = N;
for (int i = int(0); i < int(N); i++) {
if (cleft[i]) {
if (!eaten[ileft[i]] || ((i == 0) || dright[i - 1] == dleft[i])) {
ans--;
eaten[ileft[i]] = true;
continue;
}
}
if (cright[i]) {
eaten[iright[i]] = true;
ans--;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const long long maxmax = 1000000LL * 100000LL;
long long n, m, tmp, i, j, a[N], b[N], tt[N], go[N][2], l, r, res;
int main() {
cin >> n >> m >> tmp >> tmp;
for (i = 0; i < n; i++) cin >> a[i];
for (j = 1; j <= m; j++) cin >> b[j];
b[0] = -maxmax;
b[m + 1] = maxmax;
m += 2;
for (i = 0; i < n; i++) {
l = 0;
r = m;
while (l < r)
if (b[(l + r) / 2] <= a[i])
l = (l + r) / 2 + 1;
else
r = (l + r) / 2;
l--;
if ((a[i] - b[l]) < (b[r] - a[i])) {
go[i][0] = l;
go[i][1] = maxmax;
};
if ((a[i] - b[l]) > (b[r] - a[i])) {
go[i][1] = r;
go[i][0] = maxmax;
};
if ((a[i] - b[l]) == (b[r] - a[i])) {
go[i][1] = r;
go[i][0] = l;
};
}
for (j = 0; j <= m; j++) tt[j] = maxmax;
for (i = 0; i < n; i++) {
if (go[i][1] == maxmax) {
j = go[i][0];
if (tt[j] == maxmax || tt[j] == (a[i] - b[j])) res++;
tt[j] = min(tt[j], a[i] - b[j]);
continue;
}
if (go[i][0] == maxmax) {
j = go[i][1];
if (tt[j] == maxmax || tt[j] == (b[j] - a[i])) res++;
tt[j] = min(tt[j], b[j] - a[i]);
continue;
}
if (tt[go[i][0]] == maxmax || tt[j] == (a[i] - b[j])) {
j = go[i][0];
if (tt[j] == maxmax || tt[j] == (a[i] - b[j])) res++;
tt[j] = min(tt[j], a[i] - b[j]);
continue;
} else {
j = go[i][1];
if (tt[j] == maxmax || tt[j] == (b[j] - a[i])) res++;
tt[j] = min(tt[j], b[j] - a[i]);
continue;
}
}
cout << n - res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, Y0, Y1, ans;
int a[N], b[N], used[N];
int main() {
scanf("%d%d%d%d", &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);
for (int i = 1; i <= m; i++) used[i] = -1;
for (int i = 1; i <= n; i++) {
int r = lower_bound(b + 1, b + 1 + m, a[i]) - b;
int l = r - 1;
if (l == 0) {
if (!~used[r])
used[r] = b[r] - a[i];
else if (used[r] != b[r] - a[i]) {
ans++;
used[r] = min(used[r], b[r] - a[i]);
}
} else if (r == m + 1) {
if (!~used[l])
used[l] = a[i] - b[l];
else if (used[l] != a[i] - b[l]) {
ans++;
used[l] = min(used[l], a[i] - b[l]);
}
} else if (a[i] - b[l] < b[r] - a[i]) {
if (!~used[l])
used[l] = a[i] - b[l];
else if (used[l] != a[i] - b[l]) {
ans++;
used[l] = min(used[l], a[i] - b[l]);
}
} else if (a[i] - b[l] > b[r] - a[i]) {
if (!~used[r])
used[r] = b[r] - a[i];
else if (used[r] != b[r] - a[i]) {
ans++;
used[r] = min(used[r], b[r] - a[i]);
}
} else if (!~used[l] || used[l] == a[i] - b[l])
used[l] = a[i] - b[l];
else
used[r] = b[r] - a[i];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int aa[100005], bb[100005], cc[100005];
int slove(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;
scanf("%d%d%d%d", &n, &m, &x1, &y1);
ans = n;
for (int i = 1; i <= n; i++) scanf("%d", &aa[i]);
for (int j = 1; j <= m; j++) scanf("%d", &bb[j]);
if (k <= m) {
for (int i = 1; i <= n; i++) {
k = slove(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;
}
}
}
}
}
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int imax = INT_MAX;
const long long lmax = LONG_LONG_MAX;
int a[100050], b[100050];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m, y0, y1;
cin >> n >> m >> y0 >> y1;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
int d = 0, p = 0, l = -1;
for (int i = 0; i < n; i++) {
while (d < m && abs(a[i] - b[d + 1]) < abs(a[i] - b[d])) d++;
if (l < d || abs(a[i - 1] - b[d]) == abs(a[i] - b[d])) {
p++;
l = d;
} else if (d < m && abs(a[i] - b[d + 1]) == abs(a[i] - b[d])) {
p++;
l = ++d;
} else
l = d;
}
cout << n - p << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 1000001;
int n, m, k, Y, x[max_n], y[max_n], a[max_n], b[max_n], d[2][max_n], ans;
int main() {
cin >> n >> m >> Y >> Y;
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < m; i++) cin >> y[i];
int j = 0;
for (int i = 0; i < n; i++) {
a[i] = b[i] = -1;
while (j < m && y[j] < x[i]) j++;
for (int jj = j; jj >= j - 2; jj--)
if (jj >= 0 && jj < m && y[jj] < x[i] && a[i] == -1) a[i] = jj;
for (int jj = j; jj <= j + 2; jj++)
if (jj >= 0 && jj < m && y[jj] >= x[i] && b[i] == -1) b[i] = jj;
if (a[i] != -1 && b[i] != -1) {
if (y[b[i]] - x[i] > x[i] - y[a[i]])
b[i] = -1;
else if (y[b[i]] - x[i] < x[i] - y[a[i]])
a[i] = -1;
}
if (a[i] != -1) {
if (i == 0)
d[0][i] = 1;
else {
if (a[i] != a[i - 1])
d[0][i] = d[0][i - 1] + 1;
else
d[0][i] = d[0][i - 1];
if (b[i - 1] != -1 &&
(b[i - 1] != a[i] || x[i] - y[a[i]] == y[b[i - 1]] - x[i - 1]))
d[0][i] = max(d[0][i], d[1][i - 1] + 1);
if (b[i - 1] != -1) d[0][i] = max(d[0][i], d[1][i - 1]);
}
}
if (b[i] != -1) {
if (i == 0)
d[1][i] = 1;
else {
d[1][i] = max(d[1][i], d[0][i - 1] + 1);
if (b[i - 1] != -1 && b[i - 1] != b[i])
d[1][i] = max(d[1][i], d[1][i - 1] + 1);
else
d[1][i] = max(d[1][i], d[1][i - 1]);
}
}
if (d[0][i] > ans) ans = d[0][i];
if (d[1][i] > ans) ans = d[1][i];
}
cout << n - ans;
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
bool debug = false;
int mi[100005], c[100005];
int main() {
scanf("%d%d%d%d", &n, &m, &k, &k);
for (int i = 0; i < n; i++) scanf("%d", mi + i);
for (int i = 0; i < m; i++) scanf("%d", c + i);
int l = 0, la = -1;
int ss = 0;
for (int i = 0; i < n; i++) {
while (l < m - 1 && abs(mi[i] - c[l + 1]) < abs(mi[i] - c[l])) l++;
if (la < l || abs(mi[i - 1] - c[l]) == abs(mi[i] - c[l])) {
ss++;
la = l;
continue;
}
if (l < m - 1 && abs(mi[i] - c[l + 1]) == abs(mi[i] - c[l])) {
ss++;
la = ++l;
continue;
}
la = l;
}
printf("%d\n", n - ss);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int n, m, lol;
int a[100005], b[100005], adj[100005], dist[100005];
int main() {
cin >> n >> m >> lol >> lol;
if (m == 0) {
cout << n << endl;
return 0;
}
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
fill(dist, dist + m, 1000000069);
int rg = 0;
for (int lf = 0; lf < n; lf++) {
while (rg < m - 1 && a[lf] >= b[rg + 1]) rg++;
if (rg == m - 1)
adj[lf] = rg;
else if (abs(a[lf] - b[rg]) < abs(a[lf] - b[rg + 1]))
adj[lf] = rg;
else if (abs(a[lf] - b[rg]) == abs(a[lf] - b[rg + 1])) {
if (dist[rg] == 1000000069 || dist[rg] == abs(a[lf] - b[rg]))
adj[lf] = rg;
else
adj[lf] = rg + 1;
} else
adj[lf] = rg + 1;
dist[adj[lf]] = min(dist[adj[lf]], abs(a[lf] - b[adj[lf]]));
}
int ans = 0;
for (int i = 0; i < n; i++)
if (dist[adj[i]] != abs(a[i] - b[adj[i]])) ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0;
bool f = 0;
char ch = ' ';
while (!isdigit(ch)) {
f |= (ch == '-');
ch = getchar();
}
while (isdigit(ch)) {
s = (s << 3) + (s << 1) + (ch ^ 48);
ch = getchar();
}
return (f) ? (-s) : (s);
}
inline void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10) {
putchar(x + '0');
return;
}
write(x / 10);
putchar((x % 10) + '0');
}
const int N = 100005;
int n, m, Y, Y0;
int a[N], b[N], wn[N];
int dp[N][2];
inline int js(int x1, int o1, int x2, int o2) {
if (!dp[x1][o1]) return 0;
int b1 = b[wn[x1] - (o1 ^ 1)], b2 = b[wn[x2] - (o2 ^ 1)];
if ((b1 != b2) || (abs(a[x1] - b1) == abs(a[x2] - b2))) return 1;
return 0;
}
int main() {
int i, oo, now = 1;
n = read();
m = read();
Y = read();
Y0 = read();
for (i = 1; i <= n; i++) a[i] = read(), wn[i] = 0;
for (i = 1; i <= m; i++) b[i] = read();
for (i = 1; i <= n; i++) {
while (now < m && b[now] <= a[i]) now++;
wn[i] = now;
}
memset(dp, 0, sizeof dp);
if (wn[1] > 1) {
oo = wn[1];
if (b[oo] - a[1] == a[1] - b[oo - 1])
dp[1][0] = dp[1][1] = 1;
else if (b[oo] - a[1] > a[1] - b[oo - 1])
dp[1][0] = 1;
else
dp[1][1] = 1;
} else
dp[1][1] = 1;
for (i = 2; i <= n; i++) {
oo = wn[i];
if (oo > 1) {
if (b[oo] - a[i] == a[i] - b[oo - 1]) {
dp[i][0] = max(js(i - 1, 0, i, 0) + dp[i - 1][0],
js(i - 1, 1, i, 0) + dp[i - 1][1]);
dp[i][1] = max(js(i - 1, 0, i, 1) + dp[i - 1][0],
js(i - 1, 1, i, 1) + dp[i - 1][1]);
} else if (b[oo] - a[i] > a[i] - b[oo - 1]) {
dp[i][0] = max(js(i - 1, 0, i, 0) + dp[i - 1][0],
js(i - 1, 1, i, 0) + dp[i - 1][1]);
} else {
dp[i][1] = max(js(i - 1, 0, i, 1) + dp[i - 1][0],
js(i - 1, 1, i, 1) + dp[i - 1][1]);
}
} else {
dp[i][1] = max(js(i - 1, 0, i, 1) + dp[i - 1][0],
js(i - 1, 1, i, 1) + dp[i - 1][1]);
}
}
write(n - max(dp[n][0], dp[n][1])), putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nsz = 2e5;
const int inf = 0x3f3f3f3f;
int n, m, tmp, a[nsz + 5], b[nsz + 5], mn[nsz + 5], ans;
int dp[nsz + 5][2];
vector<int> to[nsz + 5];
void inline upd(int &a, int b) {
if (a > b) a = b;
}
bool calc(int d, int cd) { return d == inf ? 0 : d != cd; }
int main() {
scanf("%d%d%d%d", &n, &m, &tmp, &tmp);
for (int i = 1; i <= n + m; ++i) {
int p;
scanf("%d", &p);
(i <= n ? a[i] : b[i - n]) = p;
}
for (int i = 1; i <= n; ++i) {
int p = a[i], id = lower_bound(b + 1, b + m + 1, p) - b, d1 = inf, d2 = inf;
if (id == m + 1) --id;
d1 = abs(a[i] - b[id]);
if (id != 1) d2 = abs(a[i] - b[id - 1]);
if (d1 >= d2) to[i].push_back(id - 1);
if (d1 <= d2) to[i].push_back(id);
}
memset(mn, inf, sizeof(mn));
for (int i = 1; i <= n; ++i) {
if (to[i].size() == 2) continue;
int id = to[i][0], d = abs(a[i] - b[id]);
if (d < mn[id]) {
if (mn[id] != inf) ans += 1;
mn[id] = d;
} else if (d > mn[id])
ans += 1;
}
memset(dp, inf, sizeof(dp));
int o = 0, x = 1;
dp[o][0] = dp[o][1] = 0;
int p = -1;
for (int i = 1; i <= n; ++i)
if (to[i].size() == 2) {
int id = to[i][0], d = abs(a[i] - b[id]), d1 = inf;
if (p != -1 && to[p][1] == id) {
d1 = abs(a[p] - b[id]);
upd(dp[x][0], dp[o][0] + calc(mn[id], d));
upd(dp[x][0], dp[o][1] + calc(min(mn[id], d1), d));
} else
upd(dp[x][0], min(dp[o][0], dp[o][1]) + calc(mn[id], d));
id = to[i][1], d = abs(a[i] - b[id]);
upd(dp[x][1], min(dp[o][0], dp[o][1]) + calc(mn[id], d));
p = i;
swap(o, x);
memset(dp[x], inf, sizeof(dp[x]));
}
ans += min(dp[o][0], dp[o][1]);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, ans;
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;
mn[t1] = min(mn[t1], dist(i, t1));
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;
mn[t2] = min(mn[t2], dist(i, t2));
v[t2].push_back(i);
}
}
for (int i = 1; i <= n; i++) ans += flag[i];
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, X, Y;
int pm[(1 << 17)], pc[(1 << 17)];
int mmd[(1 << 17)], ddt[(1 << 17)];
int mrk[(1 << 17)];
int Ans;
int main() {
scanf("%d%d%d%d", &n, &m, &X, &Y);
for (int i = 0; i < n; i++) {
scanf("%d", &pm[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d", &pc[i]);
mmd[i] = (2147483647);
}
int curx = 0, cury = 0;
while (curx < n && cury < m) {
int dist = abs(pm[curx] - pc[cury]);
while (cury < m - 1 && dist > abs(pm[curx] - pc[cury + 1])) {
cury++;
dist = abs(pm[curx] - pc[cury]);
}
if (cury < m - 1 && dist == abs(pm[curx] - pc[cury + 1])) {
if (dist == mmd[cury] || mmd[cury] == (2147483647)) {
mrk[curx] = cury;
mmd[cury] = min(mmd[cury], dist);
} else {
mrk[curx] = cury + 1;
mmd[cury + 1] = min(mmd[cury + 1], dist);
}
} else {
mrk[curx] = cury;
mmd[cury] = min(mmd[cury], dist);
}
ddt[curx++] = dist;
}
for (int i = 0; i < n; i++) {
if (ddt[i] == mmd[mrk[i]]) {
Ans++;
}
}
printf("%d\n", n - Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000 * 100 + 10;
int m[Maxn], c[Maxn], eatd[Maxn];
int ans;
int INF = 1000 * 1000 * 10 + 10;
int main() {
int N, M, y;
cin >> N >> M >> y >> y;
for (int i = 0; i < N; i++) cin >> m[i];
c[0] = -INF;
c[M + 1] = INF;
for (int i = 1; i <= M; i++) cin >> c[i];
for (int i = 0; i < Maxn; i++) eatd[i] = INF;
for (int i = 0; i < N; i++) {
int ind = lower_bound(c, c + M + 2, m[i]) - c;
if (m[i] - c[ind - 1] < c[ind] - m[i]) {
if (eatd[ind - 1] < m[i] - c[ind - 1])
ans++;
else {
if (eatd[ind - 1] > m[i] - c[ind - 1] && eatd[ind - 1] != INF) ans++;
eatd[ind - 1] = m[i] - c[ind - 1];
}
} else if (m[i] - c[ind - 1] > c[ind] - m[i]) {
if (eatd[ind] != INF) ans++;
eatd[ind] = c[ind] - m[i];
} else {
if (eatd[ind - 1] == INF || eatd[ind - 1] == m[i] - c[ind - 1])
eatd[ind - 1] = m[i] - c[ind - 1];
else
eatd[ind] = c[ind] - m[i];
}
}
if (M == 0)
cout << N;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65777216")
using namespace std;
const int inf = 1000000000;
int n, m, y, Y;
int x[111111], X[111111];
int d[111111][2];
vector<int> v[111111];
int main() {
cin >> n >> m >> y >> Y;
for (int i(0); i < (n); i++) scanf("%d", x + i);
for (int i(0); i < (m); i++) scanf("%d", X + i);
for (int i(0); i < (n); i++) d[i][0] = d[i][1] = inf;
for (int i(0); i < (n); i++) {
int pos = lower_bound(X, X + m, x[i]) - X;
if (pos >= m)
pos--;
else {
if (pos >= 1) {
if (X[pos] - x[i] > x[i] - X[pos - 1]) pos--;
}
}
if (pos >= 1 && X[pos] - x[i] == x[i] - X[pos - 1]) {
v[i].push_back(pos - 1);
v[i].push_back(pos);
pos--;
if (i == 0)
d[0][0] = d[0][1] = 0;
else {
d[i][1] = min(d[i - 1][0], d[i - 1][1]);
if (v[i - 1].size() == 2) {
if (v[i - 1].back() == pos)
d[i][0] =
min(d[i - 1][0],
d[i - 1][1] + (x[i - 1] + x[i] != X[pos] * 2 ? 1 : 0));
else
d[i][0] = min(d[i - 1][0], d[i - 1][1]);
} else {
if (v[i - 1][0] == pos)
d[i][0] = d[i - 1][0] + (x[i - 1] + x[i] != X[pos] * 2 ? 1 : 0);
else
d[i][0] = d[i - 1][0];
}
}
} else {
v[i].push_back(pos);
if (i == 0) {
d[0][0] = 0;
} else {
if (v[i - 1].size() == 2) {
if (v[i - 1].back() == pos)
d[i][0] =
min(d[i - 1][0],
d[i - 1][1] + (x[i - 1] + x[i] != X[pos] * 2 ? 1 : 0));
else
d[i][0] = min(d[i - 1][0], d[i - 1][1]);
} else {
if (v[i - 1][0] == pos)
d[i][0] = d[i - 1][0] + (x[i - 1] + x[i] != X[pos] * 2 ? 1 : 0);
else
d[i][0] = d[i - 1][0];
}
}
}
}
cout << min(d[n - 1][0], d[n - 1][1]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int diri[4] = {-1, 0, 1, 0};
const int dirj[4] = {0, 1, 0, -1};
int A, B;
int va[110000], vb[110000];
bool esquerra(int a, int b) {
if (b < 0) return false;
if (a == 0) return true;
return va[a - 1] < vb[b];
}
bool dreta(int a, int b) {
if (b + 1 >= B) return false;
if (a + 1 == A) return true;
return va[a + 1] > vb[b + 1];
}
int main() {
int spam;
cin >> A >> B >> spam >> spam;
for (int i = 0; i < int(A); ++i) cin >> va[i];
for (int i = 0; i < int(B); ++i) cin >> vb[i];
vector<int> dist(B, -1);
int res = A;
int b = -1;
for (int a = 0; a < A; ++a) {
while (b + 1 < B and vb[b + 1] <= va[a]) ++b;
int d = INF;
if (0 <= b and b < B) d = min(d, abs(va[a] - vb[b]));
if (b + 1 < B) d = min(d, abs(va[a] - vb[b + 1]));
if (esquerra(a, b) and d == abs(va[a] - vb[b])) {
if (dist[b] == -1 or dist[b] == d) {
dist[b] = d;
--res;
continue;
}
}
if (dreta(a, b) and d == abs(va[a] - vb[b + 1])) {
dist[b + 1] = d;
--res;
continue;
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
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 && 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;
inline int read() {
int s = 0;
bool f = 0;
char ch = ' ';
while (!isdigit(ch)) {
f |= (ch == '-');
ch = getchar();
}
while (isdigit(ch)) {
s = (s << 3) + (s << 1) + (ch ^ 48);
ch = getchar();
}
return (f) ? (-s) : (s);
}
inline void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10) {
putchar(x + '0');
return;
}
write(x / 10);
putchar((x % 10) + '0');
}
const int N = 100005;
int n, m, Y, Y0;
int a[N], b[N], wn[N];
int dp[N][2];
inline int js(int x1, int o1, int x2, int o2) {
if (!dp[x1][o1]) return 0;
int b1 = b[wn[x1] - (o1 ^ 1)], b2 = b[wn[x2] - (o2 ^ 1)];
if ((b1 != b2) || (abs(a[x1] - b1) == abs(a[x2] - b2))) return 1;
return 0;
}
int main() {
int i, oo, now = 1;
n = read();
m = read();
Y = read();
Y0 = read();
for (i = 1; i <= n; i++) a[i] = read(), wn[i] = 0;
for (i = 1; i <= m; i++) b[i] = read();
for (i = 1; i <= n; i++) {
while (now < m && b[now] <= a[i]) now++;
wn[i] = now;
}
memset(dp, 0, sizeof dp);
if (wn[1] > 1) {
oo = wn[1];
if (b[oo] - a[1] == a[1] - b[oo - 1])
dp[1][0] = dp[1][1] = 1;
else if (b[oo] - a[1] > a[1] - b[oo - 1])
dp[1][0] = 1;
else
dp[1][1] = 1;
} else
dp[1][1] = 1;
for (i = 2; i <= n; i++) {
oo = wn[i];
if (oo > 1) {
if (b[oo] - a[i] == a[i] - b[oo - 1]) {
dp[i][0] = max(js(i - 1, 0, i, 0) + dp[i - 1][0],
js(i - 1, 1, i, 0) + dp[i - 1][1]);
dp[i][1] = max(js(i - 1, 0, i, 1) + dp[i - 1][0],
js(i - 1, 1, i, 1) + dp[i - 1][1]);
} else if (b[oo] - a[i] > a[i] - b[oo - 1]) {
dp[i][0] = max(js(i - 1, 0, i, 0) + dp[i - 1][0],
js(i - 1, 1, i, 0) + dp[i - 1][1]);
} else {
dp[i][1] = max(js(i - 1, 0, i, 1) + dp[i - 1][0],
js(i - 1, 1, i, 1) + dp[i - 1][1]);
}
} else {
dp[i][1] = max(js(i - 1, 0, i, 1) + dp[i - 1][0],
js(i - 1, 1, i, 1) + dp[i - 1][1]);
}
}
write(n - max(dp[n][0], dp[n][1])), putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, C, mice[100010], cheese[100010];
pair<int, int> p[200010];
int dist[200010];
bool edge[200010];
int func(void) {
int i, j, k, tmp;
tmp = -(1 << 29);
for ((i) = 0; (i) < (int)(N); (i)++)
if (p[i].second == 1)
tmp = p[i].first;
else
dist[i] = p[i].first - tmp;
tmp = (1 << 29);
for (i = N - 1; i >= 0; i--)
if (p[i].second == 1)
tmp = p[i].first;
else
dist[i] = min(dist[i], tmp - p[i].first);
for ((i) = 0; (i) < (int)(N - 1); (i)++) {
int t1 = p[i].second, t2 = p[i + 1].second, d = p[i + 1].first - p[i].first;
if (t1 == 0 && t2 == 1 && dist[i] == d) edge[i] = true;
if (t1 == 1 && t2 == 0 && dist[i + 1] == d) edge[i] = true;
}
int ans = 0;
i = 0;
while (i < N) {
for (j = i; j < N; j++)
if (!edge[j]) break;
ans += (j - i + 1) / 2;
bool found = false;
if (p[i].second == 0 && p[j].second == 0)
for (k = i; k < j; k += 2)
if (dist[k] == dist[k + 2]) found = true;
if (found) ans++;
i = j + 1;
}
return ans;
}
int main(void) {
int Y1, Y2, i;
scanf("%d%d%d%d", &M, &C, &Y1, &Y2);
for ((i) = 0; (i) < (int)(M); (i)++) scanf("%d", &mice[i]);
for ((i) = 0; (i) < (int)(C); (i)++) scanf("%d", &cheese[i]);
N = M + C;
for ((i) = 0; (i) < (int)(M); (i)++) p[i] = make_pair(mice[i], 0);
for ((i) = 0; (i) < (int)(C); (i)++) p[M + i] = make_pair(cheese[i], 1);
sort(p, p + N);
int ans = func();
cout << M - ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, Y0, Y1;
cin >> N >> M >> Y0 >> Y1;
vector<int> mice(N);
vector<int> cheeses(M);
for (int i = 0; i < N; ++i) cin >> mice[i];
for (int i = 0; i < M; ++i) cin >> cheeses[i];
int ans = 0;
vector<int> v(M, INT_MAX);
for (int i = 0; i < N; ++i) {
int p2 =
lower_bound(cheeses.begin(), cheeses.end(), mice[i]) - cheeses.begin();
int p1 = p2 - 1;
int d1 = INT_MAX, d2 = INT_MAX;
if (p2 < M) d2 = abs(mice[i] - cheeses[p2]);
if (p1 >= 0) d1 = abs(mice[i] - cheeses[p1]);
if (p2 == 0) {
if (v[p2] == INT_MAX) ++ans;
if (d2 < v[p2]) v[p2] = d2;
} else if (p2 == M) {
if (v[p1] == INT_MAX) ++ans;
if (d1 < v[p1])
v[p1] = d1;
else if (d1 == v[p1])
++ans;
} else {
if (d1 < d2) {
if (v[p1] == INT_MAX) ++ans;
if (d1 < v[p1])
v[p1] = d1;
else if (v[p1] == d1)
++ans;
} else if (d1 > d2) {
if (v[p2] == INT_MAX) ++ans;
if (d2 < v[p2]) v[p2] = d2;
} else {
if (v[p1] == d1 || v[p1] == INT_MAX) {
++ans;
v[p1] = d1;
} else {
v[p2] = d2;
++ans;
}
}
}
}
cout << N - ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100100;
int poscheese[MX], posmice[MX];
int assigni[MX], assignd[MX], assigni2[MX];
int main() {
memset(assigni, -1, sizeof(assigni));
memset(assigni2, -1, sizeof(assigni2));
memset(assignd, 63, sizeof(assignd));
int n, m, y0, y1;
cin >> m >> n >> y0 >> y1;
for (int i = 0; i < m; ++i) {
cin >> posmice[i];
}
for (int i = 0; i < n; ++i) {
cin >> poscheese[i];
}
for (int i = 0; i < m; ++i) {
int cpos = posmice[i];
int mind = 999999999;
int mini = -1;
bool tie = false;
int posr = upper_bound(poscheese, poscheese + n, cpos) - poscheese;
int posl = posr - 1;
if (posl >= 0) {
int curd = abs(poscheese[posl] - cpos);
if (curd < mind) {
mind = curd;
mini = posl;
tie = false;
} else if (curd == mind) {
tie = true;
}
}
if (posr < n) {
int curd = abs(poscheese[posr] - cpos);
if (curd < mind) {
mind = curd;
mini = posr;
tie = false;
} else if (curd == mind) {
tie = true;
}
}
if (mini != -1 && !tie) {
if (mind < assignd[mini]) {
assignd[mini] = mind;
assigni[mini] = i;
} else if (mind == assignd[mini]) {
assigni2[mini] = i;
}
} else if (tie) {
if (assigni[mini] == -1) {
assignd[mini] = mind;
assigni[mini] = i;
} else if (mind == assignd[mini]) {
assigni2[mini] = i;
} else {
++mini;
if (assigni[mini] == -1) {
assignd[mini] = mind;
assigni[mini] = i;
}
}
}
}
int c = 0;
for (int i = 0; i < n; ++i) {
if (~assigni[i]) {
++c;
}
if (~assigni2[i]) {
++c;
}
}
cout << m - c << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[222222], b[222222], d[222222], c[222222], f[222222][2];
pair<int, int> x[222222];
int n, m, k, sum, q, p, i, j, res;
int F(int i, int j) {
if (abs(a[i] - b[j]) < d[j]) return c[j];
if (abs(a[i] - b[j]) > d[j]) return 1;
return 0;
}
int main() {
cin >> n >> m >> k >> k;
if (!m) {
cout << n << endl;
return 0;
}
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < m; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + m);
k = 0;
for (i = 0; i < m; i++) d[i] = (int)1e+9;
for (i = 0, j = 0; i < n; i++) {
while (j + 1 < m && abs(a[i] - b[j]) > abs(a[i] - b[j + 1])) j++;
if (j + 1 < m && abs(a[i] - b[j]) == abs(a[i] - b[j + 1]))
x[++k] = make_pair(i, j);
else {
c[j] *= (d[j] <= abs(a[i] - b[j]));
d[j] = min(d[j], abs(a[i] - b[j]));
c[j] += (d[j] == abs(a[i] - b[j]));
}
}
if (k) {
x[0].first = x[0].second = (int)1e+9;
for (i = 1; i <= k; i++) {
if (x[i - 1].second + 1 != x[i].second) {
if (i > 1) f[i - 1][1] += F(x[i - 1].first, x[i - 1].second + 1);
f[i][0] = min(f[i - 1][0], f[i - 1][1]) + F(x[i].first, x[i].second);
f[i][1] = min(f[i - 1][0], f[i - 1][1]);
} else {
q = min(abs(a[x[i - 1].first] - b[x[i].second]),
abs(a[x[i].first] - b[x[i].second]));
p = abs(a[x[i - 1].first] - b[x[i].second]) !=
abs(a[x[i].first] - b[x[i].second]);
if (q < d[x[i].second])
sum = c[x[i].second] + p;
else if (q == d[x[i].second])
sum = p;
else
sum = 2;
f[i][0] =
min(f[i - 1][0] + F(x[i].first, x[i].second), f[i - 1][1] + sum);
f[i][1] =
min(f[i - 1][0], f[i - 1][1] + F(x[i - 1].first, x[i].second));
}
}
f[k][1] += F(x[k].first, x[k].second + 1);
}
for (i = 0; i < m; i++) res += c[i];
res = n - k - res + min(f[k][0], f[k][1]);
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, x[101010], y[101010], z[101010];
int main() {
int yy1, yy2;
cin >> n >> m >> yy1 >> yy2;
for (int i = 0; i < n; i++) {
cin >> x[i];
}
y[0] = -1e9;
for (int i = 1; i <= m; i++) {
cin >> y[i];
}
y[m + 1] = 1e9;
m += 2;
ans = 0;
for (int i = 0; i < max(n, m) + 100; i++) {
z[i] = 1e9;
}
for (int i = 0; i < n; i++) {
int j = lower_bound(y, y + m, x[i]) - y,
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] == 1e9 || z[j - 1] == d))) {
j--;
}
if (z[j] == 1e9 || z[j] == d) {
ans++;
}
z[j] = min(z[j], d);
}
cout << n - ans << 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 y0, y1;
scanf("%d %d %d %d", &n, &m, &y0, &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;
const int MAXN = 111111;
const int SQ = 200;
int n, m;
vector<int> go[MAXN];
vector<pair<int, int> > qq[MAXN], gg[MAXN];
int ans[MAXN], a[MAXN];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int l, r;
scanf("%d%d", &l, &r);
--l;
--r;
go[r].push_back(l);
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
qq[y].push_back(make_pair(x, i));
}
for (int i = 0; i < n; ++i) a[i] = i;
for (int i = 0; i < n; ++i) {
if (!go[i].empty()) {
int l = go[i][0];
int now = 0;
int nb = 0;
for (nb = 0; now + SQ <= l + 1; ++nb, now += SQ) {
while (!gg[nb].empty() && gg[nb].back().first >= l) gg[nb].pop_back();
if (gg[nb].empty() || gg[nb].back().second < l) {
gg[nb].push_back(make_pair(l, i));
} else {
gg[nb].back().second = i;
}
}
if (l >= now) {
for (int j = now; j < now + SQ && j < i; ++j) {
int x = lower_bound(gg[nb].begin(), gg[nb].end(),
make_pair(a[j] + 1, -1)) -
gg[nb].begin();
--x;
if (x != -1) a[j] = max(a[j], gg[nb][x].second);
}
gg[nb].clear();
for (int j = now; j <= l; ++j)
if (a[j] >= l) a[j] = max(a[j], i);
}
}
for (auto e : qq[i]) {
int l = e.first;
int b = a[l];
int nb = l / SQ;
int x = lower_bound(gg[nb].begin(), gg[nb].end(), make_pair(b + 1, -1)) -
gg[nb].begin();
--x;
if (x != -1) b = max(b, gg[nb][x].second);
ans[e.second] = b;
}
}
for (int i = 0; i < q; ++i) {
printf("%d\n", ans[i] + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(0) * 2;
const double EPS = 1e-8;
const long long MOD = 1e9 + 7;
const int MAXN = 2e5 + 5;
const int oo = 1e9;
const double foo = 1e30;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcounll(s);
}
template <class T>
T sqr(T x) {
return x * x;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
const int nip = 330;
int n, l[MAXN], r[MAXN], isR[MAXN], isL[MAXN], gg[MAXN];
int d[nip + 5][nip * nip + 5], g[nip + 5][nip * nip + 5];
int main() {
cin >> n;
int num;
cin >> num;
for (int i = 0; i < n; i++) gg[i] = -1;
for (int i = 0; i < num; i++) {
scanf("%d%d", &l[i], &r[i]);
l[i]--;
r[i]--;
isR[r[i]] = 1;
isL[l[i]] = 1;
gg[r[i]] = l[i];
}
for (int i = nip - 1; i < n; i += nip) {
for (int j = i; j >= 0; j--) {
if (!isL[j]) d[i / nip][j] = -1;
if (isR[j]) d[i / nip][gg[j]] = max(d[i / nip][gg[j]], j);
}
}
stack<int> st;
for (int i = nip - 1; i < n; i += nip) {
while (!st.empty()) st.pop();
for (int j = i; j >= 0; j--) {
g[i / nip][j] = j;
while (!st.empty() && st.top() <= d[i / nip][j]) {
g[i / nip][j] = max(g[i / nip][j], g[i / nip][st.top()]);
st.pop();
}
st.push(j);
}
}
int q;
cin >> q;
for (int tc = 0; tc < q; tc++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
if (y - x + 1 <= nip) {
int ans = x;
for (int i = x + 1; i <= y; i++) {
if (gg[i] >= x && gg[i] <= ans) {
ans = i;
}
}
printf("%d\n", ans + 1);
} else {
int hi = y / nip;
hi--;
int ans = g[hi][x];
for (int i = (hi + 1) * nip; i <= y; i++) {
if (gg[i] >= x && gg[i] <= ans) {
ans = i;
}
}
printf("%d\n", ans + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma GCC optimize(3)
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const int INF = 1000000000;
const int MAXN = 100005;
const int B = 500;
int N, M, Q;
int low[MAXN];
std::vector<int> V[MAXN], ID[MAXN], up[MAXN];
int ans[MAXN];
int f[MAXN];
void solve() {
static int mx[MAXN][25];
for (int l = 1, r; l <= N; l = r + 1) {
r = min(l + B - 1, N);
for (int i = l; i <= r; i++) {
f[i] = i;
for (int j = l; j <= i; j++)
if (f[j] >= low[i] && low[i] >= j) f[j] = i;
for (int j = 0; j < V[i].size(); j++) {
if (V[i][j] >= l) {
ans[ID[i][j]] = f[V[i][j]];
continue;
}
ans[ID[i][j]] = f[V[i][j]];
for (int k = l; k <= i; k++)
if (low[k] >= V[i][j] && low[k] <= ans[ID[i][j]]) ans[ID[i][j]] = k;
}
}
memset(mx, 0, sizeof(mx));
memset(f, 0, sizeof(f));
for (int i = r; i >= 1; i--) {
f[i] = i;
for (int j = 0; j < up[i].size(); j++) {
if (up[i][j] > r) continue;
int t = 0;
while (1 << t <= up[i][j] - i) t++;
t--;
f[i] = max(f[i], max(mx[i + 1][t], mx[up[i][j] - (1 << t) + 1][t]));
}
mx[i][0] = f[i];
for (int j = 1; j < 25; j++)
mx[i][j] = max(mx[i][j - 1], mx[min(r, i + (1 << (j - 1)))][j - 1]);
}
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
}
void init() {
int l, r;
scanf("%d %d", &N, &M);
for (int i = 1; i <= M; i++) {
scanf("%d %d", &l, &r);
if (l == r) continue;
low[r] = l;
up[l].push_back(r);
}
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d %d", &l, &r);
V[r].push_back(l);
ID[r].push_back(i);
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 9;
const int bl = 400;
vector<int> nx[N];
int pi[N];
int dp[N][500];
int lg[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
for (int i = 0; i < N; i++) pi[i] = -1;
lg[0] = 0;
for (int i = 1; i < N; i++) {
lg[i] = lg[i - 1];
while ((1 << (lg[i] + 1)) <= i) {
lg[i]++;
}
}
int n, m;
cin >> n >> m;
int l, r;
for (int i = 0; i < m; i++) {
cin >> l >> r;
nx[l].push_back(r);
pi[r] = l;
}
for (int i = 1; i <= n; i++)
for (int j = 0; j < 500; j++) dp[i][j] = i;
int rf;
int id;
int sz;
int mx;
for (int x = 1; x * bl <= n; x++) {
rf = x * bl;
vector<pair<int, int> > p;
for (int i = rf; i >= 1; i--) {
sz = p.size();
id = sz;
mx = i;
for (auto t : nx[i]) {
if (t <= rf) mx = max(mx, t);
}
for (int j = lg[sz]; j >= 0; j--) {
if (id - (1 << j) < 0 || p[id - (1 << j)].second > mx) continue;
id -= (1 << j);
}
if (id != sz) {
dp[i][x] = p[id].first;
}
while (!p.empty() && p.back().first <= dp[i][x]) {
p.pop_back();
}
p.push_back(make_pair(dp[i][x], i));
}
}
int q;
cin >> q;
int t;
int pp;
int li;
for (int i = 0; i < q; i++) {
cin >> l >> r;
t = -1;
for (int j = l / bl;; j++) {
if (j * bl > r) break;
if (j * bl >= l) t = j;
}
pp = l;
li = l;
if (t != -1) {
pp = dp[l][t];
li = t * bl + 1;
}
while (li <= r) {
if (pi[li] >= l && pi[li] <= pp) pp = li;
li++;
}
cout << pp << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
int N, M, Q, O[100002], T[262145];
std::vector<int> V[100002];
std::vector<std::pair<int, int> > VQ[100002];
void B(int p, int l, int r) {
T[p] = 1000000000;
if (l == r) return;
int m = (l + r) >> 1;
B(p << 1, l, m);
B(p << 1 | 1, m + 1, r);
}
inline void cmin(int &x, int y) {
if (y < x) x = y;
}
inline void down(int p) {
cmin(T[p << 1], T[p]);
cmin(T[p << 1 | 1], T[p]);
}
void P(int p, int l, int r, int L, int R, int w) {
if (T[p] <= w) return;
if (L <= l && r <= R) {
T[p] = w;
return;
}
down(p);
int m = (l + r) >> 1;
if (L <= m) P(p << 1, l, m, L, R, w);
if (R > m) P(p << 1 | 1, m + 1, r, L, R, w);
T[p] = std::max(T[p << 1], T[p << 1 | 1]);
}
int G(int p, int l, int r, int x, int w) {
if (T[p] <= w) return -1;
if (x <= l) {
while (l < r) {
int m = (l + r) >> 1;
down(p);
if (T[p << 1] > w)
r = m, p <<= 1;
else
l = m + 1, p = p << 1 | 1;
}
return l;
}
int m = (l + r) >> 1, LA = x <= m ? G(p << 1, l, m, x, w) : -1;
return ~LA ? LA : G(p << 1 | 1, m + 1, r, x, w);
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1, x, y; i <= M; i++) {
scanf("%d%d", &x, &y);
if (x < y) V[x].push_back(y);
}
scanf("%d", &Q);
for (int i = 1, x, y; i <= Q; i++) {
scanf("%d%d", &x, &y);
VQ[x].push_back({y, i});
}
B(1, 1, N);
for (int i = N; i; i--) {
for (int j : V[i]) P(1, 1, N, i, j - 1, j);
for (auto j : VQ[i]) O[j.second] = G(1, 1, N, i, j.first);
}
for (int i = 1; i <= Q; i++) printf("%d\n", O[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 100010;
int N, M, Q;
int R[MN];
vector<pair<int, int> > query[MN];
int ans[MN];
struct BIT {
vector<int> tree, lazy;
void init() {
tree = vector<int>(4 * N, -1);
lazy = vector<int>(4 * N, -1);
}
void prop(int l, int r, int n) {
if (l != r) {
tree[2 * n] = max(tree[2 * n], lazy[n]);
lazy[2 * n] = max(lazy[2 * n], lazy[n]);
tree[2 * n + 1] = max(tree[2 * n + 1], lazy[n]);
lazy[2 * n + 1] = max(lazy[2 * n + 1], lazy[n]);
lazy[n] = -1;
}
}
void upd(int a, int b, int v, int l, int r, int n) {
if (b < l || r < a) return;
if (a <= l && r <= b) {
tree[n] = max(tree[n], v);
lazy[n] = max(lazy[n], v);
return;
}
prop(l, r, n);
int m = (l + r) >> 1;
upd(a, b, v, l, m, 2 * n);
upd(a, b, v, m + 1, r, 2 * n + 1);
tree[n] = min(tree[2 * n], tree[2 * n + 1]);
}
int quer(int a, int b, int l, int r, int n) {
if (b < l || r < a) return 1e9;
if (a <= l && r <= b) return tree[n];
prop(l, r, n);
int m = (l + r) >> 1;
int L = quer(a, b, l, m, 2 * n);
int R = quer(a, b, m + 1, r, 2 * n + 1);
return min(L, R);
}
} bit;
int main() {
scanf("%d %d", &N, &M);
for (int i = 0; i < M; i++) {
int l, r;
scanf("%d %d", &l, &r);
l--;
r--;
if (l == r) continue;
R[r] = l + 1;
}
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
query[y].push_back({x, i});
}
bit.init();
for (int i = 0; i < N; i++) {
if (R[i]) {
bit.upd(R[i], i, R[i], 0, N - 1, 1);
}
for (int j = 0; j < query[i].size(); j++) {
int l = query[i][j].first;
int r = i;
int id = query[i][j].second;
int s = l + 1, e = r, p = -1;
while (s <= e) {
int m = (s + e) >> 1;
if (bit.quer(l + 1, m, 0, N - 1, 1) <= l) {
p = m;
e = m - 1;
} else
s = m + 1;
}
if (p == -1)
ans[id] = r;
else
ans[id] = p - 1;
}
}
for (int i = 0; i < Q; i++) {
printf("%d\n", ans[i] + 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int to[100009], p[100009], n, bel[100009], st[100009], en[100009], ans[100009];
int BLOK;
pair<int, int> arr[100009], d[100009], S[100009];
bool cmp(int x, int y) { return (arr[x].second < arr[y].second); }
void upd(int p, int v) {
umax(d[p], make_pair(v, p));
umax(S[bel[p]], d[p]);
}
pair<int, int> get(int l, int r) {
pair<int, int> res = make_pair(0, 0);
if (bel[l] == bel[r]) {
for (int i = l; i <= r; i++) umax(res, d[i]);
return res;
}
for (int i = l; i <= en[bel[l]]; i++) umax(res, d[i]);
for (int i = st[bel[r]]; i <= r; i++) umax(res, d[i]);
for (int i = bel[l] + 1; i < bel[r]; i++) umax(res, S[i]);
return res;
}
int jump(int x) {
if (d[x].first == x) return x;
pair<int, int> res = get(x, d[x].first);
if (res.first <= d[x].first) return d[x].first;
return jump(res.second);
}
void build() {
int now = 1;
for (int i = 1; i <= n; i++) {
bel[i] = now;
d[i] = make_pair(i, i);
umax(S[now], d[i]);
if (i % BLOK == 0) {
en[now] = i;
if (i < n) st[++now] = i + 1;
}
}
if (n % BLOK != 0) en[now] = n;
}
int main() {
int m;
scanf("%d%d", &n, &m);
BLOK = sqrt(n);
build();
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (l != r) to[r] = l;
}
int q, pnt = 1;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d%d", &x, &y);
arr[i] = make_pair(x, y);
p[i] = i;
}
sort(p + 1, p + q + 1, cmp);
for (int i = 1; i <= n; i++) {
if (to[i]) upd(to[i], i);
while (pnt <= q and arr[p[pnt]].second == i)
ans[p[pnt]] = jump(arr[p[pnt]].first), pnt++;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> L[100001];
int R[100001];
int nxt[100001];
int L_max[100001];
int pref_max[100001];
const int BLOCK_SIZE = 300;
vector<pair<pair<int, int>, int> > queries;
int Q_ans[100001];
bool compare(pair<pair<int, int>, int> L, pair<pair<int, int>, int> R) {
return L.first.second < R.first.second;
}
int main() {
int N, M;
scanf("%d %d", &N, &M);
while (M--) {
int x, y;
scanf("%d %d", &x, &y);
L[x].push_back(y);
R[y] = x;
}
for (int i = 1; i <= N; i++) {
int id = i / BLOCK_SIZE;
int R = (id + 1) * BLOCK_SIZE - 1;
nxt[i] = i;
for (int x : L[i]) {
if (x <= R) nxt[i] = x;
}
}
for (int i = 1; i <= N; i++) {
int id = i / BLOCK_SIZE;
int L = id * BLOCK_SIZE;
if (i > L) nxt[i] = max(nxt[i], nxt[i - 1]);
}
for (int i = N; i >= 1; i--) {
int id = i / BLOCK_SIZE;
int R = (id + 1) * BLOCK_SIZE - 1;
for (int x : L[i]) {
if (x <= R) nxt[i] = max(nxt[i], nxt[x]);
}
}
int Q;
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
int x, y;
scanf("%d %d", &x, &y);
queries.push_back({{x, y}, i});
}
sort(queries.begin(), queries.end(), compare);
int prev_y = 0;
for (auto it : queries) {
int x = it.first.first, y = it.first.second;
while (prev_y < y) {
++prev_y;
if (R[prev_y] == 0) continue;
int l = R[prev_y];
L_max[l] = prev_y;
int block_end = min(N, (l / BLOCK_SIZE + 1) * BLOCK_SIZE - 1);
for (int i = l; i <= block_end; i++) {
pref_max[i] = prev_y;
}
}
if (x / BLOCK_SIZE == y / BLOCK_SIZE) {
int ans = x;
for (int i = x; i <= y; i++) {
if (i > ans) break;
ans = max(ans, L_max[i]);
}
Q_ans[it.second] = ans;
} else {
int ans = x;
for (int id = x / BLOCK_SIZE; id <= y / BLOCK_SIZE; id++) {
if (ans < id * BLOCK_SIZE) break;
bool done = false;
if (id == x / BLOCK_SIZE) {
int block_end = (x / BLOCK_SIZE + 1) * BLOCK_SIZE - 1;
for (int i = x; i <= block_end; i++) {
if (i > ans) {
done = true;
break;
}
ans = max(ans, L_max[i]);
}
} else if (id == y / BLOCK_SIZE) {
for (int i = id * BLOCK_SIZE; i <= y; i++) {
if (i > ans) {
done = true;
break;
}
ans = max(ans, L_max[i]);
}
} else {
if (ans >= (id + 1) * BLOCK_SIZE - 1)
ans = max(ans, pref_max[(id + 1) * BLOCK_SIZE - 1]);
else {
ans = max(ans, nxt[ans]);
ans = max(ans, pref_max[ans]);
if (ans >= (id + 1) * BLOCK_SIZE - 1)
ans = max(ans, pref_max[(id + 1) * BLOCK_SIZE - 1]);
}
}
if (done) break;
}
Q_ans[it.second] = ans;
}
}
for (int i = 0; i < Q; i++) printf("%d\n", Q_ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
pair<int, int> g[350];
int n, m, siz, f[maxn][350], back[maxn];
vector<int> vec[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
siz = sqrt(n);
memset(back, -1, sizeof back);
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
l--;
r--;
back[r] = l;
vec[l].push_back(r);
}
memset(g, -1, sizeof g);
for (int i = n - 1; i >= 0; i--) {
for (int j : vec[i])
if (j / siz != i / siz) {
int w = j / siz, rec = -1;
for (int k = w * siz; k <= min(w * siz + siz - 1, n - 1); k++)
if (back[k] >= i && (rec == -1 || back[k] < back[rec])) rec = k;
g[w] = make_pair(back[rec], rec);
for (int k = rec + 1; k <= min(w * siz + siz - 1, n - 1); k++)
if (back[k] >= i && back[k] <= g[w].second) g[w].second = k;
}
int x = i, w = i / siz;
for (int j = i; j <= w * siz + siz - 1; j++)
if (back[j] >= i && back[j] <= x) x = j;
f[i][w] = x;
for (int j = w + 1; j <= (n - 1) / siz; j++) {
if (g[j].first != -1 && x >= g[j].first) x = g[j].second;
f[i][j] = x;
}
}
int q;
cin >> q;
while (q--) {
int x, y;
cin >> x >> y;
x--;
y--;
int wx = x / siz, wy = y / siz;
if (wx == wy) {
int ans = x;
for (int i = x; i <= y; i++)
if (back[i] >= x && back[i] <= ans) ans = i;
cout << ans + 1 << '\n';
} else {
int ans = f[x][wy - 1];
for (int i = wy * siz; i <= y; i++)
if (back[i] >= x && back[i] <= ans) ans = i;
cout << ans + 1 << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &first) {
char c = getchar();
first = 0;
while (c < '0' || c > '9') c = getchar();
while ('0' <= c && c <= '9') first = first * 10 + c - '0', c = getchar();
}
const int N = 1e5 + 10;
int n, m;
vector<int> seg[N], qry[N], id[N];
namespace Seg {
int a, b, c, mx[N << 2], tag[N << 2];
void push(int first, int l, int r) {
if (tag[first]) {
if (!mx[first])
mx[first] = tag[first];
else
mx[first] = min(mx[first], tag[first]);
if (l < r) {
if (!tag[(first << 1)] || tag[(first << 1)] > tag[first])
tag[(first << 1)] = tag[first];
if (!tag[((first << 1) | 1)] || tag[((first << 1) | 1)] > tag[first])
tag[((first << 1) | 1)] = tag[first];
}
tag[first] = 0;
}
}
void modi(int first, int l, int r) {
if (a <= l && r <= b) {
if (!tag[first] || tag[first] > c) tag[first] = c;
push(first, l, r);
} else
push(first, l, r),
(a <= ((l + r) >> 1) ? modi((first << 1), l, ((l + r) >> 1))
: push((first << 1), l, ((l + r) >> 1))),
(b > ((l + r) >> 1) ? modi(((first << 1) | 1), ((l + r) >> 1) + 1, r)
: push(((first << 1) | 1), ((l + r) >> 1) + 1, r)),
mx[first] = max(mx[(first << 1)], mx[((first << 1) | 1)]);
}
int find(int first, int l, int r) {
if (l == r)
return l;
else {
push(first, l, r), push((first << 1), l, ((l + r) >> 1));
return (mx[(first << 1)] <= c
? find(((first << 1) | 1), ((l + r) >> 1) + 1, r)
: find((first << 1), l, ((l + r) >> 1)));
}
}
} // namespace Seg
int ans[N];
int main() {
read(n), read(m);
for (int i = 1; i <= m; i++) {
int l, r;
read(l), read(r);
seg[l].push_back(r);
}
int q;
read(q);
for (int i = 1; i <= q; i++) {
int l, r;
read(l), read(r);
qry[l].push_back(r), id[l].push_back(i);
}
for (int l = n; l >= 1; l--) {
int len = seg[l].size();
Seg::a = l, Seg::b = l, Seg::c = n + 1, Seg::modi(1, 1, n);
for (int j = 0; j < len; j++) {
Seg::a = l, Seg::b = seg[l][j] - 1, Seg::c = seg[l][j];
if (Seg::a <= Seg::b) Seg::modi(1, 1, n);
}
len = qry[l].size();
for (int j = 0; j < len; j++) {
Seg::c = qry[l][j];
ans[id[l][j]] = Seg::find(1, 1, n);
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma G++ optimize("O2")
using namespace std;
const int N = 111111;
const int M = 666666;
const int MOD = 1e9 + 7;
const int intINF = 1e9;
const long long llINF = 2e18;
const double pi = acos(-1.0);
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
const double eps = 1e-10;
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
long long readll() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
unsigned long long readull() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
vector<pair<int, int> > V[N];
int a[N], n, m, q;
void predo() {}
void init() {
n = read(), m = read();
for (int i = (int)1; i <= (int)m; i++) {
int x = read(), y = read();
a[y] = x;
}
q = read();
for (int i = (int)1; i <= (int)q; i++) {
int x = read(), y = read();
V[y].push_back(make_pair(x, i));
}
}
struct node {
int mx, mx2, tag;
} t[N << 2];
void addtag(int p, int s) {
t[p].mx += s;
t[p].tag += s;
}
void pushdown(int p) {
if (t[p].tag) {
int mx = max(t[p << 1].mx, t[p << 1 | 1].mx);
if (t[p << 1].mx == mx) addtag(p << 1, t[p].tag);
if (t[p << 1 | 1].mx == mx) addtag(p << 1 | 1, t[p].tag);
t[p].tag = 0;
}
}
void fix(int p, int x) {
if (x > t[p].mx) {
t[p].mx2 = t[p].mx;
t[p].mx = x;
} else if (x < t[p].mx && x > t[p].mx2)
t[p].mx2 = x;
}
void pushup(int p) {
t[p].mx = -intINF;
fix(p, t[p << 1].mx);
fix(p, t[p << 1].mx2);
fix(p, t[p << 1 | 1].mx);
fix(p, t[p << 1 | 1].mx2);
}
void update(int l, int r, int x, int y, int s1, int s2, int p) {
if (t[p].mx < s1) return;
if (x <= l && r <= y && t[p].mx2 < s1) {
addtag(p, s2 - t[p].mx);
return;
}
pushdown(p);
int mid = (l + r) >> 1;
if (x <= mid) update(l, mid, x, y, s1, s2, p << 1);
if (y > mid) update(mid + 1, r, x, y, s1, s2, p << 1 | 1);
pushup(p);
}
int query(int l, int r, int x, int p) {
if (l == r) return t[p].mx;
pushdown(p);
int mid = (l + r) >> 1;
if (x <= mid) return query(l, mid, x, p << 1);
return query(mid + 1, r, x, p << 1 | 1);
}
void build(int l, int r, int p) {
if (l == r) {
t[p].mx = l;
t[p].mx2 = -intINF;
return;
}
int mid = (l + r) >> 1;
build(l, mid, p << 1);
build(mid + 1, r, p << 1 | 1);
pushup(p);
}
int ans[N];
void solve() {
build(1, n, 1);
for (int i = (int)1; i <= (int)n; i++) {
if (a[i]) {
update(1, n, 1, a[i], a[i], i, 1);
}
for (auto t : V[i]) {
ans[t.second] = query(1, n, t.first, 1);
}
}
for (int i = (int)1; i <= (int)q; i++) printf("%d\n", ans[i]);
}
int main() {
predo();
int cas = 1;
while (cas--) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000, maxq = 100000;
int n, m, Q, Ls[maxn + 5], ans[maxq + 5];
vector<pair<int, int> > q[maxn + 5];
int MAX[(maxn << 2) + 5], lst[(maxn << 2) + 5], TA[(maxn << 2) + 5],
TB[(maxn << 2) + 5];
inline void Fix(int p, int x) {
if (x > MAX[p])
lst[p] = MAX[p], MAX[p] = x;
else if (x < MAX[p] && x > lst[p])
lst[p] = x;
}
inline void Pushup(int p) {
MAX[p] = -2e9;
Fix(p, MAX[p << 1]);
Fix(p, lst[p << 1]);
Fix(p, MAX[p << 1 | 1]);
Fix(p, lst[p << 1 | 1]);
}
void Build(int l, int r, int p = 1) {
if (l == r) {
MAX[p] = l;
lst[p] = -2e9;
return;
}
int mid = l + (r - l >> 1);
Build(l, mid, p << 1);
Build(mid + 1, r, p << 1 | 1);
Pushup(p);
}
inline void Addtag(int p, int A, int B) {
if (MAX[p] >= A) {
MAX[p] = B;
if (!TA[p]) TA[p] = A;
TB[p] = B;
}
}
inline void Pushdown(int p) {
if (TA[p])
Addtag(p << 1, TA[p], TB[p]), Addtag(p << 1 | 1, TA[p], TB[p]),
TA[p] = TB[p] = 0;
}
void Insert(int L, int R, int A, int B, int l = 1, int r = n, int p = 1) {
if (MAX[p] < A) return;
if (L == l && r == R && lst[p] < A) return Addtag(p, A, B);
int mid = l + (r - l >> 1);
Pushdown(p);
if (R <= mid)
Insert(L, R, A, B, l, mid, p << 1);
else if (L > mid)
Insert(L, R, A, B, mid + 1, r, p << 1 | 1);
else
Insert(L, mid, A, B, l, mid, p << 1),
Insert(mid + 1, R, A, B, mid + 1, r, p << 1 | 1);
Pushup(p);
}
int Ask(int pos, int l = 1, int r = n, int p = 1) {
if (l == r) return MAX[p];
int mid = l + (r - l >> 1);
Pushdown(p);
if (pos <= mid) return Ask(pos, l, mid, p << 1);
return Ask(pos, mid + 1, r, p << 1 | 1);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; i++) scanf("%d%d", &x, &y), Ls[y] = x;
scanf("%d", &Q);
for (int i = 1, x, y; i <= Q; i++)
scanf("%d%d", &x, &y), q[y].push_back(make_pair(x, i));
for (int i = (Build(1, n), 1); i <= n; i++) {
if (Ls[i]) Insert(1, Ls[i], Ls[i], i);
for (int si = q[i].size(), j = 0; j < si; j++)
ans[q[i][j].second] = Ask(q[i][j].first);
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
int n, m;
int ntot = 0;
int id[85];
int f[100005][85];
int mxr[100005][85];
int fr[100005];
inline void upmx(int &x, int y) { x = max(x, y); }
inline void insert(int x, int y) {
fr[y] = x;
upmx(mxr[x][(y - 1) / 1200 + 1], y);
}
int lg[100005], bin[100005];
int ST[100005][20];
inline void STinit() {
memset(ST, 0, sizeof(ST));
for (int i = 1; i <= n; i++) ST[i][0] = i;
}
inline void STmdf(int x, int y) {
ST[x][0] = y;
int *p = ST[x];
for (int j = 1; x + bin[j] - 1 <= n; j++)
p[j] = max(p[j - 1], ST[x + bin[j - 1]][j - 1]);
}
inline int STqry(int l, int r) {
if (r < l) return 0;
int t = lg[r - l + 1];
return max(ST[l][t], ST[r - bin[t] + 1][t]);
}
int main() {
n = getint(), m = getint();
lg[0] = -1;
for (int i = 1; i < 100005; i++) lg[i] = lg[i >> 1] + 1;
bin[0] = 1;
for (int i = 1; i < 20; i++) bin[i] = bin[i - 1] << 1;
for (int i = 1; i <= n; i++) fr[i] = i;
for (ntot = 1; ntot * 1200 <= n; ntot++) id[ntot] = ntot * 1200;
ntot--;
for (int i = 1; i <= m; i++) {
int x = getint(), y = getint();
insert(x, y);
}
for (int i = 1; i <= n; i++) {
mxr[i][0] = i;
for (int j = 1; j <= ntot; j++) upmx(mxr[i][j], mxr[i][j - 1]);
}
for (int j = 1; j <= ntot; j++) {
f[id[j]][j] = id[j];
STmdf(id[j], id[j]);
for (int i = id[j] - 1; i >= 1; i--) {
f[i][j] = max(i, STqry(i + 1, mxr[i][j]));
STmdf(i, f[i][j]);
}
}
int qq = getint();
while (qq--) {
int l = getint(), r = getint();
int R = r / 1200;
int ans, st;
if (r - l <= 1200)
ans = l, st = ans;
else
ans = f[l][R], st = id[R];
int i;
for (i = st + 1; i <= r - 7; i += 8) {
ans = ((*(fr + i) <= ans) && (*(fr + i) >= l)) ? i : ans;
ans = ((*(fr + i + 1) <= ans) && (*(fr + i + 1)) >= l) ? (i + 1) : ans;
ans = ((*(fr + i + 2) <= ans) && (*(fr + i + 2)) >= l) ? (i + 2) : ans;
ans = ((*(fr + i + 3) <= ans) && (*(fr + i + 3)) >= l) ? (i + 3) : ans;
ans = ((*(fr + i + 4) <= ans) && (*(fr + i + 4)) >= l) ? (i + 4) : ans;
ans = ((*(fr + i + 5) <= ans) && (*(fr + i + 5)) >= l) ? (i + 5) : ans;
ans = ((*(fr + i + 6) <= ans) && (*(fr + i + 6)) >= l) ? (i + 6) : ans;
ans = ((*(fr + i + 7) <= ans) && (*(fr + i + 7)) >= l) ? (i + 7) : ans;
}
for (; i <= r; i++) ans = (fr[i] <= ans && fr[i] >= l) ? i : ans;
printf("%d\n", ans);
ans = (fr[i] <= ans && fr[i] >= l) ? i : ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int INF = 1e9 + 10;
vector<pair<int, int> > w[MAXN];
int a[MAXN];
int ans[MAXN];
int segt[4 * MAXN];
int lazy[4 * MAXN];
void lzu(int id) {
segt[2 * id + 1] = min(segt[2 * id + 1], lazy[id]);
segt[2 * id + 2] = min(segt[2 * id + 2], lazy[id]);
lazy[2 * id + 1] = min(lazy[2 * id + 1], lazy[id]);
lazy[2 * id + 2] = min(lazy[2 * id + 2], lazy[id]);
lazy[id] = INF;
}
void update(int id, int L, int R, int l, int r, int val) {
if (L > r || R < l) {
return;
}
if (L >= l && R <= r) {
segt[id] = min(segt[id], val);
lazy[id] = min(lazy[id], val);
return;
}
lzu(id);
int mid = (L + R) / 2;
update(2 * id + 1, L, mid, l, r, val);
update(2 * id + 2, mid + 1, R, l, r, val);
segt[id] = max(segt[2 * id + 1], segt[2 * id + 2]);
}
int get_res(int id, int L, int R, int l, int r, int val) {
if (L > r || R < l) {
return -1;
}
if (L >= l && R <= r) {
if (segt[id] < val) {
return -1;
}
while (L != R) {
int mid = (L + R) / 2;
if (segt[2 * id + 1] >= val) {
id = 2 * id + 1;
R = mid;
} else {
id = 2 * id + 2;
L = mid + 1;
}
}
return L;
}
lzu(id);
int mid = (L + R) / 2;
int z = get_res(2 * id + 1, L, mid, l, r, val);
if (z == -1) {
return get_res(2 * id + 2, mid + 1, R, l, r, val);
} else {
return z;
}
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
fill(a, a + MAXN, INF);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
if (l != r) {
w[l].push_back(make_pair(0, r));
}
}
fill(segt, segt + 4 * MAXN, n);
fill(lazy, lazy + 4 * MAXN, INF);
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
int x, y;
cin >> x >> y;
w[x].push_back(make_pair(i, y));
}
for (int i = n; i >= 1; i--) {
for (int j = 0; j < w[i].size(); j++) {
if (w[i][j].first == 0) {
update(1, 1, n, i, w[i][j].second - 1, w[i][j].second - 1);
} else {
ans[w[i][j].first] =
get_res(1, 1, n, i, w[i][j].second, w[i][j].second);
}
}
}
for (int i = 1; i <= q; i++) {
cout << ans[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int sgn(double x) { return x < -eps ? -1 : x > eps; }
int Mn(int& a, int b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int Mx(int& a, int b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
long long inv(long long a, long long b) {
return a == 1 ? 1 : (1 - b * inv(b % a, a)) / a;
}
long long exg(long long a, long long b, int& x, int& y) {
!a ? x = 0, y = 1 : (exg(b % a, a, y, x), x -= b / a * y);
}
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 = 1e5 + 5, B = 330;
vector<int> a[N];
int f[N][B], g[N][B], n, m, L, pre[N];
stack<int> q;
int solve(int x, int cur, int st, int y) {
for (int i = st; i <= int(y); i++)
if (x <= pre[i] && pre[i] <= cur) cur = i;
return cur + 1;
}
int main() {
cin >> n >> m;
for (int i = 0; i <= int(n - 1); i++) pre[i] = -1;
for (int i = 1; i <= int(m); i++) {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
x--;
y--;
a[x].push_back(y);
pre[y] = x;
}
L = sqrt(n) + 0.5;
for (int i = 0; i <= int(n - 1); i++) sort(a[i].begin(), a[i].end());
for (int i = 0; i <= int(n - 1); i++) {
if (!((int)(a[i]).size())) continue;
int k = 0;
for (int j = 1; j <= int((n - 1) / L); j++) {
while (k < ((int)(a[i]).size()) - 1 && a[i][k + 1] <= j * L) k++;
if (a[i][k] <= j * L) g[i][j] = a[i][k];
}
}
for (int j = 1; j <= int((n - 1) / L); j++) {
while (!q.empty()) q.pop();
for (int i = n - 1; i >= int(0); i--) {
f[i][j] = max(i, g[i][j]);
while (!q.empty() && q.top() <= f[i][j])
Mx(f[i][j], f[q.top()][j]), q.pop();
q.push(i);
}
}
int T;
cin >> T;
while (T--) {
int x, y;
scanf("%d", &x);
scanf("%d", &y);
x--;
y--;
printf("%d\n", solve(x, max(x, f[x][y / L]), max(x, y / L * L), y));
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, q, a[((int)101 * 1000)], dp[((int)101 * 1000)],
ans[((int)101 * 1000)];
vector<pair<int, int> > qu[((int)101 * 1000)];
pair<int, int> lazy[4 * ((int)101 * 1000)];
void update_lazy(int id, int x, int y) {
if (lazy[id].first == -1) {
lazy[id] = {x, y};
return;
}
if (x <= lazy[id].second) lazy[id] = {min(x, lazy[id].first), y};
}
void shift(int id) {
if (lazy[id].first == -1) return;
update_lazy(id * 2, lazy[id].first, lazy[id].second);
update_lazy(id * 2 + 1, lazy[id].first, lazy[id].second);
lazy[id] = {-1, -1};
}
void update(int ql, int qr, int x, int y, int xl = 0, int xr = n, int id = 1) {
if (qr <= xl || xr <= ql) return;
if (ql <= xl && xr <= qr) {
update_lazy(id, x, y);
return;
}
int mid = (xl + xr) / 2;
shift(id);
update(ql, qr, x, y, xl, mid, id * 2);
update(ql, qr, x, y, mid, xr, id * 2 + 1);
}
void clean(int q, int xl = 0, int xr = n, int id = 1) {
if (xl == xr - 1) {
if (lazy[id].first == -1) return;
if (dp[xl] >= lazy[id].first) dp[xl] = lazy[id].second;
lazy[id] = {-1, -1};
return;
}
int mid = (xl + xr) / 2;
shift(id);
if (q < mid)
clean(q, xl, mid, id * 2);
else
clean(q, mid, xr, id * 2 + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < 4 * ((int)101 * 1000); i++) lazy[i] = {-1, -1};
for (int i = 0; i < n; i++) a[i] = -1;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
l--;
r--;
a[r] = l;
}
cin >> q;
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
qu[y].push_back({x, i});
}
for (int i = 0; i < n; i++) {
dp[i] = i;
if (a[i] != -1) update(0, a[i] + 1, a[i], i);
for (auto u : qu[i]) clean(u.first), ans[u.second] = dp[u.first];
}
for (int i = 0; i < q; i++) cout << ans[i] + 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
struct line {
int a, b;
line() {}
line(int a, int b) : a(a), b(b) {}
bool operator<(const line& o) const { return a < o.a; }
friend line operator+(const line& first, const line& second) {
if (second < first) return second + first;
if (first.b >= second.a && first.b < second.b)
return line(first.a, second.b);
return first;
}
void print() { printf("(%d, %d) ", a, b); }
};
struct node {
vector<line> box;
node() {}
node(line first) { box = {first}; }
int size() { return (int)(box).size(); }
friend node operator+(const node& X, const node& Y) {
const vector<line>& first = X.box;
const vector<line>& second = Y.box;
int l = 0, r = 0;
node T;
vector<line>& t = T.box;
while (l < first.size() && r < second.size()) {
if (first[l] < second[r])
t.push_back(first[l++]);
else
t.push_back(second[r++]);
}
while (l < first.size()) t.push_back(first[l++]);
while (r < second.size()) t.push_back(second[r++]);
vector<line> Stack;
Stack.push_back(t.back());
for (int i = ((int)(t).size() - 2); i >= (0); --i) {
line& c = t[i];
while (!Stack.empty() && Stack.back().a <= c.b) {
c.b = max(c.b, Stack.back().b);
Stack.pop_back();
}
Stack.push_back(c);
}
Stack.clear();
return T;
}
line search(int a) {
int l = 0, r = size();
while (l < r) {
int m = (l + r) >> 1;
if (box[m].a < a)
l = m + 1;
else
r = m;
}
if (l != size()) return box[l];
return line(inf, inf);
}
void print() {
printf("{ ");
for (line& e : box) {
e.print();
cout << " ";
}
printf("}\n");
}
};
const int N = 100005;
line rope[N];
node seg[N << 2];
void build(int l, int r, int now) {
if (l == r) {
seg[now] = node(rope[l]);
return;
}
int m = (l + r) >> 1;
int L = (now << 1), R = (now << 1 | 1);
build(l, m, L);
build(m + 1, r, R);
seg[now] = seg[L] + seg[R];
}
line get(int ll, int rr, int l, int r, int now) {
if (ll <= l && r <= rr) {
return seg[now].search(ll);
}
if (rr < l || r < ll) return line(inf, inf);
int m = (l + r) >> 1;
return get(ll, rr, l, m, now << 1) + get(ll, rr, m + 1, r, now << 1 | 1);
}
void solve() {
int n, m;
cin >> n >> m;
for (int i = (1); i <= (m); ++i) {
int a, b;
cin >> a >> b;
rope[b] = {a, b};
}
build(1, n, 1);
int q;
cin >> q;
while (q--) {
int a, b;
cin >> a >> b;
line ans = get(a, b, 1, n, 1);
if (ans.a != a)
printf("%d\n", a);
else
printf("%d\n", ans.b);
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r, lc, rc, d, p;
} lt[2 * 110000];
struct node1 {
int l, r, id;
} q[110000];
int n, m, L[110000], fa[110000], ans[110000], tl;
bool cmp(node1 x, node1 y) {
if (x.r < y.r) return 1;
return 0;
}
void upd(int now) {
int lc = lt[now].lc, rc = lt[now].rc;
if (lt[lc].d > lt[rc].d)
lt[now].d = lt[lc].d, lt[now].p = lt[lc].p;
else
lt[now].d = lt[rc].d, lt[now].p = lt[rc].p;
}
void bt(int l, int r) {
int now = ++tl;
lt[now].l = l;
lt[now].r = r;
if (l < r) {
int mid = (l + r) / 2;
lt[now].lc = tl + 1;
bt(l, mid);
lt[now].rc = tl + 1;
bt(mid + 1, r);
upd(now);
} else
lt[now].p = lt[now].d = l;
}
void change(int now, int k, int d) {
int mid = (lt[now].l + lt[now].r) / 2, lc = lt[now].lc, rc = lt[now].rc;
if (lt[now].l == lt[now].r) {
lt[now].d = d;
return;
}
if (mid >= k)
change(lc, k, d);
else
change(rc, k, d);
upd(now);
}
void query(int now, int l, int r, int &p, int &d) {
int mid = (lt[now].l + lt[now].r) / 2, lc = lt[now].lc, rc = lt[now].rc;
if (lt[now].l == l && lt[now].r == r) {
p = lt[now].p;
d = lt[now].d;
return;
}
if (mid >= r)
query(lc, l, r, p, d);
else if (l > mid)
query(rc, l, r, p, d);
else {
int p1, d1;
query(lc, l, mid, p1, d1);
query(rc, mid + 1, r, p, d);
if (d1 > d) d = d1, p = p1;
}
}
int find(int x) {
if (fa[x] != x) {
int p, d;
query(1, x, fa[x], p, d);
if (d > fa[x]) fa[x] = find(p);
}
return fa[x];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (r > l) L[r] = l;
}
for (int i = 1; i <= n; i++) fa[i] = i;
scanf("%d", &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &q[i].l, &q[i].r), q[i].id = i;
sort(q + 1, q + m + 1, cmp);
bt(1, n);
int j = 1;
for (int i = 1; i <= n; i++) {
if (L[i]) {
fa[L[i]] = i;
change(1, L[i], i);
}
while (j <= m && q[j].r == i) {
ans[q[j].id] = find(q[j].l);
j++;
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, inf = 1e9;
int mx[4 * maxn], mx2[4 * maxn], lz[4 * maxn];
int a[maxn];
void Merge(int id) {
mx[id] = max(mx[2 * id], mx[2 * id + 1]);
mx2[id] = max(mx2[2 * id], mx2[2 * id + 1]);
if (mx[id] != mx[2 * id]) mx2[id] = max(mx2[id], mx[2 * id]);
if (mx[id] != mx[2 * id + 1]) mx2[id] = max(mx2[id], mx[2 * id + 1]);
}
void shift(int l, int r, int id) {
if (lz[id] == -1) return;
if (r - l > 1) {
if (mx[id] == max(mx[2 * id], lz[2 * id])) lz[2 * id] = lz[id];
if (mx[id] == max(mx[2 * id + 1], lz[2 * id + 1])) lz[2 * id + 1] = lz[id];
}
mx[id] = lz[id];
lz[id] = -1;
}
void build(int l = 0, int r = maxn, int id = 1) {
lz[id] = -1;
if (r - l == 1) {
mx[id] = l;
mx2[id] = -inf;
return;
}
int mid = (l + r) >> 1;
build(l, mid, 2 * id);
build(mid, r, 2 * id + 1);
Merge(id);
}
void Add(int f, int s, int x, int y, int l = 0, int r = maxn, int id = 1) {
if (f >= s || l >= r) return;
shift(l, r, id);
if (s <= l || r <= f || mx[id] < x) return;
if (f <= l && r <= s && mx2[id] < x) {
lz[id] = y;
shift(l, r, id);
return;
}
int mid = (l + r) >> 1;
Add(f, s, x, y, l, mid, 2 * id);
Add(f, s, x, y, mid, r, 2 * id + 1);
Merge(id);
}
int Ask(int pos, int l = 0, int r = maxn, int id = 1) {
shift(l, r, id);
if (r - l == 1) return mx[id];
int mid = (l + r) >> 1;
if (pos < mid) return Ask(pos, l, mid, 2 * id);
return Ask(pos, mid, r, 2 * id + 1);
}
int any[maxn], ans[maxn];
vector<pair<int, int> > v[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
build();
memset(any, -1, sizeof any);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
any[--b] = --a;
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
v[--b].push_back({--a, i});
}
for (int i = 0; i < n; i++) {
if (any[i] != -1) Add(0, any[i] + 1, any[i], i);
for (pair<int, int> p : v[i]) ans[p.second] = Ask(p.first);
}
for (int i = 0; i < q; i++) {
cout << ans[i] + 1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(0) * 2;
const double EPS = 1e-8;
const long long MOD = 1e9 + 7;
const int MAXN = 2e5 + 5;
const int oo = 1e9;
const double foo = 1e30;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcounll(s);
}
template <class T>
T sqr(T x) {
return x * x;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
const int nip = 330;
int n, l[MAXN], r[MAXN], isR[MAXN], isL[MAXN], gg[MAXN];
int d[nip + 5][nip * nip + 5], g[nip + 5][nip * nip + 5];
int main() {
cin >> n;
int num;
cin >> num;
for (int i = 0; i < n; i++) gg[i] = -1;
for (int i = 0; i < num; i++) {
scanf("%d%d", &l[i], &r[i]);
l[i]--;
r[i]--;
isR[r[i]] = 1;
isL[l[i]] = 1;
gg[r[i]] = l[i];
}
for (int i = nip - 1; i < n; i += nip) {
for (int j = i; j >= 0; j--) {
if (!isL[j]) d[i / nip][j] = -1;
if (isR[j]) d[i / nip][gg[j]] = max(d[i / nip][gg[j]], j);
}
}
stack<int> st;
for (int i = nip - 1; i < n; i += nip) {
while (!st.empty()) st.pop();
for (int j = i; j >= 0; j--) {
g[i / nip][j] = j;
while (!st.empty() && st.top() <= d[i / nip][j]) {
g[i / nip][j] = max(g[i / nip][j], g[i / nip][st.top()]);
st.pop();
}
st.push(j);
}
}
int q;
cin >> q;
for (int tc = 0; tc < q; tc++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
if (y - x + 1 <= nip) {
int ans = x;
for (int i = x + 1; i <= y; i++) {
if (gg[i] >= x && gg[i] <= ans) {
ans = i;
}
}
printf("%d\n", ans + 1);
} else {
int hi = y / nip;
hi--;
int ans = g[hi][x];
for (int i = (hi + 1) * nip; i <= y; i++) {
if (gg[i] >= x && gg[i] <= ans) {
ans = i;
}
}
printf("%d\n", ans + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int block = 320;
const int maxn = 11e4;
int n, m, q, f[maxn][block], dp[maxn][block], prv[maxn];
vector<int> up[maxn];
inline void proc() {
memset((f), (0), sizeof(f));
for (register int(i) = (0); (i) < (maxn); ++(i)) {
for (register int(j) = (0); (j) < (up[i].size()); ++(j))
(f[i][(int)ceil((double)up[i][j] / block)]) =
max((f[i][(int)ceil((double)up[i][j] / block)]), (up[i][j]));
for (register int(j) = (1); (j) < (block); ++(j))
(f[i][j]) = max((f[i][j]), (f[i][j - 1]));
}
for (register int(i) = (block)-1; (i) >= (0); --(i)) {
stack<int> stk;
for (register int(j) = (i * block + 1) - 1; (j) >= (0); --(j)) {
dp[j][i] = f[j][i];
while (stk.size() && dp[j][i] >= stk.top())
(dp[j][i]) = max((dp[j][i]), (dp[stk.top()][i])), stk.pop();
stk.push(j);
}
}
}
int main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false);
cin >> n >> m;
for (register int(i) = (0); (i) < (maxn); ++(i)) up[i].push_back(i);
for (register int(i) = (0); (i) < (maxn); ++(i)) prv[i] = 1ll << 25;
for (register int(i) = (0); (i) < (m); ++(i)) {
int l, r;
cin >> l >> r;
up[l].push_back(r);
prv[r] = l;
}
proc();
cin >> q;
while (q--) {
int x, y, res, po;
cin >> x >> y;
if (x / block != y / block)
res = dp[x][y / block], po = y / block * block;
else
res = po = x;
while (po++ < y)
if (x <= prv[po] && prv[po] <= res) res = po;
cout << res << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int SQRT = 1500;
vector<int> up[N], down[N];
vector<pair<int, pair<int, int>>> q[N];
set<int> pos;
int ans[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int m;
cin >> m;
for (int i = 0; (i) < (m); ++i) {
int l, r;
cin >> l >> r;
l--, r--;
up[l].push_back(r);
down[r].push_back(l);
}
for (int i = 0; (i) < (n); ++i) {
sort((up[i]).begin(), (up[i]).end());
sort((down[i]).begin(), (down[i]).end());
}
int qq;
cin >> qq;
for (int i = 0; (i) < (qq); ++i) {
int x, y;
cin >> x >> y;
x--, y--;
if (y - x <= SQRT) {
int mx = x;
for (int p = (x); (p) < (y + 1); ++p) {
if (p > mx) break;
auto ok = upper_bound((up[p]).begin(), (up[p]).end(), y);
if (ok == up[p].begin()) continue;
ok--;
mx = max(mx, *ok);
}
ans[i] = mx;
} else {
q[x / SQRT].push_back(make_pair(y, make_pair(x, i)));
}
}
for (int i = 0; (i) < (n); ++i) {
sort((q[i]).begin(), (q[i]).end());
}
for (int i = 0; (i) < (n / SQRT + 1); ++i) {
if ((int)((q[i]).size()) == 0) continue;
int start = SQRT * (i + 1) - 1, now = start;
for (int j = 0; (j) < (n); ++j) pos.insert(j);
for (auto query : q[i]) {
int y = query.first, x = query.second.first, id = query.second.second;
while (now < y) {
now++;
auto ok = lower_bound((down[now]).begin(), (down[now]).end(), start);
if (ok == down[now].end()) continue;
int p = *ok;
while (1) {
auto it = pos.lower_bound(p);
if (*it < now)
pos.erase(it);
else
break;
}
}
int mx = x;
for (int p = (x); (p) < (start + 1); ++p) {
if (p > mx) break;
auto ok = upper_bound((up[p]).begin(), (up[p]).end(), y);
if (ok == up[p].begin()) continue;
ok--;
mx = max(mx, *ok);
}
ans[id] = *pos.lower_bound(mx);
}
}
for (int i = 0; (i) < (qq); ++i) {
cout << ans[i] + 1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
using std::sort;
using std::swap;
using std::vector;
const int maxn = 100017;
int val[maxn << 2], tag[maxn << 2];
int N, M, Q;
int rp[maxn];
struct Query {
int id, x;
};
vector<Query> q[maxn];
int ans[maxn];
struct node {
int mx, sc, tag;
} tree[maxn << 2];
void pushdown(int i) {
if (tree[i].tag == 0) return;
if (tree[(i << 1)].mx > tree[i].sc)
tree[(i << 1)].mx = tree[(i << 1)].tag = tree[i].tag;
if (tree[(i << 1 | 1)].mx > tree[i].sc)
tree[(i << 1 | 1)].mx = tree[(i << 1 | 1)].tag = tree[i].tag;
tree[i].tag = 0;
return;
}
void pushup(int i) {
tree[i].mx = max(tree[(i << 1)].mx, tree[(i << 1 | 1)].mx);
tree[i].sc = max(tree[(i << 1)].sc, tree[(i << 1 | 1)].sc);
if (tree[(i << 1)].mx != tree[(i << 1 | 1)].mx)
tree[i].sc = max(tree[i].sc, min(tree[(i << 1)].mx, tree[(i << 1 | 1)].mx));
return;
}
void update(int L, int R, int l, int r, int li, int ri, int i) {
if (li > tree[i].mx) return;
if (l <= L && R <= r) {
if (li > tree[i].sc)
tree[i].mx = tree[i].tag = ri;
else {
int mid = L + R >> 1;
pushdown(i);
update(L, mid, l, r, li, ri, (i << 1));
update(mid + 1, R, l, r, li, ri, (i << 1 | 1));
pushup(i);
}
} else {
int mid = L + R >> 1;
pushdown(i);
if (l <= mid) update(L, mid, l, r, li, ri, (i << 1));
if (r > mid) update(mid + 1, R, l, r, li, ri, (i << 1 | 1));
pushup(i);
}
return;
}
void update(int L, int R, int x, int i) {
if (L == R) {
tree[i].mx = x;
return;
}
pushdown(i);
int mid = L + R >> 1;
if (x <= mid)
update(L, mid, x, (i << 1));
else
update(mid + 1, R, x, (i << 1 | 1));
return pushup(i);
}
int query(int L, int R, int x, int i) {
if (L == R) return tree[i].mx;
pushdown(i);
int mid = L + R >> 1;
if (x <= mid)
return query(L, mid, x, (i << 1));
else
return query(mid + 1, R, x, (i << 1 | 1));
}
int main() {
scanf("%d%d", &N, &M);
int x, y;
for (int i = 1; i <= M; i++) scanf("%d%d", &x, &y), rp[y] = x;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++)
scanf("%d%d", &x, &y), q[y].push_back((Query){i, x});
for (int i = 1; i <= N; i++) {
update(1, N, i, 1);
if (rp[i]) update(1, N, 1, rp[i], rp[i], i, 1);
for (int k = 0; k < q[i].size(); k++)
ans[q[i][k].id] = query(1, N, q[i][k].x, 1);
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 131072;
const int N = 131072;
const int sq = 5000;
bool mark[maxn];
int n, m, q;
int ar[maxn];
vector<int> Q[maxn];
int seg[maxn * 4];
int x[maxn];
int L[maxn];
int ans[maxn];
void cng(int i, int x) {
ar[i] = x;
i--;
seg[i += N] = x;
for (i >>= 1; i; i >>= 1) seg[i] = max(seg[i << 1], seg[(i << 1) | 1]);
}
int mxr(int l, int r) {
int resL = 0, resR = 0;
l--;
for (l += N, r += N; l < r; l >>= 1, r >>= 1) {
if (l & 1) resL = max(resL, seg[l++]);
if (r & 1) resR = max(seg[--r], resR);
}
return max(resL, resR);
}
int find(int x) {
for (int nex, l = x; 1;) {
nex = mxr(l, x);
if (nex <= x) break;
x = nex;
}
return x;
}
void solve() {
for (int i = 1; i <= n; i++) {
if (~L[i]) cng(L[i], i);
for (int j : Q[i]) ans[j] = find(x[j]);
if (mark[i])
for (int j = i; j > 0; j--)
if (ar[j]) cng(j, max(mxr(j, ar[j]), ar[j]));
}
}
int main() {
for (int i = sq; i < maxn; i += sq) mark[i] = true;
memset(L, -1, sizeof L);
scanf("%d", &n);
scanf("%d", &m);
for (int l, r, i = 0; i < m; i++) {
scanf("%d%d", &l, &r);
L[r] = l;
}
scanf("%d", &q);
for (int y, i = 0; i < q; i++) {
scanf("%d%d", x + i, &y);
Q[y].push_back(i);
}
solve();
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gi() {
char cc = getchar();
int cn = 0, flus = 1;
while (cc < '0' || cc > '9') {
if (cc == '-') flus = -flus;
cc = getchar();
}
while (cc >= '0' && cc <= '9') cn = cn * 10 + cc - '0', cc = getchar();
return cn * flus;
}
const int N = 1e5 + 5;
int n, m, q, L[N];
struct SegmentBeats {
int bef, mx, se, tot, tag;
} tr[N << 2];
void cmax(int &x, int y) { x = (x < y) ? y : x; }
inline void pushup(int x) {
tr[x].tot = tr[x].se = 0,
tr[x].mx = max(tr[(x << 1)].mx, tr[(x << 1 | 1)].mx);
if (tr[x].mx == tr[(x << 1)].mx)
tr[x].tot += tr[(x << 1)].tot, cmax(tr[x].se, tr[(x << 1)].se);
else
cmax(tr[x].se, tr[(x << 1)].mx);
if (tr[x].mx == tr[(x << 1 | 1)].mx)
tr[x].tot += tr[(x << 1 | 1)].tot, cmax(tr[x].se, tr[(x << 1 | 1)].se);
else
cmax(tr[x].se, tr[(x << 1 | 1)].mx);
tr[x].bef = tr[x].mx;
}
inline void push(int x, int k) { tr[x].mx = k, tr[x].tag = k; }
inline void pushmark(int x) {
if (!tr[x].tag) return;
if (tr[(x << 1)].mx == tr[x].bef) push((x << 1), tr[x].tag);
if (tr[(x << 1 | 1)].mx == tr[x].bef) push((x << 1 | 1), tr[x].tag);
tr[x].tag = 0, tr[x].bef = tr[x].mx;
}
int query(int x, int l, int r, int k) {
if (l == r) return tr[x].mx;
int mid = (l + r) >> 1;
pushmark(x);
if (k <= mid)
return query((x << 1), l, mid, k);
else
return query((x << 1 | 1), mid + 1, r, k);
}
void update(int x, int l, int r, int k, int d) {
if (l == r) return tr[x].mx = d, tr[x].se = 0, tr[x].tot = 1, void();
int mid = (l + r) >> 1;
pushmark(x);
if (k <= mid)
update((x << 1), l, mid, k, d);
else
update((x << 1 | 1), mid + 1, r, k, d);
pushup(x);
}
void modify(int x, int l, int r, int ql, int qr, int y, int z) {
if (tr[x].mx < y || r < ql || qr < l) return;
if ((ql <= l && r <= qr) && (tr[x].se < y && tr[x].mx >= y))
return push(x, z);
int mid = (l + r) >> 1;
pushmark(x);
modify((x << 1), l, mid, ql, qr, y, z),
modify((x << 1 | 1), mid + 1, r, ql, qr, y, z), pushup(x);
}
vector<pair<int, int> > p[N];
int ans[N];
signed main() {
n = gi(), m = gi();
int x, y;
for (int i = (1); i <= (m); ++i) x = gi(), y = gi(), L[y] = x;
q = gi();
for (int i = (1); i <= (q); ++i)
x = gi(), y = gi(), p[y].push_back(make_pair(x, i));
for (int i = (1); i <= (n); ++i) {
update(1, 1, n, i, i);
if (L[i]) modify(1, 1, n, 1, L[i], L[i], i);
for (auto u : p[i]) ans[u.second] = query(1, 1, n, u.first);
}
for (int i = (1); i <= (q); ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int block = 320;
const int maxn = 11e4;
int n, m, q, dn[maxn], f[maxn][block], dp[maxn][block];
int prv[maxn];
vector<int> up[maxn];
inline void proc() {
memset((f), (0), sizeof(f));
for (register int(i) = (0); (i) < (maxn); ++(i)) {
for (register int(j) = (0); (j) < (up[i].size()); ++(j))
(f[i][(int)ceil((double)up[i][j] / block)]) =
max((f[i][(int)ceil((double)up[i][j] / block)]), (up[i][j]));
for (register int(j) = (1); (j) < (block); ++(j))
(f[i][j]) = max((f[i][j]), (f[i][j - 1]));
}
for (register int(i) = (block)-1; (i) >= (0); --(i)) {
stack<int> stk;
for (register int(j) = (i * block + 1) - 1; (j) >= (0); --(j)) {
dp[j][i] = f[j][i];
while (stk.size() && dp[j][i] >= stk.top())
(dp[j][i]) = max((dp[j][i]), (dp[stk.top()][i])), stk.pop();
stk.push(j);
}
}
}
int main() {
cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false);
cin >> n >> m;
for (register int(i) = (0); (i) < (maxn); ++(i))
dn[i] = i, up[i].push_back(i);
fill(prv, prv + n, 1ll << 25);
for (register int(i) = (0); (i) < (m); ++(i)) {
int l, r;
cin >> l >> r;
dn[r] = l, up[l].push_back(r);
prv[r - 1] = l - 1;
}
proc();
cin >> q;
while (q--) {
int x, y, res, po;
cin >> x >> y;
if (x / block != y / block)
res = dp[x][y / block], po = y / block * block;
else {
int l = x - 1, r = y, lm, pl;
lm = pl = l;
for (int j = pl + 1; j < r; ++j) {
if (prv[j] <= lm && prv[j] >= l) lm = max(lm, j);
}
cout << lm + 1 << '\n';
continue;
}
while (po++ < y)
if (x <= dn[po] && dn[po] <= res) res = po;
cout << res << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXINT = 100010;
const int MAXNODE = 100010;
const int MAXEDGE = 2 * MAXNODE;
const int MAX_BLOCK = 320;
char BUF, *buf;
int read() {
char c = getchar();
int f = 1, x = 0;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return f * x;
}
char get_ch() {
char c = getchar();
while (!isalpha(c)) c = getchar();
return c;
}
vector<int> to[MAXINT];
int prv[MAXINT], f[MAX_BLOCK][MAXINT], ans[MAX_BLOCK][MAXINT], n, m, q,
sz_b = 317, cnt_b, p[MAXINT];
pair<int, int> stk[MAXINT];
pair<int, int> *tp;
void get_input();
void work();
void pre_calc();
int main() {
get_input();
pre_calc();
work();
return 0;
}
void work() {
for (int i = 0; i < q; ++i) {
int lm, pl;
int l = read() - 1, r = read();
if (r - l > sz_b) {
int b_r = r / sz_b;
if (b_r) {
lm = ans[b_r][l];
pl = b_r * sz_b;
} else {
pl = l;
lm = l;
}
} else {
pl = lm = l;
}
for (int j = pl; j < r; ++j) {
if (prv[j] <= lm && prv[j] >= l) {
lm = (lm > j ? lm : j);
}
}
printf("%d\n", lm + 1);
}
}
void get_input() {
memset(prv, 0x3f3f3f3f, sizeof(prv));
n = read();
m = read();
for (int i = 0; i < m; ++i) {
int u = read() - 1, v = read() - 1;
prv[v] = u;
to[u].push_back(v);
}
q = read();
}
void pre_calc() {
for (int i = 0; i < n; ++i) sort(to[i].begin(), to[i].end());
cnt_b = n / sz_b;
for (int i = 1; i <= cnt_b; ++i) {
for (int j = 0; j < i * sz_b; ++j) {
for (; p[j] < to[j].size() && to[j][p[j]] < i * sz_b; p[j]++)
;
if (p[j])
f[i][j] = to[j][p[j] - 1];
else
f[i][j] = j;
}
}
for (int i = 1; i <= cnt_b; ++i) {
tp = stk;
for (int j = i * sz_b - 1; j >= 0; j--) {
ans[i][j] = f[i][j];
if (tp == stk)
ans[i][j] = j;
else {
while (tp != stk && f[i][j] >= (tp - 1)->first) {
ans[i][j] =
(ans[i][j] > (tp - 1)->second ? ans[i][j] : (tp - 1)->second);
tp--;
}
}
*tp++ = make_pair(j, ans[i][j]);
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma G++ optimize("O2")
using namespace std;
const int N = 111111;
const int M = 666666;
const int MOD = 1e9 + 7;
const int intINF = 1e9;
const long long llINF = 2e18;
const double pi = acos(-1.0);
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
const double eps = 1e-10;
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
long long readll() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
unsigned long long readull() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
vector<pair<int, int> > V[N];
int a[N], n, m, q;
void predo() {}
void init() {
n = read(), m = read();
for (int i = (int)1; i <= (int)m; i++) {
int x = read(), y = read();
a[y] = x;
}
q = read();
for (int i = (int)1; i <= (int)q; i++) {
int x = read(), y = read();
V[y].push_back(make_pair(x, i));
}
}
struct node {
int mx, mx2, tag1, tag2;
} t[N << 2];
void addtag(int p, int s1, int s2) {
{
t[p].mx = s2;
if (!t[p].tag1) t[p].tag1 = s1;
t[p].tag2 = s2;
}
}
void pushdown(int p) {
if (t[p].tag1) {
int mx = max(t[p << 1].mx, t[p << 1 | 1].mx);
if (t[p << 1].mx == mx) addtag(p << 1, t[p].tag1, t[p].tag2);
if (t[p << 1 | 1].mx == mx) addtag(p << 1 | 1, t[p].tag1, t[p].tag2);
t[p].tag1 = t[p].tag2 = 0;
}
}
void fix(int p, int x) {
if (x > t[p].mx) {
t[p].mx2 = t[p].mx;
t[p].mx = x;
} else if (x < t[p].mx && x > t[p].mx2)
t[p].mx2 = x;
}
void pushup(int p) {
t[p].mx = -intINF;
fix(p, t[p << 1].mx);
fix(p, t[p << 1].mx2);
fix(p, t[p << 1 | 1].mx);
fix(p, t[p << 1 | 1].mx2);
}
void update(int l, int r, int x, int y, int s1, int s2, int p) {
if (t[p].mx < s1) return;
if (x <= l && r <= y && t[p].mx2 < s1) {
addtag(p, s1, s2);
return;
}
pushdown(p);
int mid = (l + r) >> 1;
if (x <= mid) update(l, mid, x, y, s1, s2, p << 1);
if (y > mid) update(mid + 1, r, x, y, s1, s2, p << 1 | 1);
pushup(p);
}
int query(int l, int r, int x, int p) {
if (l == r) return t[p].mx;
pushdown(p);
int mid = (l + r) >> 1;
if (x <= mid) return query(l, mid, x, p << 1);
return query(mid + 1, r, x, p << 1 | 1);
}
void build(int l, int r, int p) {
if (l == r) {
t[p].mx = l;
t[p].mx2 = -intINF;
return;
}
int mid = (l + r) >> 1;
build(l, mid, p << 1);
build(mid + 1, r, p << 1 | 1);
pushup(p);
}
int ans[N];
void solve() {
build(1, n, 1);
for (int i = (int)1; i <= (int)n; i++) {
if (a[i]) {
update(1, n, 1, a[i], a[i], i, 1);
}
for (auto t : V[i]) {
ans[t.second] = query(1, n, t.first, 1);
}
}
for (int i = (int)1; i <= (int)q; i++) printf("%d\n", ans[i]);
}
int main() {
predo();
int cas = 1;
while (cas--) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int f = 0;
x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) f |= (ch == '-');
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
if (f) x = -x;
}
const int N = 100005;
int T[N << 2], ans[N], n, m, Q, x, y;
vector<pair<int, int> > q[N];
vector<int> v[N];
void down(int o) {
T[(o << 1)] = min(T[(o << 1)], T[o]);
T[(o << 1 | 1)] = min(T[(o << 1 | 1)], T[o]);
}
void up(int o) { T[o] = max(T[(o << 1)], T[(o << 1 | 1)]); }
void build(int o, int l, int r) {
T[o] = 1e9;
if (l == r) return;
build((o << 1), l, ((l + r) >> 1));
build((o << 1 | 1), ((l + r) >> 1) + 1, r);
}
void upd(int o, int l, int r, int x, int y, int z) {
if (l == x && y == r) {
T[o] = min(T[o], z);
return;
}
down(o);
if (x <= ((l + r) >> 1))
upd((o << 1), l, ((l + r) >> 1), x, min(y, ((l + r) >> 1)), z);
if (((l + r) >> 1) < y)
upd((o << 1 | 1), ((l + r) >> 1) + 1, r, max(((l + r) >> 1) + 1, x), y, z);
up(o);
}
int ask(int o, int l, int r, int p, int lim) {
if (T[o] <= lim) return -1;
if (p <= l) {
for (; l < r;) {
if (T[(o << 1)] <= lim)
l = ((l + r) >> 1) + 1, o = (o << 1 | 1);
else
r = ((l + r) >> 1), o = (o << 1);
}
return l;
}
int tmp = -1;
if (p <= ((l + r) >> 1)) tmp = ask((o << 1), l, ((l + r) >> 1), p, lim);
if (tmp != -1) return tmp;
return ask((o << 1 | 1), ((l + r) >> 1) + 1, r, p, lim);
}
int main() {
read(n), n++, read(m);
for (int i = (1); i <= (m); i++) {
read(x), read(y);
if (x < y) v[x].push_back(y);
}
read(Q);
for (int i = (1); i <= (Q); i++) {
read(x), read(y);
q[x].push_back(make_pair(y, i));
}
build(1, 1, n);
for (int i = (n - 1); i >= (1); i--) {
for (auto x : v[i]) upd(1, 1, n, i, x - 1, x);
for (auto x : q[i]) ans[x.second] = ask(1, 1, n, i, x.first);
}
for (int i = (1); i <= (Q); i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int iinf = 1e9 + 7;
const long long linf = 1ll << 60;
const double dinf = 1e60;
template <typename T>
inline void scf(T &x) {
bool f = 0;
x = 0;
char c = getchar();
while ((c < '0' || c > '9') && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
if (f) x = -x;
return;
}
template <typename T1, typename T2>
void scf(T1 &x, T2 &y) {
scf(x);
return scf(y);
}
template <typename T1, typename T2, typename T3>
void scf(T1 &x, T2 &y, T3 &z) {
scf(x);
scf(y);
return scf(z);
}
template <typename T1, typename T2, typename T3, typename T4>
void scf(T1 &x, T2 &y, T3 &z, T4 &w) {
scf(x);
scf(y);
scf(z);
return scf(w);
}
inline char mygetchar() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
template <typename T>
void chkmax(T &x, const T &y) {
if (y > x) x = y;
return;
}
template <typename T>
void chkmin(T &x, const T &y) {
if (y < x) x = y;
return;
}
void TZL();
void RANK1();
int main() {
TZL();
RANK1();
return 0;
}
const int N = 1e5 + 100;
const int B = 350;
int n, q_n;
int lb[N], rb[N];
int bel[N], ans[N];
int l[N], r[N];
int fst[N], lst[N];
int stk[N], top;
int dp[N];
vector<int> has[N];
void BF(int i) {
int l = ::l[i], r = ::r[i], &ans = ::ans[i];
ans = l;
for (int j = (l), _end_ = (r); j <= _end_; ++j)
if (lb[j] >= l && ans >= lb[j]) ans = j;
return;
}
void TZL() {
scf(n);
for (int i = (1), _end_ = (n); i <= _end_; ++i)
lb[i] = i, bel[i] = (i - 1) / B;
for (int i = (1), _end_ = (n); i <= _end_; ++i) lst[bel[i]] = i;
for (int i = (n), _end_ = (1); i >= _end_; --i) fst[bel[i]] = i;
int e_n;
scf(e_n);
for (int i = 0, _end_ = (e_n); i < _end_; ++i) {
int u, v;
scf(u, v);
lb[v] = u;
}
scf(q_n);
for (int i = (1), _end_ = (q_n); i <= _end_; ++i) {
scf(l[i], r[i]);
if (r[i] - l[i] + 1 <= B)
BF(i);
else
has[bel[r[i]]].push_back(i);
}
return;
}
void RANK1() {
for (int _ = (0), _end_ = (bel[n - 1]); _ <= _end_; ++_)
if ((int)has[_].size()) {
auto &has = ::has[_];
int q = fst[_];
for (int p = (1), _end_ = (q); p <= _end_; ++p) rb[p] = p;
for (int p = (1), _end_ = (q); p <= _end_; ++p) rb[lb[p]] = p;
top = 0;
for (int p = (q), _end_ = (1); p >= _end_; --p) {
int mx = p;
while (top && stk[top - 1] <= rb[p]) chkmax(mx, dp[stk[--top]]);
dp[p] = mx;
while (top && dp[stk[top - 1]] <= dp[p]) --top;
stk[top++] = p;
}
for (int i : has) {
int l = ::l[i], r = ::r[i], &ans = ::ans[i];
ans = dp[l];
for (int j = (q + 1), _end_ = (r); j <= _end_; ++j)
if (lb[j] >= l && lb[j] <= ans) ans = j;
}
}
for (int i = (1), _end_ = (q_n); i <= _end_; ++i) printf("%d\n", ans[i]);
return;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000, maxq = 100000;
int n, m, Q, Ls[maxn + 5], ans[maxq + 5];
vector<pair<int, int>> q[maxn + 5];
int MAX[(maxn << 2) + 5], lst[(maxn << 2) + 5], TA[(maxn << 2) + 5],
TB[(maxn << 2) + 5];
inline void Fix(int p, int x) {
if (x > MAX[p])
lst[p] = MAX[p], MAX[p] = x;
else if (x < MAX[p] && x > lst[p])
lst[p] = x;
}
inline void Pushup(int p) {
MAX[p] = -2e9;
Fix(p, MAX[p << 1]);
Fix(p, lst[p << 1]);
Fix(p, MAX[p << 1 | 1]);
Fix(p, lst[p << 1 | 1]);
}
void Build(int l, int r, int p = 1) {
if (l == r) {
MAX[p] = l;
lst[p] = -2e9;
return;
}
int mid = l + (r - l >> 1);
Build(l, mid, p << 1);
Build(mid + 1, r, p << 1 | 1);
Pushup(p);
}
inline void Addtag(int p, int A, int B) {
if (MAX[p] >= A) {
MAX[p] = B;
if (!TA[p]) TA[p] = A;
TB[p] = B;
}
}
inline void Pushdown(int p) {
if (TA[p])
Addtag(p << 1, TA[p], TB[p]), Addtag(p << 1 | 1, TA[p], TB[p]),
TA[p] = TB[p] = 0;
}
void Insert(int L, int R, int A, int B, int l = 1, int r = n, int p = 1) {
if (MAX[p] < A) return;
if (L == l && r == R && lst[p] < A) return Addtag(p, A, B);
int mid = l + (r - l >> 1);
Pushdown(p);
if (R <= mid)
Insert(L, R, A, B, l, mid, p << 1);
else if (L > mid)
Insert(L, R, A, B, mid + 1, r, p << 1 | 1);
else
Insert(L, mid, A, B, l, mid, p << 1),
Insert(mid + 1, R, A, B, mid + 1, r, p << 1 | 1);
Pushup(p);
}
int Ask(int pos, int l = 1, int r = n, int p = 1) {
if (l == r) return MAX[p];
int mid = l + (r - l >> 1);
Pushdown(p);
if (pos <= mid) return Ask(pos, l, mid, p << 1);
return Ask(pos, mid + 1, r, p << 1 | 1);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; i++) scanf("%d%d", &x, &y), Ls[y] = x;
scanf("%d", &Q);
for (int i = 1, x, y; i <= Q; i++)
scanf("%d%d", &x, &y), q[y].push_back(make_pair(x, i));
for (int i = (Build(1, n), 1); i <= n; i++) {
if (Ls[i]) Insert(1, Ls[i], Ls[i], i);
for (int si = q[i].size(), j = 0; j < si; j++)
ans[q[i][j].second] = Ask(q[i][j].first);
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int BS = 100;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int>> go(n), og(n);
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
--l;
--r;
go[l].push_back(r);
og[r].push_back(l);
}
for (int i = 0; i < n; ++i) sort(go[i].begin(), go[i].end());
int q;
cin >> q;
vector<tuple<int, int, int, int>> qrs;
for (int i = 0; i < q; ++i) {
int l, r;
cin >> l >> r;
--l;
--r;
qrs.emplace_back((l + BS - 1) / BS, r, l, i);
}
sort(qrs.begin(), qrs.end());
auto one_step = [&](int i, int r) {
auto it = upper_bound(go[i].begin(), go[i].end(), r);
if (it == go[i].begin()) return i;
return *(--it);
};
vector<int> ans(q);
int pbi = -1, pr = -1;
vector<int> stk;
for (auto [bi, r, l, i] : qrs) {
if (r - l <= BS) {
int at = l;
for (int j = l; j <= at; ++j) at = max(at, one_step(j, r));
ans[i] = at;
} else {
int split = bi * BS;
assert(split < r);
if (bi != pbi) {
stk.clear();
pr = split - 1;
pbi = bi;
}
while (pr < r) {
++pr;
int lowest = pr;
for (auto lp : og[pr])
if (lp >= split) lowest = min(lowest, lp);
while (stk.size() && stk.back() >= lowest) stk.pop_back();
stk.push_back(pr);
}
int at = l;
for (int j = l; j <= at && j < split; ++j) at = max(at, one_step(j, r));
if (at < split) {
ans[i] = at;
} else {
auto it = lower_bound(stk.begin(), stk.end(), at);
ans[i] = *it;
}
}
}
for (int i = 0; i < q; ++i) cout << ans[i] + 1 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
vector<pair<int, int> > qes[N];
int n, m, q, f[N << 2], g[N << 2], link[N], ans[N];
void upd(int rt, int x, int y) {
if (!f[rt])
f[rt] = x, g[rt] = y;
else if (x <= g[rt])
f[rt] = min(x, f[rt]), g[rt] = y;
}
void down(int rt) {
if (!f[rt]) return;
upd(rt << 1, f[rt], g[rt]);
upd(rt << 1 | 1, f[rt], g[rt]);
f[rt] = 0;
}
void update(int rt, int l, int r, int L, int R, int x, int y) {
if (l >= L && r <= R) {
upd(rt, x, y);
return;
}
down(rt);
if (L <= ((l + r) >> 1)) update(rt << 1, l, ((l + r) >> 1), L, R, x, y);
if (R > ((l + r) >> 1))
update(rt << 1 | 1, ((l + r) >> 1) + 1, r, L, R, x, y);
}
int query(int rt, int l, int r, int p) {
if (l == r) {
if (f[rt] && f[rt] <= l)
return g[rt];
else
return l;
}
down(rt);
if (p <= ((l + r) >> 1))
return query(rt << 1, l, ((l + r) >> 1), p);
else
return query(rt << 1 | 1, ((l + r) >> 1) + 1, r, p);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
link[r] = l;
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
qes[r].push_back(make_pair(l, i));
}
for (int i = 1; i <= n; i++) {
if (link[i]) update(1, 1, n, 1, link[i], link[i], i);
for (int j = 0; j <= ((int)(qes[i]).size()) - 1; j++)
ans[qes[i][j].second] = query(1, 1, n, qes[i][j].first);
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma G++ optimize("O2")
using namespace std;
const int N = 111111;
const int M = 666666;
const int MOD = 1e9 + 7;
const int intINF = 1e9;
const long long llINF = 2e18;
const double pi = acos(-1.0);
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
const double eps = 1e-10;
int read() {
int v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
long long readll() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
unsigned long long readull() {
long long v = 0, f = 1;
char c = getchar();
while (c < 48 || 57 < c) {
if (c == '-') f = -1;
c = getchar();
}
while (48 <= c && c <= 57) v = (v << 3) + v + v + c - 48, c = getchar();
return v * f;
}
vector<pair<int, int> > V[N];
int a[N], n, m, q;
void predo() {}
void init() {
n = read(), m = read();
for (int i = (int)1; i <= (int)m; i++) {
int x = read(), y = read();
a[y] = x;
}
q = read();
for (int i = (int)1; i <= (int)q; i++) {
int x = read(), y = read();
V[y].push_back(make_pair(x, i));
}
}
struct node {
int mx, mx2, tag1, tag2;
} t[N << 2];
void addtag(int p, int s1, int s2) {
if (t[p].mx >= s1) {
t[p].mx = s2;
if (!t[p].tag1) t[p].tag1 = s1;
t[p].tag2 = s2;
}
}
void pushdown(int p) {
if (t[p].tag1) {
addtag(p << 1, t[p].tag1, t[p].tag2);
addtag(p << 1 | 1, t[p].tag1, t[p].tag2);
t[p].tag1 = t[p].tag2 = 0;
}
}
void fix(int p, int x) {
if (x > t[p].mx) {
t[p].mx2 = t[p].mx;
t[p].mx = x;
} else if (x < t[p].mx && x > t[p].mx2)
t[p].mx2 = x;
}
void pushup(int p) {
t[p].mx = -intINF;
fix(p, t[p << 1].mx);
fix(p, t[p << 1].mx2);
fix(p, t[p << 1 | 1].mx);
fix(p, t[p << 1 | 1].mx2);
}
void update(int l, int r, int x, int y, int s1, int s2, int p) {
if (t[p].mx < s1) return;
if (l == x && r == y && t[p].mx2 < s1) {
addtag(p, s1, s2);
return;
}
pushdown(p);
int mid = (l + r) >> 1;
if (y <= mid)
update(l, mid, x, y, s1, s2, p << 1);
else if (x > mid)
update(mid + 1, r, x, y, s1, s2, p << 1 | 1);
else {
update(l, mid, x, mid, s1, s2, p << 1);
update(mid + 1, r, mid + 1, y, s1, s2, p << 1 | 1);
}
pushup(p);
}
int query(int l, int r, int x, int p) {
if (l == r) return t[p].mx;
pushdown(p);
int mid = (l + r) >> 1;
if (x <= mid) return query(l, mid, x, p << 1);
return query(mid + 1, r, x, p << 1 | 1);
}
void build(int l, int r, int p) {
if (l == r) {
t[p].mx = l;
t[p].mx2 = -intINF;
return;
}
int mid = (l + r) >> 1;
build(l, mid, p << 1);
build(mid + 1, r, p << 1 | 1);
pushup(p);
}
int ans[N];
void solve() {
build(1, n, 1);
for (int i = (int)1; i <= (int)n; i++) {
if (a[i]) {
update(1, n, 1, a[i], a[i], i, 1);
}
for (auto t : V[i]) {
ans[t.second] = query(1, n, t.first, 1);
}
}
for (int i = (int)1; i <= (int)q; i++) printf("%d\n", ans[i]);
}
int main() {
predo();
int cas = 1;
while (cas--) {
init();
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool smin(T &a, const T &b) {
return a > b ? a = b : a;
}
template <typename T>
inline bool smax(T &a, const T &b) {
return a < b ? a = b : a;
}
const int N = (int)1e5 + 505, sq = 350, mod = (int)0;
int res[N], o[N], ql[N], qr[N], askx[N], asky[N], to_see[N], par[sq + 10][N],
cnt[sq + 10], val[sq + 10][N];
vector<int> sizes[sq + 10], ind[sq + 10];
int find(int v, int par[N]) {
return v == par[v] ? v : par[v] = find(par[v], par);
}
int by_y(int first, int second) { return asky[first] < asky[second]; }
int main() {
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
memset(to_see, -1, sizeof to_see);
for (int j = 0; j < m; ++j) {
cin >> ql[j] >> qr[j];
--ql[j], --qr[j];
to_see[qr[j]] = j;
}
int q;
cin >> q;
for (int j = 0; j < q; ++j) {
cin >> askx[j] >> asky[j];
--askx[j];
--asky[j];
o[j] = j;
}
for (int j = 0; j < sq; ++j) {
cnt[j] = sq + 1;
}
sort(o, o + q, by_y);
int pt = 0;
for (int j = 0; j < n; ++j) {
int id = j - j / sq * sq;
val[j / sq][id] = j;
par[j / sq][id] = id;
sizes[j / sq].push_back(j);
ind[j / sq].push_back(id);
if (to_see[j] != -1) {
int l = ql[to_see[j]];
for (int g = 0; g < l / sq; ++g) {
while (sizes[g].size() && sizes[g].back() >= l) {
par[g][ind[g].back()] = cnt[g];
sizes[g].pop_back();
ind[g].pop_back();
}
val[g][cnt[g]] = j;
sizes[g].push_back(j);
par[g][cnt[g]] = cnt[g];
ind[g].push_back(cnt[g]);
++cnt[g];
}
for (int first = l / sq * sq; first <= l; ++first) {
int g = l / sq;
if (val[g][find(first - first / sq * sq, par[g])] >= l) {
par[g][first - first / sq * sq] = cnt[g];
}
}
int g = l / sq;
val[g][cnt[g]] = j;
par[g][cnt[g]] = cnt[g];
sizes[g].push_back(j);
ind[g].push_back(cnt[g]);
++cnt[g];
}
while (pt < q && asky[o[pt]] == j) {
int i = askx[o[pt]], id = o[pt];
res[id] = val[i / sq][find(i - i / sq * sq, par[i / sq])] + 1;
++pt;
}
}
for (int j = 0; j < q; ++j) cout << res[j] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
int n, q, from[MAXN], tl[MAXN], tr[MAXN], ans[MAXN], sec[MAXN];
pair<int, int> weed[MAXN << 2];
bool cmp(int q1, int q2) { return tr[q1] < tr[q2]; }
void plant(int v, int b, int e) {
if (e - b == 1) {
weed[v] = {b, b};
return;
}
int mid = b + e >> 1;
plant(v << 1, b, mid);
plant(v << 1 ^ 1, mid, e);
weed[v] = max(weed[v << 1], weed[v << 1 ^ 1]);
}
void water(int v, int b, int e, int pos, int val) {
if (e - b == 1) {
weed[v].first = val;
return;
}
int mid = b + e >> 1;
if (pos < mid)
water(v << 1, b, mid, pos, val);
else
water(v << 1 ^ 1, mid, e, pos, val);
weed[v] = max(weed[v << 1], weed[v << 1 ^ 1]);
}
int getVal(int v, int b, int e, int pos) {
if (e - b == 1) return weed[v].first;
int mid = b + e >> 1;
if (pos < mid) return getVal(v << 1, b, mid, pos);
return getVal(v << 1 ^ 1, mid, e, pos);
}
pair<int, int> smoke(int v, int b, int e, int l, int r) {
if (l <= b && e <= r) return weed[v];
if (r <= b || e <= l) return {-1, -1};
int mid = b + e >> 1;
return max(smoke(v << 1, b, mid, l, r), smoke(v << 1 ^ 1, mid, e, l, r));
}
int getPar(int v) {
int r = getVal(1, 0, n, v);
if (r == v) return r;
auto x = smoke(1, 0, n, v + 1, r + 1);
if (x.first <= r) return r;
int ret = getPar(x.second);
water(1, 0, n, v, ret);
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int m;
cin >> m;
memset(from, -1, sizeof(from));
while (m--) {
int l, r;
cin >> l >> r, l--, r--;
if (l ^ r) from[r] = l;
}
plant(1, 0, n);
cin >> q;
for (int i = 0; i < q; i++) cin >> tl[i] >> tr[i], tl[i]--;
iota(sec, sec + q, 0);
sort(sec, sec + q, cmp);
int cur = 0;
for (int i = 0; i < n; i++) {
if (~from[i]) water(1, 0, n, from[i], i);
while (cur < q && tr[sec[cur]] == i + 1) {
int v = tl[sec[cur]];
ans[sec[cur++]] = getPar(v) + 1;
}
}
for (int i = 0; i < q; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 2e5 + 10;
int n;
vector<pair<int, int> > M[Max * 4];
vector<pair<int, int> > out[Max * 4];
vector<int> pmn[Max * 4];
vector<pair<int, int> > ropes[Max];
void build(int tl = 1, int tr = n + 1, int idx = 1) {
if (tr - tl == 1) {
M[idx].push_back(make_pair(tl, tl));
out[idx] = ropes[tl];
for (int i = 0; i < out[idx].size(); i++) pmn[idx].push_back(tl);
for (int i = 0; i < out[idx].size(); i++) {
if (i == 0)
pmn[idx].push_back(out[idx][i].first);
else
pmn[idx].push_back(min(pmn[idx].back(), out[idx][i].first));
}
return;
}
int mid = (tl + tr) / 2;
build(tl, mid, idx * 2);
build(mid, tr, idx * 2 + 1);
int mnl = 1000000, mxr = 0;
{
auto& L = out[idx * 2];
auto& R = out[idx * 2 + 1];
auto p1 = L.begin(), p2 = R.begin();
while (p1 != L.end() || p2 != R.end()) {
if (p1 == L.end())
out[idx].push_back(*(p2++));
else if (p2 == R.end()) {
if (p1->second >= tr)
out[idx].push_back(*(p1++));
else {
mnl = min(mnl, p1->first);
mxr = max(mxr, (p1++)->second);
}
} else if (p1->second < p2->second) {
if (p1->second >= tr)
out[idx].push_back(*(p1++));
else {
mnl = min(mnl, p1->first);
mxr = max(mxr, (p1++)->second);
}
} else
out[idx].push_back(*(p2++));
}
}
for (int i = 0; i < out[idx].size(); i++) {
if (i == 0)
pmn[idx].push_back(out[idx][i].first);
else
pmn[idx].push_back(min(pmn[idx].back(), out[idx][i].first));
}
{
auto& L = M[idx * 2];
auto& R = M[idx * 2 + 1];
int mrgL = 1000000;
for (int i = 0; i < L.size(); i++)
if (L[i].second >= mnl)
mrgL = min(mrgL, L[i].first);
else
M[idx].push_back(L[i]);
for (int i = 0; i < R.size(); i++)
if (R[i].first <= mxr)
if (R[i].second >= mxr)
M[idx].push_back(make_pair(mrgL, R[i].second));
else
;
else
M[idx].push_back(R[i]);
}
}
void LOG(int tl = 1, int tr = n + 1, int idx = 1) {
if (tr - tl != 1) {
int mid = (tl + tr) / 2;
LOG(tl, mid, idx * 2);
LOG(mid, tr, idx * 2 + 1);
}
cout << tl << ',' << tr << " :\n";
cout << "M : ";
for (auto x : M[idx]) cout << x.first << ',' << x.second << ' ';
cout << "\nout : ";
for (auto x : out[idx]) cout << x.first << ',' << x.second << ' ';
cout << "\npmn : ";
for (auto x : pmn[idx]) cout << x << ' ';
cout << "\n\n";
}
vector<int> IMP;
void get(int l, int r, int tl = 1, int tr = n + 1, int idx = 1) {
if (l <= tl && tr <= r) {
IMP.push_back(idx);
return;
}
if (r <= tl || tr <= l) return;
int mid = (tl + tr) / 2;
get(l, r, tl, mid, idx * 2);
get(l, r, mid, tr, idx * 2 + 1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
if (r != l) ropes[l].push_back(make_pair(l, r));
}
for (int i = 1; i <= n; i++) sort(ropes[i].begin(), ropes[i].end());
build();
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
IMP.clear();
get(l, r + 1);
int ans = l;
for (int idx = 0; idx < IMP.size(); idx++) {
int i = IMP[idx];
if (ans > M[i].back().second) {
int x = out[i].size(), y = -1;
while (x - y > 1) {
int mid = (x + y) / 2;
if (out[i][mid].second <= r)
y = mid;
else
x = mid;
}
if (y != -1) ans = max(ans, out[i][y].second);
continue;
}
auto baze =
upper_bound(M[i].begin(), M[i].end(), make_pair(ans, 1000000));
baze--;
ans = baze->second;
if (out[i].size() == 0 || out[i][0].second > r) break;
int x = out[i].size(), y = 0;
while (x - y > 1) {
int mid = (x + y) / 2;
if (out[i][mid].second <= r)
y = mid;
else
x = mid;
}
int mnl = pmn[i][y];
if (mnl <= ans)
ans = out[i][y].second;
else
break;
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
int f = 0;
for (; !isdigit(c); c = getchar()) f |= c == '-';
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ '0');
if (f) x = -x;
}
template <typename T>
void write(T x, char ed = '\n') {
if (x < 0) putchar('-'), x = -x;
static short st[30], tp;
do st[++tp] = x % 10, x /= 10;
while (x);
while (tp) putchar(st[tp--] | '0');
putchar(ed);
}
template <typename T>
inline void Mx(T &x, T y) {
if (x < y) x = y;
}
template <typename T>
inline void Mn(T &x, T y) {
if (x > y) x = y;
}
const int N = 100005;
vector<int> vec[N << 2], mn[N << 2], dp[N << 2];
int vis[N], ne[N << 1], to[N << 1], fr[N], h[N], tot, n, m, q;
inline void adde(int x, int y) { ne[++tot] = h[x], to[h[x] = tot] = y; }
void build(int p, int l, int r) {
int mid = (l + r) >> 1;
if (l != r) build(p << 1, l, mid), build(p << 1 | 1, mid + 1, r);
dp[p].resize(r - l + 1);
for (int i = l; i <= r; ++i) vis[i] = 0;
for (int i = r; i >= l; --i) {
Mx(dp[p][i - l], i), vis[i] = 1;
if (fr[i] >= l) {
int t = fr[i];
while (!vis[t]) vis[t] = 1, dp[p][t - l] = dp[p][i - l], ++t;
}
}
mn[p].resize(r - l + 1);
for (int i = l; i <= r; ++i) {
mn[p][i - l] = n + 1;
if (i != l) mn[p][i - l] = mn[p][i - l - 1];
for (int t = h[i]; t; t = ne[t])
if (to[t] > r) Mn(mn[p][i - l], to[t]), vec[p].push_back(to[t]);
}
sort(vec[p].begin(), vec[p].end());
}
int Far;
void query(int p, int l, int r, int L, int R) {
if (Far < l) return;
if (L <= l && r <= R) {
if (Far < r) {
Far = dp[p][Far - l];
if (mn[p][Far - l] <= R) Far = r;
}
if (Far >= r && vec[p].size()) {
int t = upper_bound(vec[p].begin(), vec[p].end(), R) - vec[p].begin();
if (t) --t;
if (vec[p][t] <= R) Mx(Far, vec[p][t]);
}
return;
}
int mid = (l + r) >> 1;
if (L <= mid) query(p << 1, l, mid, L, R);
if (R > mid) query(p << 1 | 1, mid + 1, r, L, R);
}
int main() {
read(n), read(m);
for (int i = 1, a, b; i <= m; ++i) read(a), read(b), fr[b] = a, adde(a, b);
build(1, 1, n), read(q);
for (int i = 1, l, r; i <= q; ++i)
read(l), read(r), Far = l, query(1, 1, n, l, r), write(Far);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline void read(int &x) {
char c = nc(), b = 1;
for (; !(c >= '0' && c <= '9'); c = nc())
if (c == '-') b = -1;
for (x = 0; c >= '0' && c <= '9'; x = x * 10 + c - '0', c = nc())
;
x *= b;
}
const int N = 100005;
int T[N << 2], R[N << 2], F[N << 2], G[N << 2];
inline void mark(int x, int a, int b) {
if (T[x] >= a) {
T[x] = b;
F[x] = b;
if (!G[x] || G[x] > a) G[x] = a;
}
}
inline void calc(int &x, int &y, int &z) {
if (z > x)
y = x, x = z;
else if (z < x && z > y)
y = z;
}
inline void upd(int x) {
T[x] = R[x] = -1 << 30;
calc(T[x], R[x], T[x << 1]);
calc(T[x], R[x], R[x << 1]);
calc(T[x], R[x], T[x << 1 | 1]);
calc(T[x], R[x], R[x << 1 | 1]);
}
inline void push(int x) {
if (F[x]) {
mark(x << 1, G[x], F[x]);
mark(x << 1 | 1, G[x], F[x]);
F[x] = 0;
G[x] = 0;
}
}
inline void Build(int x, int l, int r) {
if (l == r) {
T[x] = l;
R[x] = -1 << 30;
return;
}
int mid = (l + r) >> 1;
Build(x << 1, l, mid);
Build(x << 1 | 1, mid + 1, r);
upd(x);
}
inline void Modify(int x, int l, int r, int ql, int qr, int a, int b) {
if (T[x] < a) return;
if (ql <= l && r <= qr && R[x] < a) {
mark(x, a, b);
return;
}
push(x);
int mid = (l + r) >> 1;
if (ql <= mid) Modify(x << 1, l, mid, ql, qr, a, b);
if (qr > mid) Modify(x << 1 | 1, mid + 1, r, ql, qr, a, b);
upd(x);
}
inline int Query(int x, int l, int r, int t) {
if (l == r) return T[x];
push(x);
int mid = (l + r) >> 1;
if (t <= mid)
return Query(x << 1, l, mid, t);
else
return Query(x << 1 | 1, mid + 1, r, t);
}
int n, m, pos[N];
int ans[N];
struct abcd {
int l, r, idx;
bool operator<(const abcd &B) const { return r < B.r; }
} que[N];
int main() {
int l, r;
read(n);
read(m);
for (int i = 1; i <= m; i++) read(l), read(r), pos[r] = l;
int Q;
read(Q);
for (int i = 1; i <= Q; i++) {
read(que[i].l);
read(que[i].r);
que[i].idx = i;
}
sort(que + 1, que + Q + 1);
int pnt = 1;
Build(1, 1, n);
for (int i = 1; i <= n; i++) {
if (pos[i]) Modify(1, 1, n, 1, pos[i], pos[i], i);
while (pnt <= Q && que[pnt].r == i)
ans[que[pnt].idx] = Query(1, 1, n, que[pnt].l), pnt++;
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.