text stringlengths 49 983k |
|---|
#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 oo = 0x3f3f3f3f;
const double eps = 1e-9;
int seg_trees[400400];
int bases[400400];
int left_child(int id) { return id * 2 + 1; }
int get_mid(int f, int t) {
assert(t - f > 1);
return f + (t - f) / 2;
}
void insert_segtree(int id, int from, int to, int maxh, int base) {
while (true) {
if (maxh > seg_trees[id]) {
bases[id] = base;
seg_trees[id] = maxh;
}
if (from == base && to == base + 1) {
return;
} else {
int m = get_mid(from, to);
id = left_child(id);
if (base < m) {
to = m;
} else {
from = m;
id++;
}
}
}
}
void insert_segtree(int maxh, int base) {
insert_segtree(0, 0, 100100, maxh, base);
}
pair<long long, long long> query(int id, int from, int to, int f, int t) {
f = max(f, from);
t = min(t, to);
if (f >= t) return make_pair(-oo, -oo);
if (from == f && t == to) return make_pair(seg_trees[id], bases[id]);
int m = get_mid(from, to);
int c = left_child(id);
auto a = query(c, from, m, f, t);
auto b = query(c + 1, m, to, f, t);
return max(a, b);
}
pair<long long, long long> query(int f, int t) {
return query(0, 0, 100100, f, t);
}
long long get_res(int f) {
int t = f;
stack<pair<long long, long long> > todo;
while (true) {
auto nn = query(f, t + 1);
if (nn.first > t) {
todo.push(make_pair(f, t));
f = nn.second;
t = nn.first;
} else {
break;
}
}
while (!todo.empty()) {
auto nn = todo.top();
if (rand() % int((todo).size()) == 0) {
insert_segtree(t, nn.first);
}
todo.pop();
}
return t;
}
pair<int, int> queries[100100];
unordered_map<int, int> mem[100100];
pair<int, int> squeries[100100];
int main() {
ios::sync_with_stdio(false);
int N, M, Q;
cin >> N >> M;
vector<pair<int, int> > ropes(M);
for (int i = (0); i < (M); i++) cin >> ropes[i].second >> ropes[i].first;
sort((ropes).begin(), (ropes).end());
cin >> Q;
for (int i = (0); i < (Q); i++) cin >> queries[i].second >> queries[i].first;
for (int i = (0); i < (Q); i++) squeries[i] = queries[i];
sort(squeries, squeries + Q);
int A = 0;
for (int i = (0); i < (Q); i++) {
while (A < M && squeries[i].first >= ropes[A].first) {
insert_segtree(ropes[A].first, ropes[A].second);
A++;
}
mem[squeries[i].first][squeries[i].second] = get_res(squeries[i].second);
}
for (int i = (0); i < (Q); i++)
cout << mem[queries[i].first][queries[i].second] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, pos = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') pos = 0;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
return pos ? x : -x;
}
const int N = 2e5 + 200;
struct node {
int l, r, id;
} p[N];
int cmp(node a, node b) { return a.r < b.r; }
pair<int, int> d[N * 2], tag[N * 2];
vector<int> G[N];
int f[112][N], g[N];
int c[N], B, maxr, n, m;
int tmp[10];
void pushup(int now) {
tmp[0] = d[now << 1].first, tmp[1] = d[now << 1].second;
tmp[2] = d[now << 1 | 1].first;
tmp[3] = d[now << 1 | 1].second;
sort(tmp, tmp + 4);
d[now].first = tmp[3];
d[now].second = tmp[2] == tmp[3] ? tmp[1] : tmp[2];
}
void pusht(int now, pair<int, int> w) {
if (d[now].first >= w.first) {
d[now].first = w.second;
if (!tag[now].first) {
tag[now].first = w.first;
} else
tag[now].first = min(tag[now].first, w.first);
tag[now].second = w.second;
}
}
void pushdown(int now) {
if (tag[now].first) {
pusht(now << 1, tag[now]);
pusht(now << 1 | 1, tag[now]);
tag[now] = make_pair(0, 0);
}
}
void modify(int now, int l, int r, int ql, int qr, pair<int, int> w) {
if (d[now].first < w.first) return;
if (ql <= l && r <= qr && d[now].second < w.first) {
pusht(now, w);
return;
}
int mid = (l + r) >> 1;
pushdown(now);
if (ql <= mid) modify(now << 1, l, mid, ql, qr, w);
if (mid < qr) modify(now << 1 | 1, mid + 1, r, ql, qr, w);
pushup(now);
}
int query(int now, int l, int r, int pos) {
if (l == r) {
return d[now].first;
}
int mid = (l + r) >> 1;
pushdown(now);
if (pos <= mid)
return query(now << 1, l, mid, pos);
else
return query(now << 1 | 1, mid + 1, r, pos);
}
void build(int now, int l, int r) {
if (l == r) {
d[now].first = l;
d[now].second = -1e9;
return;
}
int mid = (l + r) >> 1;
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
pushup(now);
}
int ans[N];
int main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
int x = read(), y = read();
g[y] = x;
}
int q = read();
for (int i = 1; i <= q; ++i) {
p[i].l = read(), p[i].r = read(), p[i].id = i;
}
sort(p + 1, p + q + 1, cmp);
int pos = 0;
build(1, 1, n);
for (int i = 1; i <= n; ++i) {
if (g[i]) {
modify(1, 1, n, 1, g[i], make_pair(g[i], i));
}
while (pos + 1 <= q && p[pos + 1].r <= i) {
pos++;
ans[p[pos].id] = query(1, 1, n, p[pos].l);
}
}
for (int i = 1; i <= q; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 10, MN = 1e5 + 10;
int n, m, q;
vector<pair<int, int> > qr[MN];
int rope[MN], ans[MN];
pair<int, int> seg[MN << 2];
void build(int id, int b, int e) {
if (e - b == 1) {
seg[id] = {b, b};
return;
}
int mid = b + e >> 1;
build(id << 1, b, mid), build(id << 1 | 1, mid, e);
seg[id] = max(seg[id << 1], seg[id << 1 | 1]);
}
void upd(int id, int b, int e, int p, int val) {
if (e - b == 1) {
seg[id].first = val;
return;
}
int mid = b + e >> 1;
if (p < mid)
upd(id << 1, b, mid, p, val);
else
upd(id << 1 | 1, mid, e, p, val);
seg[id] = max(seg[id << 1], seg[id << 1 | 1]);
}
int get2(int id, int b, int e, int p) {
if (e - b == 1) return seg[id].first;
int mid = b + e >> 1;
if (p < mid)
return get2(id << 1, b, mid, p);
else
return get2(id << 1 | 1, mid, e, p);
}
pair<int, int> get3(int id, int b, int e, int l, int r) {
if (r <= b || e <= l) return {-1, -1};
if (l <= b && e <= r) return seg[id];
int mid = b + e >> 1;
return max(get3(id << 1, b, mid, l, r), get3(id << 1 | 1, mid, e, l, r));
}
int get(int l) {
int r = get2(1, 0, n, l);
if (r == l) return r;
pair<int, int> M = get3(1, 0, n, l + 1, r + 1);
if (M.first <= r) return r;
r = get(M.second);
upd(1, 0, n, l, r);
return r;
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
memset(rope, -1, sizeof rope);
while (m--) {
int l, r;
cin >> l >> r;
--l, --r;
if (l != r) rope[r] = l;
}
cin >> q;
for (int i = 0; i < q; ++i) {
int x, y;
cin >> x >> y;
--x, --y;
qr[y].push_back({x, i});
}
build(1, 0, n);
for (int i = 0; i < n; ++i) {
if (~rope[i]) upd(1, 0, n, rope[i], i);
for (auto x : qr[i]) {
int id = x.second, l = x.first;
ans[id] = get(l) + 1;
}
}
for (int i = 0; i < q; ++i) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 201110, T = 510;
struct Quer {
int l, r, id;
} quer[N];
int s[N], DP[N], P[N], res[N];
vector<int> G[N];
int n, m, Q;
bool comp(Quer u, Quer v) { return u.r < v.r; }
void update(int x, int v) {
for (; x <= n; x += x & -x) s[x] = max(s[x], v);
}
int getMax(int x) {
int ans = 0;
for (; x > 0; x -= x & -x) ans = max(ans, s[x]);
return ans;
}
void reset(int k) {
memset(s, 0, sizeof(s));
update(k, k);
for (int u = k - 1; u >= 1; u--) {
DP[u] = u;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v <= k) DP[u] = max(DP[u], getMax(v));
}
update(u, DP[u]);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) P[i] = i;
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
P[v] = u;
G[u].push_back(v);
}
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d%d", &quer[i].l, &quer[i].r);
quer[i].id = i;
}
sort(quer + 1, quer + Q + 1, comp);
int k = 0;
for (int i = 1; i <= n; i++) DP[i] = i;
for (int i = 1; i <= Q; i++) {
while (k < quer[i].r) {
k++;
if (k % T == 0) reset(k);
}
res[quer[i].id] = DP[quer[i].l];
for (int j = (k / T) * T + 1; j <= quer[i].r; j++)
if (P[j] >= quer[i].l && P[j] <= res[quer[i].id]) res[quer[i].id] = j;
}
for (int i = 1; i <= Q; i++) printf("%d\n", res[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 77, inf = 1000000000 + 77;
int n, m, q;
int A[N], lz[N << 2], Mx[N << 2];
vector<int> V[N];
vector<pair<int, int> > Q[N];
inline void Shift(int l, int r, int id) {
int x = lz[id];
if (x == inf) return;
lz[id] = inf;
Mx[id] = min(Mx[id], x);
if (r - l > 1)
lz[id << 1] = min(lz[id << 1], x),
lz[id << 1 ^ 1] = min(lz[id << 1 ^ 1], x);
}
void Update(int ql, int qr, int x, int l = 1, int r = n + 1, int id = 1) {
Shift(l, r, id);
if (qr <= l || r <= ql) return;
if (ql <= l && r <= qr) {
lz[id] = x;
Shift(l, r, id);
return;
}
int mid = ((l + r) >> 1);
Update(ql, qr, x, l, mid, id << 1);
Update(ql, qr, x, mid, r, id << 1 ^ 1);
Mx[id] = max(Mx[id << 1], Mx[id << 1 ^ 1]);
}
pair<int, int> Get(int ql, int x, int l = 1, int r = n + 1, int id = 1) {
Shift(l, r, id);
if (Mx[id] <= x || r <= ql) return make_pair(-1, -1);
if (r - l < 2) return make_pair(l, Mx[id]);
int mid = ((l + r) >> 1);
if (ql <= l) {
Shift(l, mid, id << 1);
Shift(mid, r, id << 1 ^ 1);
if (Mx[id << 1] > x) return Get(ql, x, l, mid, id << 1);
return Get(ql, x, mid, r, id << 1 ^ 1);
}
pair<int, int> t = Get(ql, x, l, mid, id << 1);
if (t.second <= x || t.first < ql) return Get(ql, x, mid, r, id << 1 ^ 1);
return t;
}
int main() {
fill(lz, lz + (N << 2), inf);
fill(Mx, Mx + (N << 2), inf);
scanf("%d %d", &n, &m);
for (int x, y, i = 1; i <= m; ++i) scanf("%d %d", &x, &y), V[x].push_back(y);
scanf("%d", &q);
for (int x, y, i = 1; i <= q; ++i)
scanf("%d %d", &x, &y), Q[x].push_back(make_pair(y, i));
for (int i = n; i > 0; --i) {
for (int x : V[i]) Update(i, x, x);
for (pair<int, int> x : Q[i])
A[x.second] = min(x.first, Get(i, x.first).first);
}
for (int i = 1; i <= q; ++i) printf("%d\n", A[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, Q, ans[100005], t[265000];
vector<int> v[100005];
vector<pair<int, int> > vq[100005];
void build(int k, int l, int r) {
t[k] = 1e9;
if (l == r) return;
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
}
void pushdown(int k) {
t[k * 2] = min(t[k * 2], t[k]);
t[k * 2 + 1] = min(t[k * 2 + 1], t[k]);
}
void change(int k, int l, int r, int x, int y, int v) {
if (t[k] <= v) return;
if (l == x && r == y) {
t[k] = v;
return;
}
int mid = (l + r) / 2;
pushdown(k);
if (y <= mid)
change(k * 2, l, mid, x, y, v);
else if (x > mid)
change(k * 2 + 1, mid + 1, r, x, y, v);
else
change(k * 2, l, mid, x, mid, v),
change(k * 2 + 1, mid + 1, r, mid + 1, y, v);
t[k] = max(t[k * 2], t[k * 2 + 1]);
}
int ask(int k, int l, int r, int p, int v) {
if (t[k] <= v) return -1;
if (p <= l) {
for (; l < r;) {
int mid = (l + r) / 2;
pushdown(k);
k *= 2;
if (t[k] > v)
r = mid;
else
l = mid + 1, k++;
}
return l;
}
int mid = (l + r) / 2;
int tmp = -1;
if (p <= mid) tmp = ask(k * 2, l, mid, p, v);
if (tmp != -1) return tmp;
return ask(k * 2 + 1, mid + 1, r, p, v);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x < y) v[x].push_back(y);
}
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
int x, y;
scanf("%d%d", &x, &y);
vq[x].push_back(make_pair(y, i));
}
build(1, 1, n);
for (int i = n; i; i--) {
for (int j = 0; j < v[i].size(); j++)
change(1, 1, n, i, v[i][j] - 1, v[i][j]);
for (int j = 0; j < vq[i].size(); j++)
ans[vq[i][j].second] = ask(1, 1, n, i, vq[i][j].first);
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int N = 1e6 + 10;
const long long mod = 1e9 + 7;
const long long mod2 = 998244353;
const long long inf = 8e18;
const int LOG = 22;
const int SQ = 320;
long long pw(long long a, long long b, long long M) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % M, b / 2, M)) % M
: pw(a * a % M, b / 2, M)));
}
int n, m, q, par[N], sz[N], R[N], mx[N], Ans[N];
vector<int> L[N];
vector<pair<int, int> > Q[N];
int Get(int x) { return (x == par[x]) ? x : par[x] = Get(par[x]); }
void unify(int v, int u) {
v = Get(v), u = Get(u);
if (v == u) return;
if (sz[u] > sz[v]) swap(u, v);
sz[v] += sz[u];
par[u] = v;
mx[v] = max(mx[v], mx[u]);
}
void solve(int T) {
int tr = min(n, T * SQ);
for (int i = 1; i <= n; i++) par[i] = i, sz[i] = 1, mx[i] = i;
for (int i = tr; i >= 1; i--) {
for (auto x : L[i]) {
if (x > tr) continue;
int now = mx[Get(i)];
while (now < x) {
unify(now, now + 1);
now = mx[Get(now + 1)];
}
}
for (auto x : Q[i]) {
if (!(tr <= x.first && x.first < tr + SQ)) {
continue;
}
int cur = mx[Get(i)];
for (int j = tr + 1; j <= x.first; j++) {
if (R[j] < i) continue;
if (cur >= R[j]) cur = max({mx[Get(tr)], cur, j});
}
Ans[x.second] = cur;
}
}
}
int main() {
memset(R, -1, sizeof R);
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
L[l].push_back(r);
R[r] = l;
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d%d", &l, &r);
int T1 = l / SQ, T2 = r / SQ;
if (T1 == T2) {
int ind = r;
for (int j = r; j >= l; j--) {
par[j] = j, sz[j] = 1, mx[j] = j;
}
for (int j = r; j >= l; j--) {
ind = min(ind, j);
if (R[j] < l) continue;
while (ind >= R[j]) unify(ind, j), ind--;
}
Ans[i] = mx[Get(l)];
} else
Q[l].push_back(make_pair(r, i));
}
for (int i = 1; i <= n / SQ; i++) {
solve(i);
}
for (int i = 1; i <= q; i++) {
printf("%d\n", Ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct LazySegmentTree {
struct Node {
Node *lch, *rch;
T value;
T *lazyAdd, *lazySet;
int size;
void setMark(T val) {
if (lazyAdd != 0) delete lazyAdd;
lazyAdd = 0;
if (lazySet != 0) delete lazySet;
lazySet = new T(val);
}
void addMark(T val) {
if (lazyAdd != 0)
*lazyAdd = lazyAdd->add(val);
else
lazyAdd = new T(val);
}
void propagate() {
if (lazySet) {
T toSet = *lazySet;
value = toSet.multiply(size);
if (lch != 0 && rch != 0) {
lch->setMark(toSet);
rch->setMark(toSet);
}
delete lazySet;
lazySet = 0;
}
if (lazyAdd) {
T toAdd = *lazyAdd;
value = value.add(toAdd.multiply(size));
if (lch != 0 && rch != 0) {
lch->addMark(toAdd);
rch->addMark(toAdd);
}
delete lazyAdd;
lazyAdd = 0;
}
}
T getValue() {
propagate();
return value;
}
void update() { value = lch->getValue().combine(rch->getValue()); }
};
vector<Node> nodes;
int n;
LazySegmentTree(int nsize, vector<T> init = vector<T>()) {
n = 1;
while (n < nsize) n *= 2;
nodes.resize(2 * n - 1, {0, 0, T(), 0, 0, 1});
for (int i = 0; i < n; i++) {
if (i < (int)init.size()) nodes[n - 1 + i].value = init[i];
}
for (int i = n - 2; i >= 0; i--) {
nodes[i].value = nodes[2 * i + 1].value.combine(nodes[2 * i + 2].value);
nodes[i].lch = &nodes[2 * i + 1];
nodes[i].rch = &nodes[2 * i + 2];
nodes[i].size = nodes[i].lch->size + nodes[i].rch->size;
}
}
void add(int l, int r, T toAdd, Node* cur = 0, int lb = 0, int rb = -1) {
if (cur == 0) {
cur = &nodes[0];
rb = n;
}
cur->propagate();
if (l <= lb && rb <= r) {
cur->addMark(toAdd);
return;
}
int mid = (lb + rb) / 2;
if (l < mid) add(l, r, toAdd, cur->lch, lb, mid);
if (mid < r) add(l, r, toAdd, cur->rch, mid, rb);
cur->update();
}
void set(int l, int r, T toSet, Node* cur = 0, int lb = 0, int rb = -1) {
if (cur == 0) {
cur = &nodes[0];
rb = n;
}
cur->propagate();
if (l <= lb && rb <= r) {
cur->setMark(toSet);
return;
}
int mid = (lb + rb) / 2;
if (l < mid) set(l, r, toSet, cur->lch, lb, mid);
if (mid < r) set(l, r, toSet, cur->rch, mid, rb);
cur->update();
}
T get(int l, int r, Node* cur = 0, int lb = 0, int rb = -1) {
if (cur == 0) {
cur = &nodes[0];
rb = n;
}
cur->propagate();
if (l <= lb && rb <= r) return cur->getValue();
vector<T> ret;
int mid = (lb + rb) / 2;
if (l < mid) ret.push_back(get(l, r, cur->lch, lb, mid));
if (mid < r) ret.push_back(get(l, r, cur->rch, mid, rb));
if (ret.size() == 2) return ret[0].combine(ret[1]);
return ret[0];
}
};
using namespace std;
struct Value {
int val;
Value(int nval = 0) { val = nval; }
Value add(Value r) { return {max(val, r.val)}; }
Value combine(Value r) { return {min(val, r.val)}; }
Value multiply(int cnt) { return *this; }
};
struct Stree : LazySegmentTree<Value> {
Stree(int nsize, vector<Value> init = vector<Value>())
: LazySegmentTree<Value>(nsize, init) {}
int getInd(int l, int limit, Node* cur = 0, int lb = 0, int rb = -1) {
if (cur == 0) {
cur = &nodes[0];
rb = n;
}
cur->propagate();
if (cur->value.val >= limit) return rb;
if (cur->size == 1) return lb;
int mid = (lb + rb) / 2;
if (mid <= l) return getInd(l, limit, cur->rch, mid, rb);
int ret = getInd(l, limit, cur->lch, lb, mid);
if (ret == mid) return getInd(l, limit, cur->rch, mid, rb);
return ret;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int> > rope(n + 1);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
if (l < r) rope[r].push_back(l);
}
struct Query {
int x, y;
int result;
};
int q;
cin >> q;
vector<Query> queries(q);
vector<vector<Query*> > queriesOnHeight(n + 1);
for (int i = 0; i < q; i++) {
cin >> queries[i].x >> queries[i].y;
queriesOnHeight[queries[i].y].push_back(&queries[i]);
}
Stree st(n + 1);
for (int h = 0; h <= n; h++) {
for (auto c : rope[h]) st.add(c, h, c);
for (auto cp : queriesOnHeight[h]) {
if (cp->x < h)
cp->result = st.getInd(cp->x, cp->x);
else
cp->result = h;
}
}
for (auto c : queries) cout << c.result << '\n';
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];
for (int i = st + 1; i <= r; i++)
ans = (fr[i] <= ans && fr[i] >= l) ? i : ans;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int T, n, m, k, Q, lth[100010], ans[100010];
struct ask {
int l, r, id;
bool operator<(const ask &b) const { return r < b.r; }
} q[100010];
struct node {
int mx, se_mx;
int mn_tag, to_tag;
node operator+(const node &b) const {
node tmp = {0, 0, 0, 0};
tmp.mx = max(mx, b.mx), tmp.se_mx = max(se_mx, b.se_mx);
if (mx != b.mx) tmp.se_mx = max(tmp.se_mx, min(mx, b.mx));
return tmp;
}
} tree[400010];
void build(int l, int r, int t) {
if (l == r) return tree[t] = node{l, INT_MIN, 0, 0}, void();
int mid = (l + r) >> 1;
build(l, mid, t << 1);
build(mid + 1, r, t << 1 | 1);
tree[t] = tree[t << 1] + tree[t << 1 | 1];
}
void add_tag(int t, pair<int, int> b) {
if (tree[t].mx >= b.first) {
tree[t].mx = b.second;
if (!tree[t].mn_tag)
tree[t].mn_tag = b.first;
else
tree[t].mn_tag = min(tree[t].mn_tag, b.first);
tree[t].to_tag = b.second;
}
}
void pushdown(int t) {
if (tree[t].to_tag)
add_tag(t << 1, make_pair(tree[t].mn_tag, tree[t].to_tag)),
add_tag(t << 1 | 1, make_pair(tree[t].mn_tag, tree[t].to_tag)),
tree[t].mn_tag = tree[t].to_tag = 0;
}
void change(int ll, int rr, int l, int r, int t, int mn, int c) {
if (tree[t].mx < mn) return;
if (ll <= l && r <= rr && tree[t].se_mx < mn)
return add_tag(t, make_pair(mn, c)), void();
pushdown(t);
int mid = (l + r) >> 1;
if (ll <= mid) change(ll, rr, l, mid, t << 1, mn, c);
if (mid < rr) change(ll, rr, mid + 1, r, t << 1 | 1, mn, c);
tree[t] = tree[t << 1] + tree[t << 1 | 1];
}
int query(int a, int l, int r, int t) {
if (l == r) return tree[t].mx;
pushdown(t);
int mid = (l + r) >> 1;
if (mid >= a)
return query(a, l, mid, t << 1);
else
return query(a, mid + 1, r, t << 1 | 1);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1, l, r; i <= m; i++) scanf("%d%d", &l, &r), lth[r] = l;
build(1, n, 1);
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
scanf("%d %d", &q[i].l, &q[i].r);
q[i].id = i;
}
sort(q + 1, q + Q + 1);
for (int i = 1, j = 1; i <= n; i++) {
if (lth[i]) change(1, lth[i], 1, n, 1, lth[i], i);
while (q[j].r <= i && j <= Q) ans[q[j].id] = query(q[j].l, 1, n, 1), j++;
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
int seg_trees[400400];
int bases[400400];
int left_child(int id) { return id * 2 + 1; }
int get_mid(int f, int t) {
assert(t - f > 1);
return f + (t - f) / 2;
}
void insert_segtree(int id, int from, int to, int maxh, int base) {
while (true) {
if (maxh > seg_trees[id]) {
bases[id] = base;
seg_trees[id] = maxh;
}
if (from == base && to == base + 1) {
return;
} else {
int m = get_mid(from, to);
id = left_child(id);
if (base < m) {
to = m;
} else {
from = m;
id++;
}
}
}
}
void insert_segtree(int maxh, int base) {
insert_segtree(0, 0, 100100, maxh, base);
}
pair<long long, long long> query(int id, int from, int to, int f, int t) {
f = max(f, from);
t = min(t, to);
if (f >= t) return make_pair(-oo, -oo);
if (from == f && t == to) return make_pair(seg_trees[id], bases[id]);
int m = get_mid(from, to);
int c = left_child(id);
auto a = query(c, from, m, f, t);
auto b = query(c + 1, m, to, f, t);
return max(a, b);
}
pair<long long, long long> query(int f, int t) {
return query(0, 0, 100100, f, t);
}
long long get_res(int f) {
int t = f;
stack<pair<long long, long long> > todo;
while (true) {
auto nn = query(f, t + 1);
if (nn.first > t) {
todo.push(make_pair(f, t));
f = nn.second;
t = nn.first;
} else {
break;
}
}
while (!todo.empty()) {
auto nn = todo.top();
insert_segtree(t, nn.first);
todo.pop();
}
return t;
}
pair<int, int> queries[100100];
unordered_map<int, int> mem[100100];
pair<int, int> squeries[100100];
int main() {
ios::sync_with_stdio(false);
int N, M, Q;
cin >> N >> M;
vector<pair<int, int> > ropes(M);
for (int i = (0); i < (M); i++) cin >> ropes[i].second >> ropes[i].first;
sort((ropes).begin(), (ropes).end());
cin >> Q;
for (int i = (0); i < (Q); i++) cin >> queries[i].second >> queries[i].first;
for (int i = (0); i < (Q); i++) squeries[i] = queries[i];
sort(squeries, squeries + Q);
int A = 0;
for (int i = (0); i < (Q); i++) {
while (A < M && squeries[i].first >= ropes[A].first) {
insert_segtree(ropes[A].first, ropes[A].second);
A++;
}
mem[squeries[i].first][squeries[i].second] = get_res(squeries[i].second);
}
for (int i = (0); i < (Q); i++)
cout << mem[queries[i].first][queries[i].second] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int l, r, id;
bool operator<(const data &a) const { return r < a.r; }
} a[100010], b[100010];
int mx[100010 << 2], sx[100010 << 2], ta[100010 << 2], tb[100010 << 2],
ans[100010];
inline void pushup(int x) {
int l = x << 1, r = x << 1 | 1;
if (mx[l] > mx[r])
mx[x] = mx[l], sx[x] = max(sx[l], mx[r]);
else if (mx[l] < mx[r])
mx[x] = mx[r], sx[x] = max(mx[l], sx[r]);
else
mx[x] = mx[l], sx[x] = max(sx[l], sx[r]);
}
inline void pushdown(int x) {
int l = x << 1, r = x << 1 | 1;
if (mx[l] >= ta[x])
mx[l] = tb[x], ta[l] = min(ta[l], ta[x]), tb[l] = max(tb[l], tb[x]);
if (mx[r] >= ta[x])
mx[r] = tb[x], ta[r] = min(ta[r], ta[x]), tb[r] = max(tb[r], tb[x]);
ta[x] = 1 << 30, tb[x] = 0;
}
void build(int l, int r, int x) {
ta[x] = 1 << 30, tb[x] = 0;
if (l == r) {
mx[x] = l, sx[x] = -1 << 30;
return;
}
int mid = (l + r) >> 1;
build(l, mid, x << 1), build(mid + 1, r, x << 1 | 1);
pushup(x);
}
void update(int b, int e, int va, int vb, int l, int r, int x) {
if (mx[x] < va) return;
if (b <= l && r <= e && mx[x] >= va && sx[x] < va) {
mx[x] = vb, ta[x] = min(ta[x], va), tb[x] = max(tb[x], vb);
return;
}
pushdown(x);
int mid = (l + r) >> 1;
if (b <= mid) update(b, e, va, vb, l, mid, x << 1);
if (e > mid) update(b, e, va, vb, mid + 1, r, x << 1 | 1);
pushup(x);
}
int query(int p, int l, int r, int x) {
if (l == r) return mx[x];
pushdown(x);
int mid = (l + r) >> 1;
if (p <= mid)
return query(p, l, mid, x << 1);
else
return query(p, mid + 1, r, x << 1 | 1);
}
int main() {
int n, m, q, i, p = 1;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) scanf("%d%d", &a[i].l, &a[i].r);
scanf("%d", &q);
for (i = 1; i <= q; i++) scanf("%d%d", &b[i].l, &b[i].r), b[i].id = i;
sort(a + 1, a + m + 1), sort(b + 1, b + q + 1);
build(0, n, 1);
for (i = 1; i <= q; i++) {
while (p <= m && a[p].r <= b[i].r)
update(0, a[p].l, a[p].l, a[p].r, 0, n, 1), p++;
ans[b[i].id] = query(b[i].l, 0, n, 1);
}
for (i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const long long LINF = INF * (long long)INF;
const int MAX = 100100;
vector<pair<pair<int, int>, int> > Q[MAX];
int ANS[MAX];
struct DSU {
int p[MAX];
int sz[MAX];
int L[MAX];
int R[MAX];
void init(int n) {
for (int i = (0); i < (n); i++) sz[i] = 1, p[i] = L[i] = R[i] = i;
}
int get(int a) { return p[a] == a ? a : p[a] = get(p[a]); }
void unite(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
p[b] = a;
L[a] = min(L[a], L[b]);
R[a] = max(R[a], R[b]);
sz[a] += sz[b];
}
} D;
int L[MAX];
vector<int> R[MAX];
const int MAGIC = 333;
int n;
void solve(vector<pair<pair<int, int>, int> > Q) {
if (Q.empty()) return;
sort(Q.begin(), Q.end());
reverse(Q.begin(), Q.end());
D.init(n);
int bind = Q[0].first.second / MAGIC * MAGIC;
int ll = bind - 1;
for (int i = (0); i < ((int)Q.size()); i++) {
int l = Q[i].first.first;
int r = Q[i].first.second;
int ind = Q[i].second;
while (ll >= l) {
for (int j = (0); j < ((int)R[ll].size()); j++) {
int pos = ll;
int to = R[ll][j];
if (to >= bind) continue;
while (pos < to) {
D.unite(pos, pos + 1);
pos = D.R[D.get(pos)];
}
}
ll--;
}
int bst = D.R[D.get(l)];
for (int j = (bind); j < (r + 1); j++) {
if (L[j] <= bst && L[j] >= l) {
bst = j;
}
}
ANS[ind] = bst;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int m;
cin >> n >> m;
for (int i = (0); i < (n); i++) L[i] = i;
for (int i = (0); i < (m); i++) {
int l, r;
cin >> l >> r;
--l;
--r;
L[r] = l;
R[l].push_back(r);
}
int q;
cin >> q;
for (int i = (0); i < (q); i++) {
int l, r;
cin >> l >> r;
--l;
--r;
Q[r / MAGIC].push_back(make_pair(make_pair(l, r), i));
}
for (int i = (0); i < (n); i++) {
solve(Q[i]);
}
for (int i = (0); i < (q); i++) {
cout << ANS[i] + 1 << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1 << 17, TOUR = 1 << 17, LG = 18;
set<pair<int, int> > t[2 * TOUR];
int presjek(pair<int, int> a, pair<int, int> b) {
return max(a.first, b.first) <= min(a.second, b.second);
}
void ubaci(set<pair<int, int> > &S, pair<int, int> val) {
auto it = S.lower_bound({val.first, -1});
for (; it != S.begin() && (it == S.end() || it->first > val.first); it--)
;
for (; it != S.end();) {
if (presjek(*it, val)) {
val.first = min(val.first, it->first);
val.second = max(val.second, it->second);
auto it2 = it++;
S.erase(it2);
} else if (it->first < val.first)
it++;
else
break;
}
S.insert(val);
}
void insert(int pos, pair<int, int> val) {
pos += TOUR;
for (; pos; pos /= 2) ubaci(t[pos], val);
}
int eval(set<pair<int, int> > &S, int val) {
auto it = S.lower_bound(pair<int, int>(val, val));
for (; it != S.begin() && (it == S.end() || it->first > val); it--)
;
if (it != S.end() && it->first <= val) return max(val, it->second);
return val;
}
void q(int pos, int lo, int hi, int begin, int &val) {
if (hi <= begin) return;
if (lo >= begin) {
val = eval(t[pos], val);
return;
}
q(2 * pos + 0, lo, (lo + hi) / 2, begin, val);
q(2 * pos + 1, (lo + hi) / 2, hi, begin, val);
}
pair<int, int> p[MAX];
pair<pair<int, int>, int> kver[MAX];
int rje[MAX];
int main() {
int n;
scanf("%*d%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &p[i].first, &p[i].second);
}
sort(p, p + n,
[](pair<int, int> a, pair<int, int> b) { return a.second < b.second; });
int brq;
scanf("%d", &brq);
for (int i = 0; i < brq; i++) {
scanf("%d%d", &kver[i].first.first, &kver[i].first.second);
kver[i].second = i;
}
sort(kver, kver + brq,
[](pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return a.first.second < b.first.second;
});
int indp = 0;
for (int i = 0; i < brq; i++) {
for (; indp < n && p[indp].second <= kver[i].first.second; indp++)
insert(p[indp].first, p[indp]);
rje[kver[i].second] = kver[i].first.first;
q(1, 0, TOUR, kver[i].first.first, rje[kver[i].second]);
}
for (int i = 0; i < brq; i++) printf("%d\n", rje[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int path[100010];
int dp[100010][330];
int furthest[100010];
vector<int> go[100010];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
fill(path, path + 100010, 1e9);
cin >> n >> m;
for (int qq = 0; qq < m; ++qq) {
int v, u;
cin >> v >> u;
--v;
--u;
go[v].push_back(u);
path[u] = v;
}
int bsize = sqrt(n);
for (int j = bsize; j < n; j += bsize) {
stack<int> stk;
for (int i = j; i >= 0; --i) {
furthest[i] = i;
int maxd = i;
for (auto &e : go[i]) {
if (e <= j) maxd = max(maxd, e);
}
while (!stk.empty() && stk.top() <= maxd) {
maxd = max(maxd, dp[stk.top()][j / bsize]);
stk.pop();
}
dp[i][j / bsize] = maxd;
stk.push(i);
}
}
int nq;
cin >> nq;
for (int qq = 0; qq < nq; ++qq) {
int l, r;
cin >> l >> r;
l--;
r--;
int ans;
if (r - l <= bsize) {
ans = l;
for (int i = l + 1; i <= r; ++i) {
if (l <= path[i] && path[i] <= ans) {
ans = i;
}
}
} else {
ans = dp[l][r / bsize];
for (int i = bsize * int(r / bsize); i <= r; ++i) {
if (l <= path[i] && path[i] <= ans) {
ans = i;
}
}
}
cout << ans + 1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool f = false;
for (; !isdigit(c); c = getchar()) f |= c == '-';
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
if (f) x = -x;
}
template <typename T, typename... Arg>
inline void read(T &x, Arg &...args) {
read(x);
read(args...);
}
template <typename T>
inline void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 1e5 + 10;
int n, m, q;
int ans[N];
int ls[N];
vector<pair<int, int>> Qry[N];
struct node {
int mx, nxt;
int tagA, tagB;
node(int a = -2e9) : mx(a), nxt(-2e9), tagA(0), tagB(0) {}
void upd(int x) {
if (x > mx)
nxt = mx, mx = x;
else if (nxt < x && x < mx)
nxt = x;
}
void upTag(int A, int B) {
if (mx >= A) {
mx = B;
if (!tagA) tagA = A;
tagB = B;
}
}
} t[N << 2];
void up(int x) {
t[x] = node();
t[x].upd(t[(x << 1)].mx);
t[x].upd(t[(x << 1)].nxt);
t[x].upd(t[(x << 1 | 1)].mx);
t[x].upd(t[(x << 1 | 1)].nxt);
}
void down(int x) {
if (t[x].tagA) {
t[(x << 1)].upTag(t[x].tagA, t[x].tagB);
t[(x << 1 | 1)].upTag(t[x].tagA, t[x].tagB);
t[x].tagA = t[x].tagB = 0;
}
}
void build(int x, int l, int r) {
if (l == r) {
t[x] = node(l);
return;
}
build((x << 1), l, ((l + r) >> 1));
build((x << 1 | 1), ((l + r) >> 1) + 1, r);
up(x);
}
void upd(int x, int l, int r, int ql, int qr, int A, int B) {
if (t[x].mx < A || r < ql || qr < l) return;
if (ql <= l && r <= qr && t[x].nxt < A) {
t[x].upTag(A, B);
return;
}
down(x);
upd((x << 1), l, ((l + r) >> 1), ql, qr, A, B);
upd((x << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr, A, B);
up(x);
}
int qry(int x, int l, int r, int pos) {
if (l == r) return t[x].mx;
down(x);
if (pos <= ((l + r) >> 1))
return qry((x << 1), l, ((l + r) >> 1), pos);
else
return qry((x << 1 | 1), ((l + r) >> 1) + 1, r, pos);
}
signed main() {
read(n, m);
for (int i = 1; i <= m; i++) {
int l, r;
read(l, r);
ls[r] = l;
}
read(q);
for (int i = 1; i <= q; i++) {
int x, y;
read(x, y);
Qry[y].push_back({x, i});
}
build(1, 1, n);
for (int i = 1; i <= n; i++) {
if (ls[i]) upd(1, 1, n, 1, ls[i], ls[i], i);
for (auto [x, id] : Qry[i]) ans[id] = qry(1, 1, n, x);
}
for (int i = 1; i <= q; i++) write(ans[i]), putchar('\n');
}
|
#include <bits/stdc++.h>
using namespace std;
namespace thecold {
inline int read() {
int res = 0;
bool flag = false;
char c = getchar();
while (!isdigit(c)) flag = (c == '-'), c = getchar();
while (isdigit(c)) res = res * 10 + (c ^ 48), c = getchar();
return !flag ? res : -res;
}
const int Max_n = 1e5 + 5;
int bak[Max_n], n, m, q;
struct node {
int l, r, tagl, tagv, mx, mmx;
node(int a, int b) { l = a, r = b, tagv = tagl = mx = mmx = 0; }
node() {}
} tree[Max_n << 3];
inline void push_up(const int tr) {
int ls = tr << 1, rs = tr << 1 | 1;
if (tree[tr].l == tree[tr].r) return;
if (tree[ls].mx > tree[rs].mx)
tree[tr].mx = tree[ls].mx, tree[tr].mmx = max(tree[ls].mmx, tree[rs].mx);
else if (tree[ls].mx < tree[rs].mx)
tree[tr].mx = tree[rs].mx, tree[tr].mmx = max(tree[ls].mx, tree[rs].mmx);
else
tree[tr].mx = tree[ls].mx, tree[tr].mmx = max(tree[ls].mmx, tree[rs].mmx);
}
inline void build(const int l, const int r, const int tr) {
tree[tr] = node(l, r);
if (l == r) return tree[tr].mx = l, tree[tr].mmx = -Max_n, void();
int mid = (l + r) >> 1;
build(l, mid, tr << 1), build(mid + 1, r, tr << 1 | 1);
push_up(tr);
}
inline void cop(node &a, node b, const int tr) {
a.mx = a.tagv = b.tagv, !a.tagl && (a.tagl = b.tagl);
}
inline void push_down(const int tr) {
if (!tree[tr].tagl) return;
int ls = tr << 1, rs = tr << 1 | 1;
if (tree[ls].mx == tree[tr].tagl) cop(tree[ls], tree[tr], tr);
if (tree[rs].mx == tree[tr].tagl) cop(tree[rs], tree[tr], tr);
tree[tr].tagl = tree[tr].tagv = 0;
}
inline void change(const int l, const int r, const int va, const int lim,
const int tr) {
int ll = tree[tr].l, rr = tree[tr].r;
if (ll > r || rr < l) return;
if (tree[tr].mx < lim) return;
push_down(tr);
if (l <= ll && rr <= r) {
if (tree[tr].mmx < lim)
return tree[tr].tagl = tree[tr].mx, tree[tr].tagv = tree[tr].mx = va,
void();
}
change(l, r, va, lim, tr << 1), change(l, r, va, lim, tr << 1 | 1);
push_up(tr);
}
int ans[Max_n];
struct Node {
int l, bel;
Node(int a, int b) { l = a, bel = b; }
Node() {}
};
vector<Node> v[Max_n];
inline int query(const int pos, const int tr) {
int ll = tree[tr].l, rr = tree[tr].r;
if (ll == rr) return tree[tr].mx;
push_down(tr);
int mid = (ll + rr) >> 1;
if (mid >= pos) return query(pos, tr << 1);
return query(pos, tr << 1 | 1);
}
inline void main() {
n = read(), m = read();
build(1, n, 1);
for (int i = 1; i <= m; ++i) {
int ui = read(), vi = read();
bak[vi] = ui;
}
q = read();
for (int i = 1; i <= q; ++i) {
int li = read(), ri = read();
v[ri].push_back(Node(li, i));
}
for (int now = 1; now <= n; ++now) {
if (bak[now]) change(1, bak[now], now, bak[now], 1);
int sz = v[now].size();
for (int i = 0; i < sz; ++i) ans[v[now][i].bel] = query(v[now][i].l, 1);
}
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
}
} // namespace thecold
int main() {
thecold::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int K = 300;
int to[101010];
int le[101010];
int fp[1010];
void add(int l, int r) {
int b = r / K;
int bl = b * K;
int br = (b + 1) * K - 1;
le[r] = min(le[r], le[l]);
for (int i = max(l, bl); i <= r; i++) {
le[r] = min(le[r], le[i]);
}
for (int i = bl; i <= br; i++) {
le[i] = min(le[i], le[le[i]]);
to[i] = min(to[i], le[i]);
}
for (int i = bl; i <= br; i++) {
to[i] = min(to[i], to[max(le[i], bl)]);
if (to[i] <= r) to[i] = min(to[i], to[r]);
}
fp[b] = bl;
for (int i = br; i >= bl; i--) {
if (i < br) {
to[i] = min(to[i], to[i + 1]);
}
if (to[i] < bl && fp[b] == bl) {
fp[b] = i;
}
}
}
int qr(int l, int r) {
int sp = r;
int lp = r;
for (int i = r; i > l;) {
if (lp > i) {
sp = i;
lp = le[i];
}
if (i % K == K - 1 && i - K > l) {
lp = min(lp, to[max(i - (K - 1), lp)]);
if (lp > i - K) {
sp = fp[i / K];
lp = to[sp];
}
i -= K;
} else {
lp = min(lp, le[i]);
i--;
}
}
if (lp > l) return l;
return sp;
}
int ans[101010];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<pair<int, int> > rs(m);
for (int i = 0; i < m; i++) {
cin >> rs[i].first >> rs[i].second;
rs[i].first--;
rs[i].second--;
}
sort(rs.rbegin(), rs.rend());
int q;
cin >> q;
vector<pair<pair<int, int>, int> > qs(q);
for (int qq = 0; qq < q; qq++) {
cin >> qs[qq].first.first >> qs[qq].first.second;
qs[qq].second = qq;
qs[qq].first.first--;
qs[qq].first.second--;
}
sort(qs.rbegin(), qs.rend());
for (int i = 0; i < n / K; i++) {
fp[i] = i * K;
}
for (int i = 0; i < n; i++) {
to[i] = i;
le[i] = i;
}
int i2 = 0;
for (int qq = 0; qq < q; qq++) {
while (i2 < m && rs[i2].first >= qs[qq].first.first) {
add(rs[i2].first, rs[i2].second);
i2++;
}
ans[qs[qq].second] = qr(qs[qq].first.first, qs[qq].first.second);
}
for (int i = 0; i < q; i++) {
cout << ans[i] + 1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
void fastio() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 100000 + 7;
const int M = 333 + 7;
int n, m, q, bs, bk[N], lim[N][M], answer[N][M];
int first[M], last[M], bucket[N];
vector<int> gol[N];
int main() {
fastio();
cin >> n >> m;
bs = sqrt(n);
for (int i = 1; i <= n; i++) {
bk[i] = i;
}
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
gol[l].push_back(r);
bk[r] = l;
}
for (int i = 1; i <= n; i++) {
bucket[i] = (i - 1) / bs + 1;
last[bucket[i]] = i;
}
for (int i = n; i >= 1; i--) {
first[bucket[i]] = i;
}
for (int i = 1; i <= n; i++) {
sort(gol[i].rbegin(), gol[i].rend());
for (int j = bucket[1]; j <= bucket[n]; j++) {
lim[i][j] = max(i, lim[i][j - 1]);
while (!gol[i].empty() && gol[i].back() <= last[j]) {
lim[i][j] = max(lim[i][j], gol[i].back());
gol[i].pop_back();
}
}
}
for (int j = bucket[1]; j <= bucket[n]; j++) {
vector<int> stk;
for (int i = n; i >= 1; i--) {
int cur = i;
while (!stk.empty() && stk.back() <= lim[i][j]) {
cur = max(cur, answer[stk.back()][j]);
stk.pop_back();
}
answer[i][j] = cur;
stk.push_back(i);
}
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
if (bucket[l] == bucket[r]) {
int x = l;
for (int i = l + 1; i <= r; i++) {
if (l <= bk[i] && bk[i] <= x) {
x = i;
}
}
cout << x << "\n";
} else {
int x = answer[l][bucket[r] - 1];
for (int i = first[bucket[r]]; i <= r; i++) {
if (l <= bk[i] && bk[i] <= x) {
x = i;
}
}
cout << x << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(int x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(int x) {
write(x);
putchar('\n');
}
const int N = 1000005;
struct node {
int l, r;
} b[N];
struct que {
int l, r, id;
} c[N];
int now;
int Ans[N];
int n, k, q;
int Mx[N * 4], pos[N * 4];
int Mxdis[N];
int stkc[N], topc;
int Pos, ans;
inline bool cmp2(node a, node b) {
return a.r < b.r || (a.r == b.r && a.l > b.l);
}
inline bool cmp3(que a, que b) {
return a.r < b.r || (a.r == b.r && a.l > b.l);
}
inline void change(int x, int y) {
int l = 1, r = n, num = 1;
while (1) {
int mid = (l + r) >> 1;
if (Mx[num] < y) pos[num] = x, Mx[num] = y;
if (l == r) break;
if (x <= mid)
r = mid, num = (num << 1);
else
l = mid + 1, num = (num << 1 | 1);
}
}
inline void query(int num, int l, int r, int x, int y) {
if (x <= l && r <= y) {
if (Mx[num] > ans) {
Pos = pos[num];
ans = Mx[num];
}
return;
}
int mid = (l + r) >> 1;
if (x <= mid) query(num << 1, l, mid, x, y);
if (y > mid) query(num << 1 | 1, mid + 1, r, x, y);
}
int main() {
n = read();
k = read();
for (int i = 1; i <= k; ++i) b[i].l = read(), b[i].r = read();
q = read();
for (int i = 1; i <= q; ++i) c[i].l = read(), c[i].r = read(), c[i].id = i;
sort(b + 1, b + k + 1, cmp2);
sort(c + 1, c + q + 1, cmp3);
now = 1;
for (int i = 1; i <= n; ++i) Mxdis[i] = i;
for (int i = 1; i <= q; ++i) {
while (now <= k && b[now].r <= c[i].r) {
if (Mxdis[b[now].l] < b[now].r) {
change(b[now].l, b[now].r);
Mxdis[b[now].l] = b[now].r;
}
++now;
}
topc = 0;
stkc[++topc] = c[i].l;
int last = c[i].l;
while (1) {
int x = stkc[topc];
Pos = 0, ans = 0;
query(1, 1, n, last, Mxdis[x]);
if (ans > Mxdis[x])
stkc[++topc] = Pos, last = Mxdis[x];
else
break;
}
int mm = Mxdis[stkc[topc--]];
while (topc > 0) {
change(stkc[topc], mm);
Mxdis[stkc[topc--]] = mm;
}
Ans[c[i].id] = mm;
}
for (int i = 1; i <= q; ++i) writeln(Ans[i]);
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;
}
}
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;
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
using std::sort;
using std::swap;
using std::vector;
const int maxn = 100007;
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;
inline void rd(int &x) {
x = 0;
register char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
x = x * 10 + c - 48;
c = getchar();
}
}
struct edge {
int to, nxxt;
} e[110002 << 1];
struct node {
int l, r, id;
} b[110002];
int n, m, fa[110002], Q, head[110002], cnt = 1, ans[110002], blk, lx[110002],
rx[110002], bel[110002], cn,
s[2002][2002], tot[2002], nxt[110002];
int fn[110002];
bool ban[110002];
inline void ins(int u, int v) {
e[cnt] = (edge){v, head[u]};
head[u] = cnt++;
}
inline bool cmp(node n1, node n2) { return n1.l < n2.l; }
inline void bt(int x) {
tot[x] = 0;
for (register int i = rx[x]; i >= lx[x]; i--)
if (!ban[i]) {
while (tot[x] && i < fa[s[x][tot[x]]]) tot[x]--;
if (tot[x])
nxt[i] = s[x][tot[x]];
else
nxt[i] = 0;
while (tot[x] && fa[i] <= fa[s[x][tot[x]]]) tot[x]--;
s[x][++tot[x]] = i;
}
for (register int i = rx[x]; i >= lx[x]; i--)
if (!ban[i]) {
if (nxt[i])
fn[i] = fn[nxt[i]];
else
fn[i] = i;
}
}
int main() {
rd(n), rd(m);
for (int i = 1; i <= m; i++) {
int x, y;
rd(x), rd(y);
if (x ^ y) fa[y] = x, ins(x, y);
}
rd(Q);
for (int i = 1; i <= Q; i++) rd(b[i].l), rd(b[i].r), b[i].id = i;
blk = 750;
sort(b + 1, b + 1 + Q, cmp);
for (int i = 1, j; i <= n; i = j + 1) {
j = min(n, i + blk - 1);
lx[++cn] = i, rx[cn] = j;
for (int ii = i; ii <= j; ii++) bel[ii] = cn;
}
for (int i = 1; i <= n; i++)
if (!fa[i]) ban[i] = 1;
for (int i = 1; i <= cn; i++) bt(i);
int t = 1;
for (int i = 1; i <= Q; i++) {
while (t < b[i].l) {
for (int j = head[t]; j; j = e[j].nxxt) {
ban[e[j].to] = 1;
bt(bel[e[j].to]);
}
t++;
}
if (bel[b[i].r] - bel[b[i].l] <= 1) {
int va = b[i].l;
for (register int j = b[i].l + 1; j <= b[i].r; j++) {
if (fa[j] >= b[i].l && fa[j] <= va) va = j;
}
ans[b[i].id] = va;
continue;
}
int va = b[i].l;
for (register int j = b[i].l + 1; j <= rx[bel[b[i].l]]; j++) {
if (fa[j] >= b[i].l && fa[j] <= va) va = j;
}
for (register int j = bel[b[i].l] + 1; j < bel[b[i].r]; j++) {
int l = 1, r = tot[j], mid, tas = 0;
while (l <= r) {
mid = (l + r) >> 1;
if (fa[s[j][mid]] <= va)
tas = mid, l = mid + 1;
else
r = mid - 1;
}
if (tas) va = fn[s[j][tas]];
}
for (register int j = lx[bel[b[i].r]]; j <= b[i].r; j++) {
if (fa[j] >= b[i].l && fa[j] <= va) va = j;
}
ans[b[i].id] = va;
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
cerr << clock() << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
const long double eps = 1e-8;
long long read() {
char ch = getchar();
long long x = 0;
int op = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') op = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
return x * op;
}
void write(long long a) {
if (a < 0) putchar('-'), a = -a;
if (a >= 10) write(a / 10);
putchar(a % 10 + '0');
}
int n, m, Q, fi[100005 << 2], se[100005 << 2], tg1[100005 << 2],
tg2[100005 << 2], ans[100005];
struct node {
int l, r;
} a[100005];
const bool cmpnode(const node &x, const node &y) { return x.r < y.r; }
struct questions {
int l, r, id;
} q[100005];
const bool cmpq(const questions &x, const questions &y) { return x.r < y.r; }
void cal(int &a, int &b, int val) {
if (val > a)
b = a, a = val;
else if (val < a && val > b)
b = val;
}
void up(int o) {
fi[o] = se[o] = -1000000000;
cal(fi[o], se[o], fi[(o << 1)]);
cal(fi[o], se[o], se[(o << 1)]);
cal(fi[o], se[o], fi[(o << 1 | 1)]);
cal(fi[o], se[o], se[(o << 1 | 1)]);
}
void mark(int o, int a, int b) {
if (fi[o] >= a) {
(fi[o]) = (b) > (fi[o]) ? (b) : (fi[o]);
tg1[o] = b;
if (!tg2[o]) tg2[o] = a;
}
}
void down(int o) {
if (tg1[o]) {
mark((o << 1), tg2[o], tg1[o]);
mark((o << 1 | 1), tg2[o], tg1[o]);
tg1[o] = tg2[o] = 0;
}
}
void build(int o, int l, int r) {
if (l == r) {
fi[o] = l, se[o] = -1000000000;
return;
}
int mid = l + r >> 1;
build((o << 1), l, mid);
build((o << 1 | 1), mid + 1, r);
up(o);
}
void modify(int o, int l, int r, int x, int y, int p, int q) {
if (fi[o] < p) return;
if (x <= l && r <= y && se[o] < p) {
mark(o, p, q);
return;
}
down(o);
int mid = l + r >> 1;
if (x <= mid) modify((o << 1), l, mid, x, y, p, q);
if (y > mid) modify((o << 1 | 1), mid + 1, r, x, y, p, q);
up(o);
}
int query(int o, int l, int r, int x) {
if (l == r) return fi[o];
down(o);
int mid = l + r >> 1;
if (x <= mid)
return query((o << 1), l, mid, x);
else
return query((o << 1 | 1), mid + 1, r, x);
}
int main() {
n = read(), m = read();
for (int i = (1); i <= (m); i++) a[i].l = read(), a[i].r = read();
sort(a + 1, a + 1 + m, cmpnode);
Q = read();
for (int i = (1); i <= (Q); i++)
q[i].l = read(), q[i].r = read(), q[i].id = i;
sort(q + 1, q + 1 + Q, cmpq);
build(1, 1, n);
int po = 1;
for (int i = (1); i <= (Q); i++) {
while (po <= m && a[po].r <= q[i].r) {
modify(1, 1, n, 1, a[po].l, a[po].l, a[po].r);
po++;
}
ans[q[i].id] = query(1, 1, n, q[i].l);
}
for (int i = (1); i <= (Q); i++) write(ans[i]), puts("");
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; 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 N = 100005;
vector<int> vc[N];
vector<pair<int, int> > vQ[N];
int n, m, Q;
int ans[N], t[N * 4];
void build(int k, int l, int r) {
t[k] = 1ll << 30;
if (l == r) return;
int mid = (l + r) / 2;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
}
void pushdown(int k) {
t[k * 2] = min(t[k * 2], t[k]);
t[k * 2 + 1] = min(t[k * 2 + 1], t[k]);
}
void change(int k, int l, int r, int x, int y, int v) {
if (l == x && r == y) {
t[k] = min(t[k], v);
return;
}
pushdown(k);
int mid = (l + r) / 2;
if (y <= mid)
change(k * 2, l, mid, x, y, v);
else if (x > mid)
change(k * 2 + 1, mid + 1, r, x, y, v);
else {
change(k * 2, l, mid, x, mid, v);
change(k * 2 + 1, mid + 1, r, mid + 1, y, v);
}
t[k] = max(t[k * 2], t[k * 2 + 1]);
}
int ask(int k, int l, int r, int p, int v) {
if (l == r) return (t[k] > v ? l : -1);
int mid = (l + r) / 2;
pushdown(k);
if (p <= l) {
if (t[k * 2] > v) return ask(k * 2, l, mid, p, v);
return ask(k * 2 + 1, mid + 1, r, p, v);
}
int ans = (p <= mid ? ask(k * 2, l, mid, p, v) : -1);
return ans == -1 ? ask(k * 2 + 1, mid + 1, r, p, v) : ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(m); i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x ^ y) vc[x].push_back(y);
}
scanf("%d", &Q);
for (int i = (int)(1); i <= (int)(Q); i++) {
int x, y;
scanf("%d%d", &x, &y);
vQ[x].push_back(pair<int, int>(y, i));
}
build(1, 1, n);
for (int i = (int)(n); i >= (int)(1); i--) {
for (auto j : vc[i]) change(1, 1, n, i, j - 1, j);
for (auto j : vQ[i]) ans[j.second] = ask(1, 1, n, i, j.first);
}
for (int i = (int)(1); i <= (int)(Q); i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 100000;
const int SZ = 400;
const int MAXB = (MAXN + SZ - 1) / SZ;
int n, m, nq;
int nb;
int jump[MAXN][MAXB];
int radj[MAXN];
vector<int> adj[MAXN];
int idx[MAXN];
int stck[MAXN], nstck;
int calc(int l, int r, int at, int done) {
for (int to = (done + 1); to <= (r); ++to)
if (radj[to] != -1 && l <= radj[to] && radj[to] <= at) at = to;
return at;
}
void run() {
scanf("%d%d", &n, &m);
for (int i = (0); i < (n); ++i) adj[i].clear(), radj[i] = -1;
for (int i = (0); i < (m); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
adj[a].push_back(b);
radj[b] = a;
}
for (int i = (0); i < (n); ++i) sort(adj[i].begin(), adj[i].end());
nb = (n + SZ - 1) / SZ;
for (int i = (0); i < (n); ++i) idx[i] = 0;
for (int j = (0); j < (nb); ++j) {
nstck = 0;
for (int at = min(n - 1, j * SZ); at >= 0; --at) {
int to = at;
while (idx[at] + 1 < ((int)(adj[at]).size()) &&
adj[at][idx[at] + 1] <= j * SZ)
++idx[at];
if (idx[at] < ((int)(adj[at]).size()) && adj[at][idx[at]] <= j * SZ)
to = adj[at][idx[at]];
int best = to;
while (nstck > 0 && to >= stck[nstck - 1]) best = jump[stck[--nstck]][j];
jump[at][j] = best;
stck[nstck++] = at;
}
}
scanf("%d", &nq);
for (int qi = (0); qi < (nq); ++qi) {
int l, r;
scanf("%d%d", &l, &r);
--l, --r;
int j = r / SZ;
int ret = l <= j * SZ ? calc(l, r, jump[l][j], j * SZ) : calc(l, r, l, l);
printf("%d\n", ret + 1);
}
}
int main() {
run();
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, r, l, i);
}
sort(qrs.begin(), qrs.end());
vector<int> ans(q);
int pbi = -1, pr = -1;
vector<int> stk;
vector<int> one_step(n);
for (auto [bi, r, l, i] : qrs) {
int split = bi * BS;
if (bi != pbi) {
stk.clear();
pr = max(0, split - BS) - 1;
iota(one_step.begin(), one_step.end(), 0);
pbi = bi;
}
while (pr < r) {
++pr;
for (auto x : og[pr]) one_step[x] = pr;
if (pr >= split) {
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);
}
}
if (r - l <= BS) {
int at = l;
for (int j = l; j <= at; ++j) at = max(at, one_step[j]);
ans[i] = at;
} else {
int at = l;
for (int j = l; j <= at && j < split; ++j) at = max(at, one_step[j]);
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;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int p[100100], t[100100];
int id[100100], L[100100], R[100100], ans[100100];
bool cmp(int i, int j) { return R[i] < R[j]; }
int mx[100100 << 2], flag[100100 << 2];
void push_up(int u) { mx[u] = max(mx[(u << 1)], mx[((u << 1) | 1)]); }
void push_down(int u) {
if (flag[u]) {
smax(mx[(u << 1)], flag[u]);
smax(flag[(u << 1)], flag[u]);
smax(mx[((u << 1) | 1)], flag[u]);
smax(flag[((u << 1) | 1)], flag[u]);
flag[u] = 0;
}
}
void update(int u, int L, int R, int l, int r, int val) {
if (l >= R || r <= L) return;
if (l <= L && R <= r) {
smax(mx[u], val);
smax(flag[u], val);
return;
}
push_down(u);
update((u << 1), L, (L + R >> 1), l, r, val);
update(((u << 1) | 1), (L + R >> 1), R, l, r, val);
push_up(u);
}
int calc(int u, int L, int R, int l, int r) {
if (l >= R || r <= L) return 0;
if (l <= L && R <= r) return mx[u];
push_down(u);
return max(calc((u << 1), L, (L + R >> 1), l, r),
calc(((u << 1) | 1), (L + R >> 1), R, l, r));
}
int find_root(int L, int R, int l, int r) {
if (l == r) return l;
int nr = calc(1, L, R, l, r + 1);
if (r >= nr) return r;
int ans;
update(1, L, R, l, l + 1, ans = find_root(L, R, l, nr));
return ans;
}
int main() {
int n, m, q;
gn(n, m);
for (int i = 1; i <= n; i++) p[i] = i, t[i] = i;
for (int i = 0; i < m; i++) {
int first, second;
gn(first, second);
p[second] = first;
}
gn(q);
for (int i = 0; i < q; i++) {
gn(L[i], R[i]);
id[i] = i;
}
sort(id, id + q, cmp);
for (int i = 1, j = 0; i <= n; i++) {
update(1, 1, n + 1, p[i], p[i] + 1, i);
smax(t[p[i]], i);
while (j < q && R[id[j]] == i) {
ans[id[j]] = find_root(1, n + 1, L[id[j]], t[L[id[j]]]);
j++;
}
}
for (int i = 0; i < q; i++) println(ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
int n;
vector<pair<int, int> > q;
int ans[N];
vector<int> pool[N], mem[N];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int t[2 * N];
inline int pos(int l, int r) { return (l + r) | (l != r); }
void apply(int l, int r, int v) {
int id = pos(l, r);
t[id] = min(t[id], v);
}
void release(int l, int r) {
int id = pos(l, r), mid = (l + r) >> 1;
apply(l, mid, t[id]);
apply(mid + 1, r, t[id]);
}
void update(int l, int r) {
int id = pos(l, r), mid = (l + r) >> 1;
t[id] = max(t[pos(l, mid)], t[pos(mid + 1, r)]);
}
void modify(int l, int r, int p, int q, int v) {
if (p <= l && r <= q) {
apply(l, r, v);
return;
}
release(l, r);
int mid = (l + r) >> 1;
if (p <= mid) modify(l, mid, p, q, v);
if (q > mid) modify(mid + 1, r, p, q, v);
update(l, r);
}
int res;
bool flag;
void query(int l, int r, int p, int q) {
if (!flag) return;
if (l < r) release(l, r);
int mid = (l + r) >> 1;
if (p <= l && r <= q) {
int id = pos(l, r);
if (t[id] <= q + 1)
res = r + 1;
else {
if (l < r) query(l, mid, p, q), query(mid + 1, r, p, q);
flag = false;
}
} else {
if (p <= mid) query(l, mid, p, q);
if (q > mid) query(mid + 1, r, p, q);
}
if (l < r) update(l, r);
}
int main() {
int m;
n = read();
m = read();
while (m--) {
int l, r;
l = read();
r = read();
if (l < r) pool[l].push_back(r);
}
int tot;
tot = read();
q.resize(tot);
for (int i = 0; i < tot; i++) {
scanf("%d%d", &q[i].first, &q[i].second);
if (q[i].first < q[i].second)
mem[q[i].first].push_back(i);
else
ans[i] = q[i].first;
}
memset(t, 0x3f, sizeof t);
for (int i = n; i > 0; i--) {
for (int j = 0; j < pool[i].size(); j++) {
int k = pool[i][j];
modify(1, n, i, k - 1, k);
}
for (int j = 0; j < mem[i].size(); j++) {
int k = mem[i][j];
res = i, flag = true;
query(1, n, i, q[k].second - 1);
ans[k] = res;
}
}
for (int i = 0; i < q.size(); 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] = 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>
#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 = 256;
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, r, l, i);
}
sort(qrs.begin(), qrs.end());
vector<int> ans(q);
int pbi = -1, pr = -1;
vector<int> stk;
vector<int> one_step(n);
for (auto [bi, r, l, i] : qrs) {
int split = bi * BS;
if (bi != pbi) {
stk.clear();
pr = max(0, split - BS) - 1;
iota(one_step.begin(), one_step.end(), 0);
pbi = bi;
}
while (pr < r) {
++pr;
for (auto x : og[pr]) one_step[x] = pr;
if (pr >= split) {
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);
}
}
if (r - l <= BS) {
int at = l;
for (int j = l; j <= at; ++j) at = max(at, one_step[j]);
ans[i] = at;
} else {
int at = l;
for (int j = l; j <= at && j < split; ++j) at = max(at, one_step[j]);
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 = 1e5 + 5, K = 300;
int go[N / K + 1][N];
int back[N];
signed main() {
int n, m;
scanf("%d%d", &n, &m);
n++;
for (int i = 0; i < (int)(n); i++) back[i] = i;
for (int i = 0; i < (int)(m); i++) {
int a, b;
scanf("%d%d", &a, &b);
back[b] = a;
}
for (int j = 0; j < (int)(n / K + 1); j++)
if (j) {
int to[n];
int jk = j * K;
for (int i = 0; i < (int)(jk + 1); i++) to[i] = i;
for (int i = 0; i < (int)(jk + 1); i++)
to[back[i]] = max(to[back[i]], (i));
struct pv {
int pos, val;
};
stack<int> st;
for (int i = (int)(jk + 1); --i >= 0;) {
go[j][i] = i;
while ((int)((st).size()) && st.top() <= to[i]) {
go[j][i] = max(go[j][i], (go[j][st.top()]));
st.pop();
}
st.push(i);
}
}
int q;
scanf("%d", &q);
for (int i = 0; i < (int)(q); i++) {
int l, r;
scanf("%d%d", &l, &r);
int x = l, mid = l;
if (l / K != r / K) {
int j = r / K;
mid = j * K;
x = go[j][l];
}
while (mid <= r) {
if (l <= back[mid] && back[mid] <= x) x = mid;
mid++;
}
printf("%d\n", x);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename num_t>
inline void addmod(num_t& a, const long long& b, const int& m) {
a = (a + b) % m;
if (a < 0) a += m;
}
template <typename num_t>
inline void update_max(num_t& a, const num_t& b) {
a = max(a, b);
}
template <typename num_t>
inline void update_min(num_t& a, const num_t& b) {
a = min(a, b);
}
template <typename num_t>
num_t gcd(num_t lhs, num_t rhs) {
return !lhs ? rhs : gcd(rhs % lhs, lhs);
}
template <typename num_t>
num_t pw(num_t n, num_t k, num_t mod) {
long long res = 1;
for (; k; k >>= 1) {
if (k & 1) res = res * n % mod;
n = 1ll * n * n % mod;
}
return (num_t)res;
}
const int inf = 1e9 + 7;
const long long ll_inf = 1ll * inf * inf;
const int MAX_N = 100000 + 7;
const int mod = 998244353;
int n, m;
vector<int> robe[MAX_N];
vector<pair<int, int>> query[MAX_N];
int ans[MAX_N];
const int MAGIC = 1000;
struct Block {
int left_index, right_index;
int nxt[MAX_N], rev[MAX_N];
set<int> current_state;
int max_merge = 0;
void init() {
for (int j = left_index; j <= right_index; ++j) {
rev[j] = j;
current_state.insert(j);
}
}
void merge(int right, int last) {
if (*current_state.rbegin() < right || max_merge == last) return;
bool found = false;
while (true) {
auto it = current_state.lower_bound(right);
if (it == current_state.end() || *it == last) break;
nxt[*it] = last;
current_state.erase(it);
found = true;
}
if (found) current_state.insert(last);
max_merge = last;
}
int get_state(int u) {
return (nxt[u] == 0) ? u : nxt[u] = get_state(nxt[u]);
}
int get_f(int u) {
int temp = rev[u];
return get_state(temp);
}
void fix(int u, int v, int right, int last) {
bool found = false;
for (int j = u; j <= v; ++j) {
int temp = rev[j];
if (get_state(temp) < right) continue;
rev[j] = last;
found = true;
}
if (found) current_state.insert(last);
}
};
Block block[MAX_N / MAGIC + 7];
int k = 0;
void solve() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
robe[v].push_back(u);
}
int q;
cin >> q;
for (int t = 0; t < q; ++t) {
int u, v;
cin >> u >> v;
query[v].push_back({u, t});
}
for (int i = 1; i <= n; ++i) {
if (i == 1 || i / MAGIC != (i - 1) / MAGIC) {
k = i / MAGIC;
block[k].left_index = i;
block[k].right_index = min(n, i + MAGIC - 1);
block[k].init();
}
}
for (int i = 1; i <= n; ++i) {
for (auto v : robe[i]) {
for (int t = 0; t <= k; ++t)
if (block[t].right_index <= v) {
block[t].merge(v, i);
} else if (block[t].left_index <= v) {
block[t].fix(block[t].left_index, v, v, i);
} else
break;
}
for (auto p : query[i]) {
int v = p.first;
int idx = p.second;
ans[idx] = block[v / MAGIC].get_f(v);
}
}
for (int t = 0; t < q; ++t) cout << ans[t] << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, T2 y) {
if (x < y) x = y;
}
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) {
pos = 0, len = fread(buf, 1, buf_size, stdin);
}
if (pos == len) {
return -1;
}
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) {
c = getChar();
}
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
using namespace std;
const int MAXN = 100228;
int n, m;
int a[MAXN], ans[MAXN], lp[MAXN];
vector<pair<int, int> > vq[MAXN];
int main() {
n = readInt(), m = readInt();
for (int i = 0; i < n; ++i) {
lp[i] = -1;
}
for (int i = 0; i < m; ++i) {
int l = readInt(), r = readInt();
l--, r--;
lp[r] = l;
}
int q = readInt();
for (int i = 0; i < q; ++i) {
int x = readInt(), y = readInt();
x--, y--;
vq[y].push_back({x, i});
}
for (int i = 0; i < n; ++i) {
a[i] = i;
}
for (int i = 0; i < n; ++i) {
int x = lp[i];
for (int j = 0; j <= x; ++j) {
a[j] = a[j] >= x ? i : a[j];
}
for (auto p : vq[i]) {
ans[p.second] = a[p.first];
}
}
for (int i = 0; i < q; ++i) {
writeInt(ans[i] + 1, '\n');
}
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;
}
const int oo = 0x3f3f3f3f;
const int maxh = 100100, maxs = 100100, maxq = 100100;
const int maxlog = 17;
int height, sn;
pair<int, int> seg[maxs + 5];
int qn;
pair<int, int> q[maxq + 5];
int posq[maxq + 5];
int ans[maxq + 5];
struct node {
node *c[2];
int Max, sMax;
int label_from, label_to;
node() : Max(0), sMax(-oo), label_from(-1) { memset(c, 0, sizeof c); }
void update() {
Max = 0, sMax = -oo;
for (int i = (0), i_end_ = (2); i < i_end_; ++i)
if (c[i]) {
chkmax(Max, c[i]->Max);
chkmax(sMax, c[i]->sMax);
if (c[i]->Max < Max) chkmax(sMax, c[i]->Max);
}
}
void flag_label(int _label_from, int _label_to) {
if (_label_from < Max) {
if (!~label_from) label_from = _label_from;
label_to = _label_to;
Max = _label_to;
}
}
void push_down() {
if (~label_from) {
for (int i = (0), i_end_ = (2); i < i_end_; ++i)
if (c[i]) c[i]->flag_label(label_from, label_to);
label_from = -1;
}
}
};
node nd[(maxh << 1) + 5];
int nd_cur = 0;
inline node *newnode() { return nd + (nd_cur++); }
int seg_x, seg_y, seg_z, seg_to, seg_ret;
void build(node *&rt, int l, int r) {
rt = newnode();
if (r - l <= 1) {
rt->Max = l + 1;
return;
}
int mid = (l + r) >> 1;
build(rt->c[0], l, mid);
build(rt->c[1], mid, r);
rt->update();
}
void add(node *rt, int l, int r) {
if (rt->Max <= seg_z) return;
if (seg_x <= l && r <= seg_y && rt->sMax <= seg_z) {
rt->flag_label(seg_z, seg_to);
return;
}
rt->push_down();
int mid = (l + r) >> 1;
if (seg_x < mid) add(rt->c[0], l, mid);
if (seg_y > mid) add(rt->c[1], mid, r);
rt->update();
}
void query(node *rt, int l, int r) {
if (r - l <= 1) {
seg_ret = rt->Max;
return;
}
rt->push_down();
int mid = (l + r) >> 1;
if (seg_x < mid)
query(rt->c[0], l, mid);
else
query(rt->c[1], mid, r);
}
node *rt;
inline void add_seg(int id) {
seg_x = 0, seg_y = seg[id].first + 1, seg_z = seg[id].first,
seg_to = seg[id].second;
add(rt, 0, height);
}
inline int query(int first) {
seg_x = first;
query(rt, 0, height);
return seg_ret;
}
int main() {
scanf("%d%d", &height, &sn);
for (int i = (0), i_end_ = (sn); i < i_end_; ++i)
scanf("%d%d", &seg[i].first, &seg[i].second), --seg[i].first;
sort(seg, seg + sn,
[&](const pair<int, int> &first, const pair<int, int> &second) {
return first.second < second.second;
});
scanf("%d", &qn);
for (int i = (0), i_end_ = (qn); i < i_end_; ++i) {
scanf("%d%d", &q[i].first, &q[i].second);
--q[i].first;
posq[i] = i;
}
sort(posq, posq + qn, [&](int first, int second) {
return q[first].second < q[second].second;
});
build(rt, 0, height);
int pt_s = 0;
for (int i = (0), i_end_ = (qn); i < i_end_; ++i) {
while (pt_s < sn && seg[pt_s].second <= q[posq[i]].second) add_seg(pt_s++);
ans[posq[i]] = query(q[posq[i]].first);
}
for (int i = (0), i_end_ = (qn); i < i_end_; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos(-1);
const long double eps = 1e-8;
long long read() {
char ch = getchar();
long long x = 0;
int op = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') op = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
return x * op;
}
void write(long long a) {
if (a < 0) putchar('-'), a = -a;
if (a >= 10) write(a / 10);
putchar(a % 10 + '0');
}
int n, m, Q, fi[100005 << 2], se[100005 << 2], tg1[100005 << 2],
tg2[100005 << 2], ans[100005];
struct node {
int l, r;
} a[100005];
const bool cmpnode(const node &x, const node &y) { return x.r < y.r; }
struct questions {
int l, r, id;
} q[100005];
const bool cmpq(const questions &x, const questions &y) { return x.r < y.r; }
void cal(int &a, int &b, int val) {
if (val > a)
b = a, a = val;
else if (val < a && val > b)
b = val;
}
void up(int o) {
fi[o] = se[o] = -1000000000;
cal(fi[o], se[o], fi[(o << 1)]);
cal(fi[o], se[o], se[(o << 1)]);
cal(fi[o], se[o], fi[(o << 1 | 1)]);
cal(fi[o], se[o], se[(o << 1 | 1)]);
}
void mark(int o, int a, int b) {
if (fi[o] >= a) {
fi[o] = b;
tg1[o] = b;
if (!tg2[o]) tg2[o] = a;
}
}
void down(int o) {
if (tg1[o]) {
mark((o << 1), tg2[o], tg1[o]);
mark((o << 1 | 1), tg2[o], tg1[o]);
tg1[o] = tg2[o] = 0;
}
}
void build(int o, int l, int r) {
if (l == r) {
fi[o] = l, se[o] = -1000000000;
return;
}
int mid = l + r >> 1;
build((o << 1), l, mid);
build((o << 1 | 1), mid + 1, r);
up(o);
}
void modify(int o, int l, int r, int x, int y, int p, int q) {
if (fi[o] < p) return;
if (x <= l && r <= y && se[o] < p) {
mark(o, p, q);
return;
}
down(o);
int mid = l + r >> 1;
if (x <= mid) modify((o << 1), l, mid, x, y, p, q);
if (y > mid) modify((o << 1 | 1), mid + 1, r, x, y, p, q);
up(o);
}
int query(int o, int l, int r, int x) {
if (l == r) return fi[o];
down(o);
int mid = l + r >> 1;
if (x <= mid)
return query((o << 1), l, mid, x);
else
return query((o << 1 | 1), mid + 1, r, x);
}
int main() {
n = read(), m = read();
for (int i = (1); i <= (m); i++) a[i].l = read(), a[i].r = read();
sort(a + 1, a + 1 + m, cmpnode);
Q = read();
for (int i = (1); i <= (Q); i++)
q[i].l = read(), q[i].r = read(), q[i].id = i;
sort(q + 1, q + 1 + Q, cmpq);
build(1, 1, n);
int po = 1;
for (int i = (1); i <= (Q); i++) {
while (po <= m && a[po].r <= q[i].r) {
modify(1, 1, n, 1, a[po].l, a[po].l, a[po].r);
po++;
}
ans[q[i].id] = query(1, 1, n, q[i].l);
}
for (int i = (1); i <= (Q); i++) write(ans[i]), puts("");
return 0;
}
|
#include <bits/stdc++.h>
int min[100010 << 2], R[100010 << 2], F[100010 << 2], G[100010 << 2];
inline void set(int x, int a, int b) {
if (min[x] >= a) {
min[x] = b;
F[x] = b;
if (!G[x]) G[x] = a;
}
}
inline void update(int &x, int &y, int &z) {
if (z > x)
y = x, x = z;
else if (z < x && z > y)
y = z;
}
inline void pushUp(int x) {
min[x] = R[x] = -1 << 30;
update(min[x], R[x], min[x << 1]);
update(min[x], R[x], R[x << 1]);
update(min[x], R[x], min[x << 1 | 1]);
update(min[x], R[x], R[x << 1 | 1]);
}
inline void pushDown(int x) {
if (F[x]) {
set(x << 1, G[x], F[x]);
set(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) {
min[x] = l;
R[x] = -1 << 30;
return;
}
int mid = (l + r) >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
pushUp(x);
}
inline void modify(int x, int l, int r, int _l, int _r, int a, int b) {
if (min[x] < a) return;
if (_l <= l && r <= _r && R[x] < a) {
set(x, a, b);
return;
}
pushDown(x);
int mid = (l + r) >> 1;
if (_l <= mid) modify(x << 1, l, mid, _l, _r, a, b);
if (_r > mid) modify(x << 1 | 1, mid + 1, r, _l, _r, a, b);
pushUp(x);
}
inline int Query(int x, int l, int r, int t) {
if (l == r) return min[x];
pushDown(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, q, left[100010], ans[100010];
struct query {
int l, r, id;
inline friend bool operator<(const query &a, const query &b) {
return a.r < b.r;
}
} Q[100010];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, l, r; i <= m; i++) scanf("%d%d", &l, &r), left[r] = l;
scanf("%d", &q);
for (int i = 1; i <= q; i++) scanf("%d%d", &Q[i].l, &Q[i].r), Q[i].id = i;
std::sort(Q + 1, Q + q + 1);
build(1, 1, n);
for (int i = 1, cur = 1; i <= n; i++) {
if (left[i]) modify(1, 1, n, 1, left[i], left[i], i);
while (cur <= q && Q[cur].r == i)
ans[Q[cur].id] = Query(1, 1, n, Q[cur].l), cur++;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, Q, M;
const int B = 500;
int st[100005];
int ans[100005];
vector<int> cache[100005];
vector<int> graph[100005];
int bit[100005];
void upd(int n, int v) {
while (n <= N) {
bit[n] = max(bit[n], v);
n += n & -n;
}
}
int query(int n) {
int ret = n;
while (n) {
ret = max(ret, bit[n]);
n -= n & -n;
}
return ret;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M;
for (int i = 1; i <= M; i++) {
int a, b;
cin >> a >> b;
st[b] = a;
graph[a].push_back(b);
}
for (int i = B; i <= N; i += B) {
cache[i].resize(N + 1);
fill(bit + 1, bit + 1 + N, 0);
for (int j = i; j; j--) {
int bst = j;
for (int e : graph[j]) {
if (e <= i) {
bst = max(bst, e);
}
}
bst = query(bst);
cache[i][j] = bst;
upd(j, bst);
}
}
cin >> Q;
while (Q--) {
int l, r;
cin >> l >> r;
int blk = r / B * B;
int bst = l;
if (blk >= l) {
bst = cache[blk][l];
} else {
blk = l;
}
for (int i = blk; i <= r; i++) {
if (st[i] <= bst && st[i] >= l) {
bst = i;
}
}
cout << bst << "\n";
}
}
|
#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) / 1264 + 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 * 1264 <= n; ntot++) id[ntot] = ntot * 1264;
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 / 1264;
int ans, st;
if (r - l <= 1264)
ans = l, st = ans;
else
ans = f[l][R], st = id[R];
for (int i = st + 1; i <= r; i++)
ans = (fr[i] <= ans && fr[i] >= l) ? i : ans;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int MD = 1000000007;
const int K = 1500;
int n, m;
vector<int> L[N];
vector<pair<int, int> > queR[N];
vector<pair<int, int> > queL[N];
int R[N], ans[N], g[N];
int f[N / K + 15][N];
int t[2 * N];
int get(int l, int r) {
int ans = l;
l += n - 1;
r += n - 1;
while (l <= r) {
if (l & 1) {
if (ans < t[l]) {
ans = t[l];
}
l++;
}
if (~r & 1) {
if (ans < t[r]) {
ans = t[r];
}
r--;
}
l >>= 1;
r >>= 1;
}
return ans;
}
void update(int p, int v) {
p += n - 1;
t[p] = v;
while (p > 1) {
t[p >> 1] = max(t[p], t[p ^ 1]);
p >>= 1;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int x, y;
cin >> x >> y;
L[x].push_back(y);
R[y] = x;
}
for (int i = 1; i <= n; ++i) {
sort(L[i].begin(), L[i].end());
}
int q;
cin >> q;
for (int y = K; y <= n; y += K) {
memset(t, 0, sizeof(t));
for (int x = y; x >= 1; --x) {
while (g[x] + 1 < L[x].size() && L[x][g[x] + 1] <= y) {
g[x]++;
}
if (!L[x].empty() && L[x][g[x]] <= y) {
f[y / K][x] = get(x, L[x][g[x]]);
} else {
f[y / K][x] = x;
}
update(x, f[y / K][x]);
}
}
for (int i = 1; i <= q; ++i) {
int x, y;
cin >> x >> y;
queR[y].push_back(make_pair(x, i));
queL[x].push_back(make_pair(y, i));
int res = 0;
if (y - x <= 2 * K) {
res = x;
for (int j = x + 1; j <= y; ++j) {
if (R[j] >= x && R[j] <= res) {
res = j;
}
}
} else {
res = f[y / K][x];
for (int j = y / K * K + 1; j <= y; ++j) {
if (R[j] >= x && R[j] <= res) {
res = j;
}
}
}
cout << res << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5, oo = 1e6;
int seg[4 * N], n, m, lazy[4 * N], ans[N];
vector<int> v[N];
struct query {
int r, id;
query(int a = 0, int b = 0) {
r = a;
id = b;
}
};
vector<query> q[N];
void fix(int c, int l, int r) {
seg[c] = min(seg[c], lazy[c]);
if (l != r) {
lazy[2 * c + 1] = min(lazy[2 * c + 1], lazy[c]);
lazy[2 * c + 2] = min(lazy[2 * c + 2], lazy[c]);
}
lazy[c] = oo;
}
void update(int c, int l, int r, int s, int e, int val) {
fix(c, l, r);
if (l > e || r < s) return;
if (l >= s && r <= e) {
lazy[c] = val;
fix(c, l, r);
return;
}
update(2 * c + 1, l, (l + r) / 2, s, e, val);
update(2 * c + 2, (l + r) / 2 + 1, r, s, e, val);
seg[c] = max(seg[2 * c + 1], seg[2 * c + 2]);
}
int get(int c, int l, int r, int s, int e, int val) {
fix(c, l, r);
if (l > e || r < s) return -1;
if (l >= s && r <= e)
if (seg[c] <= val) return -1;
if (l == r) return l;
int temp = get(2 * c + 1, l, (l + r) / 2, s, e, val);
if (temp != -1) return temp;
return get(2 * c + 2, (l + r) / 2 + 1, r, s, e, val);
}
int main() {
for (int i = 0; i < 4 * N; i++) seg[i] = lazy[i] = oo;
scanf("%d%d", &n, &m);
for (int i = 0, l, r; i < m; i++) {
scanf("%d%d", &l, &r);
if (l == r) continue;
v[l - 1].push_back(r - 1);
}
scanf("%d", &m);
for (int i = 0, l, r; i < m; i++) {
scanf("%d%d", &l, &r);
q[l - 1].push_back(query(r - 1, i));
}
for (int i = n - 1; i + 1; i--) {
for (auto j : v[i]) update(0, 0, n - 1, i, j - 1, j);
for (auto j : q[i]) ans[j.id] = get(0, 0, n - 1, i, n - 1, j.r);
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i] + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int INF = 0x3f3f3f3f;
inline int read() {
int sc = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') sc = sc * 10 + ch - '0', ch = getchar();
return sc;
}
int mx[MAXN << 2], tag[MAXN << 2], n, m, ans[MAXN], Q;
vector<int> seg[MAXN];
vector<pair<int, int> > q[MAXN];
inline int min(int x, int y) { return !x ? y : ((x <= y) ? x : y); }
inline void pushup(int x) { mx[x] = max(mx[x << 1], mx[x << 1 | 1]); }
inline void pushdown(int x) {
if (tag[x]) {
tag[x << 1] = min(tag[x << 1], tag[x]);
tag[x << 1 | 1] = min(tag[x << 1 | 1], tag[x]);
mx[x << 1] = min(mx[x << 1], tag[x]);
mx[x << 1 | 1] = min(mx[x << 1 | 1], tag[x]);
tag[x] = 0;
}
}
inline void modify(int x, int l, int r, int ql, int qr, int v) {
if (l == ql && r == qr) {
tag[x] = min(tag[x], v);
mx[x] = min(mx[x], v);
return;
}
pushdown(x);
int mid = l + r >> 1;
if (qr <= mid)
modify(x << 1, l, mid, ql, qr, v);
else if (ql > mid)
modify(x << 1 | 1, mid + 1, r, ql, qr, v);
else
modify(x << 1, l, mid, ql, mid, v),
modify(x << 1 | 1, mid + 1, r, mid + 1, qr, v);
pushup(x);
}
inline int query(int x, int l, int r, int v) {
if (l == r) return l;
pushdown(x);
int mid = l + r >> 1;
return mx[x << 1] <= v ? query(x << 1 | 1, mid + 1, r, v)
: query(x << 1, l, mid, v);
}
int main() {
n = read(), m = read();
for (int i = 1, l, r; i <= m; i++) {
l = read(), r = read();
if (l ^ r) seg[l].push_back(r);
}
Q = read();
for (int i = 1, l, r; i <= Q; i++)
l = read(), r = read(), q[l].push_back(make_pair(r, i));
for (int i = n; i; i--) {
modify(1, 1, n, i, i, INF);
for (auto r : seg[i]) modify(1, 1, n, i, r - 1, r);
for (auto x : q[i]) ans[x.second] = query(1, 1, n, 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 M = 400;
int f[100010][310];
int to[100010][310];
int pos[100010];
int s[100010];
int solve(int l, int r) {
int p = r / M;
int x = l;
if (p * M >= l) x = f[l][p];
p = max(p * M, l);
for (int i = p + 1; i <= r; i++)
if (l <= pos[i] && pos[i] <= x) x = i;
return x;
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d %d", &l, &r);
pos[r] = l;
for (int j = 1; j * M <= n; j++)
if (r <= j * M) to[l][j] = max(to[l][j], r);
}
for (int j = 1; j * M <= n; j++) {
int r = j * M;
int head = 0;
for (int l = r; l >= 1; l--) {
f[l][j] = l;
while (head && s[head] <= to[l][j]) {
f[l][j] = max(f[l][j], f[s[head]][j]);
head--;
}
s[++head] = l;
}
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d %d", &l, &r);
printf("%d\n", solve(l, r));
}
return 0;
}
|
#include <bits/stdc++.h>
int father = 0;
using namespace std;
const int oo = 1e9;
const int M1 = 1000000007;
const int M2 = 1000000009;
const double PI = acos(-1);
const int SZ = 1 << 21;
const int MX = 300000;
const int N = MX + 100;
const int LOGN = 18;
int n, m, p[N], q, Z, vis[N], vsId, ans[N];
vector<int> g[N];
struct qu {
int l, r, idx;
qu(int _l, int _r, int _idx) {
l = _l;
r = _r;
idx = _idx;
}
bool operator<(const qu &rhs) const { return r < rhs.r; }
};
vector<qu> bk[350];
int dfs(int u, int bl, int br, int ql, int qr) {
if (u < ql || u > qr) return -1;
if (u < bl || u > br) return u;
if (vis[u] == vsId) return -1;
vis[u] = vsId;
int mx = u;
for (int i = 0; i < g[u].size(); ++i) {
if (g[u][i] > br) break;
mx = max(mx, dfs(g[u][i], bl, br, ql, qr));
}
vector<int>::iterator it = upper_bound(g[u].begin(), g[u].end(), qr);
if (it != g[u].begin()) {
--it;
mx = max(mx, dfs((*it), bl, br, ql, qr));
}
return mx;
}
int main() {
scanf("%d%d", &n, &m);
Z = sqrt(n) + 1;
for (int i = 1; i <= n; ++i) p[i] = i;
for (int u, v, i = 0; i < m; ++i) {
scanf("%d%d", &u, &v);
p[v] = u;
g[u].push_back(v);
}
for (int i = 2; i <= n; ++i) {
g[i].push_back(i - 1);
}
for (int i = 1; i <= n; ++i) {
sort(g[i].begin(), g[i].end());
}
scanf("%d", &q);
for (int x, y, i = 0; i < q; ++i) {
scanf("%d%d", &x, &y);
bk[x / Z].push_back(qu(x, y, i));
}
for (int i = 0; i <= Z; ++i) {
sort(bk[i].begin(), bk[i].end());
if (!bk[i].size()) continue;
int idx = i * Z + Z;
int st = i * Z;
int ed = min(n, idx - 1);
vector<pair<int, int> > all;
for (int j = 0; j < bk[i].size(); ++j) {
qu cur = bk[i][j];
while (idx <= cur.r) {
if (p[idx] <= ed) {
all.push_back(make_pair(idx, idx));
idx++;
continue;
}
int res = p[idx];
while (all.size() && all.back().second >= p[idx]) {
res = min(res, all.back().first);
all.pop_back();
}
all.push_back(make_pair(res, idx));
idx++;
}
vsId++;
int best = dfs(cur.l, st, ed, cur.l, cur.r);
for (int j = cur.l; j <= min(best, ed); ++j) {
best = max(best, dfs(j, st, ed, cur.l, cur.r));
}
vector<pair<int, int> >::iterator it =
upper_bound(all.begin(), all.end(), make_pair(best, oo));
if (it != all.begin()) {
--it;
best = max(best, (*it).second);
}
ans[cur.idx] = best;
}
}
for (int i = 0; i < q; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 5;
int n, m;
int p[N];
vector<int> graph[N];
int mark[N];
vector<pair<int, int> > u[N];
int ans[N];
const int INF = 1000000000;
int t[4 * N];
int ad[4 * N];
void build(int v, int tl, int tr) {
ad[v] = INF;
if (tl == tr) {
t[v] = INF;
return;
}
int tm = (tl + tr) / 2;
build(v + v, tl, tm);
build(v + v + 1, tm + 1, tr);
t[v] = max(t[v + v], t[v + v + 1]);
}
void push(int v) {
ad[v + v] = min(ad[v + v], ad[v]);
t[v + v] = min(t[v + v], ad[v]);
ad[v + v + 1] = min(ad[v + v + 1], ad[v]);
t[v + v + 1] = min(t[v + v + 1], ad[v]);
}
void update(int v, int tl, int tr, int l, int r, int val) {
if (l <= tl && tr <= r) {
ad[v] = min(ad[v], val);
t[v] = min(t[v], ad[v]);
return;
}
push(v);
int tm = (tl + tr) / 2;
if (l <= tm) update(v + v, tl, tm, l, r, val);
if (r > tm) update(v + v + 1, tm + 1, tr, l, r, val);
t[v] = max(t[v + v], t[v + v + 1]);
}
int Y;
int get(int v, int tl, int tr, int l, int r) {
int tm = (tl + tr) / 2;
if (l == tl && tr == r) {
if (t[v] <= Y) return INF;
if (tl == tr) return tl;
push(v);
if (t[v + v] > Y)
return get(v + v, tl, tm, tl, tm);
else
return get(v + v + 1, tm + 1, tr, tm + 1, tr);
}
push(v);
if (r <= tm) return get(v + v, tl, tm, l, r);
if (l > tm) return get(v + v + 1, tm + 1, tr, l, r);
int in = get(v + v, tl, tm, l, tm);
if (in != INF) return in;
return get(v + v + 1, tm + 1, tr, tm + 1, r);
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= (int)(n); ++i) p[i] = i;
for (int i = 1; i <= (int)(m); ++i) {
int s, f;
scanf("%d%d", &s, &f);
p[f] = s;
}
for (int i = 1; i <= (int)(n); ++i)
if (p[i] != i) graph[p[i]].push_back(i);
int Q;
scanf("%d", &Q);
for (int iter = 1; iter <= (int)(Q); ++iter) {
int x, y;
scanf("%d%d", &x, &y);
ans[iter] = x;
u[x].push_back(make_pair(y, iter));
}
build(1, 1, n);
for (int i = (int)(n); i >= 1; --i) {
for (auto f : graph[i]) {
update(1, 1, n, i, f - 1, f);
}
for (auto U : u[i]) {
Y = U.first;
int in = U.second;
ans[in] = max(ans[in], min(get(1, 1, n, i, Y), Y));
}
}
for (int i = 1; i <= (int)(Q); ++i) printf("%d\n", ans[i]);
}
void testgen() {
FILE* f = fopen("input.txt", "w");
srand(time(0));
fclose(f);
}
int main(int argc, char* argv[]) {
cout << fixed;
cout.precision(12);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1e5 + 42, kmax = 320;
int n, m, q;
int left_end[nmax];
int query(int at_least, int up_to, int covered_to_now, int start_from) {
for (int i = start_from; i <= up_to; i++) {
if (left_end[i] >= at_least && left_end[i] <= covered_to_now)
covered_to_now = max(covered_to_now, i);
}
return covered_to_now;
}
int max_covered[nmax][kmax];
int BLOCK_SIZE;
vector<int> adj[nmax];
int dp[nmax];
stack<int> active, idle;
int bck(int low, int high) {
active = idle;
for (int i = high; i >= low; i--) {
int mx_possible = 0;
for (auto k : adj[i])
if (k <= high) mx_possible = max(mx_possible, k);
dp[i] = i;
int now = i;
while (active.size() && active.top() <= mx_possible) {
now = active.top();
active.pop();
}
dp[i] = dp[now];
active.push(i);
}
return dp[low];
}
int main() {
scanf("%i%i", &n, &m);
int l, r;
for (int i = 1; i <= m; i++) {
scanf("%i%i", &l, &r);
left_end[r] = l;
adj[l].push_back(r);
}
BLOCK_SIZE = sqrt(n);
for (int i = 1; i * BLOCK_SIZE <= n; i++) {
bck(1, i * BLOCK_SIZE);
for (int j = 1; j <= i * BLOCK_SIZE; j++) max_covered[j][i] = dp[j];
}
scanf("%i", &q);
for (int i = 1; i <= q; i++) {
scanf("%i%i", &l, &r);
int start_from = r / BLOCK_SIZE * BLOCK_SIZE + 1;
if (start_from <= l)
printf("%i\n", query(l, r, l, l));
else {
int known = max_covered[l][r / BLOCK_SIZE];
printf("%i\n", query(l, r, known, start_from));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int from[100005];
vector<int> t[100005];
vector<pair<int, int> > p[100005];
int n, m, q;
int ans[100005];
int sta[100005];
int calc(int x, int y) {
int mx = x;
for (int i = x; i <= y; i++) {
if (x <= from[i] && from[i] <= mx) mx = i;
}
return mx;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (x == y) continue;
t[x].push_back(y);
from[y] = x;
}
int block = 350;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d%d", &x, &y);
if (y - x + 1 <= block) {
ans[i] = calc(x, y);
continue;
}
p[x].push_back(make_pair(y, i));
}
for (int md = block; md <= n; md += block) {
sta[0] = 0;
for (int i = md - 1; i >= 1; i--) {
sta[++sta[0]] = i;
if (t[i].size())
for (int j = 0; j <= t[i].size() - 1; j++) {
int tmp = t[i][j];
if (tmp > md) continue;
while (sta[0] && sta[sta[0]] < tmp) sta[0]--;
}
if (p[i].size() == 0) continue;
for (int j = 0; j <= p[i].size() - 1; j++) {
int wz = p[i][j].first, id = p[i][j].second;
if (md <= wz && wz < md + block) {
int now;
if (sta[0] == 0)
now = md;
else
now = sta[sta[0]];
for (int k = md; k <= wz; k++) {
if (i <= from[k] && from[k] <= now) now = k;
}
ans[id] = now;
}
}
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int maxn = 3e5 + 500;
const int mod = 1e9 + 7;
const int inf = 1e9 + 500;
const int rad = 330;
pair<int, int> baze[maxn];
int id[maxn];
int s[maxn];
int t[maxn];
int ans[maxn];
int l[maxn];
int r[maxn];
int endof[maxn];
int dp[maxn];
int prmx[maxn];
int tahesh;
void update(int p) {
tahesh = p;
if (t[p] == p) {
return;
}
endof[t[p]] = p;
int l = (t[p] / rad) * rad;
int r = l + rad;
prmx[l] = endof[l];
for (int i = l + 1; i < r; i++) {
prmx[i] = max(prmx[i - 1], endof[i]);
}
dp[r - 1] = prmx[r - 1];
for (int i = r - 2; i >= l; i--) {
if (prmx[i] == i) {
dp[i] = i;
} else {
dp[i] = dp[i + 1];
}
}
}
int find_ans(int p) {
int l = baze[p].first;
int r = baze[p].second;
if (tahesh - l < 3 * rad) {
for (int i = l; i <= r; i++) {
r = max(r, endof[i]);
}
return r;
}
for (p = l; p <= r && p % rad != 0; p++) {
r = max(r, endof[p]);
}
while (p <= r) {
if (p / rad < r / rad) {
r = max(r, prmx[(p / rad) * rad + rad - 1]);
p = (p / rad + 1) * rad;
} else {
r = dp[r];
p = (p / rad + 1) * rad;
}
}
return r;
}
vector<int> ss[maxn];
vector<int> tt[maxn];
vector<int> sar[maxn];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < maxn; i++) {
s[i] = i;
t[i] = i;
endof[i] = i;
dp[i] = i;
}
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
ss[l].push_back(r);
tt[r].push_back(l);
}
int cn = 0;
for (int i = 1; i <= n; i++) {
int tol = max((int)ss[i].size() + (int)tt[i].size(), 1);
for (int j = 0; j < ss[i].size(); j++) {
s[cn + j] = ss[i][j];
}
for (int j = 0; j < tt[i].size(); j++) {
t[cn + ss[i].size() + j] = tt[i][j];
}
baze[i] = make_pair(cn, cn + tol - 1);
cn += tol;
}
cn = 0;
for (int i = 1; i <= n; i++) {
int tol = max((int)ss[i].size() + (int)tt[i].size(), 1);
for (int j = 0; j < ss[i].size(); j++) {
s[cn + j] = baze[ss[i][j]].second;
}
cn += tol;
}
for (int i = 0; i < cn; i++) {
if (s[i] != i) t[s[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = baze[i].first; j <= baze[i].second; j++) {
id[j] = i;
}
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> l[i] >> r[i];
sar[baze[r[i]].second].push_back(i);
}
for (int i = 0; i < cn; i++) {
update(i);
for (auto v : sar[i]) {
ans[v] = find_ans(l[v]);
}
}
for (int i = 0; i < q; i++) {
cout << id[ans[i]] << "\n";
}
}
|
#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 (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;
int const N = 123456;
int const T = 1 << 19;
vector<int> f[N];
int const INF = 1 << 30;
struct node {
int mx;
int smin;
};
struct query {
int left;
int right;
int ans;
};
query qs[N];
vector<int> sq[N];
node tr[2 * T + 5];
int getmax(int v) { return std::min(tr[v].mx, tr[v].smin); }
void relax(int v) {
if (tr[v].smin == INF) return;
tr[v].mx = getmax(v);
tr[v * 2].smin = std::min(tr[v * 2].smin, tr[v].smin);
tr[v * 2 + 1].smin = std::min(tr[v * 2 + 1].smin, tr[v].smin);
tr[v].smin = INF;
}
void setmin(int v, int left, int right, int L, int R, int val) {
if (right <= L || R <= left) return;
if (L <= left && right <= R) {
tr[v].smin = std::min(tr[v].smin, val);
return;
}
relax(v);
int mid = (left + right) >> 1;
setmin(v * 2, left, mid, L, R, val);
setmin(v * 2 + 1, mid, right, L, R, val);
tr[v].mx = std::max(getmax(v * 2), getmax(v * 2 + 1));
}
int getmin(int v, int left, int right, int L, int R, int val) {
if (right <= L || R <= left) return -1;
if (L <= left && right <= R) {
if (getmax(v) <= val) return -1;
}
if (left == right - 1) {
return left;
}
relax(v);
int mid = (left + right) >> 1;
int got = getmin(v * 2, left, mid, L, R, val);
if (got >= 0) return got;
return getmin(v * 2 + 1, mid, right, L, R, val);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
--x;
--y;
f[x].push_back(y);
}
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int x, y;
scanf("%d%d", &x, &y);
qs[i] = {x - 1, y - 1, -5};
sq[x - 1].push_back(i);
}
for (int i = 0; i < 2 * T; i++) tr[i] = {INF, INF};
for (int i = n - 1; i >= 0; i--) {
for (int y : f[i]) {
setmin(1, 0, T, i, y, y);
}
for (int qid : sq[i]) {
int got = getmin(1, 0, T, i, n, qs[qid].right);
assert(got >= 0);
qs[qid].ans = got;
}
}
for (int i = 0; i < q; i++) {
printf("%d\n", qs[i].ans + 1);
}
}
|
#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;
lm = ans[b_r][l];
pl = b_r * sz_b;
} else
lm = pl = 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>
using namespace std;
int N, Q, M;
const int B = 950;
int st[100005];
int ans[100005];
vector<int> cache[100005];
vector<int> graph[100005];
int bit[100005];
void upd(int n, int v) {
while (n <= N) {
bit[n] = max(bit[n], v);
n += n & -n;
}
}
int query(int n) {
int ret = n;
while (n) {
ret = max(ret, bit[n]);
n -= n & -n;
}
return ret;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M;
for (int i = 1; i <= M; i++) {
int a, b;
cin >> a >> b;
st[b] = a;
graph[a].push_back(b);
}
for (int i = B; i <= N; i += B) {
cache[i].resize(N + 1);
fill(bit + 1, bit + 1 + N, 0);
for (int j = i; j; j--) {
int bst = j;
for (int e : graph[j]) {
if (e <= i) {
bst = max(bst, e);
}
}
bst = query(bst);
cache[i][j] = bst;
upd(j, bst);
}
}
cin >> Q;
while (Q--) {
int l, r;
cin >> l >> r;
int blk = r / B * B;
int bst = l;
if (blk >= l) {
bst = cache[blk][l];
} else {
blk = l;
}
for (int i = blk; i <= r; i++) {
if (st[i] <= bst && st[i] >= l) {
bst = i;
}
}
cout << bst << "\n";
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
#pragma GCC optimize("Ofast,-funroll-loops,-fno-stack-protector")
#pragma GCC target( \
"popcnt,sse,sse2,sse3,ssse3,sse4,avx,avx2,abm,mmx,tune=native")
using namespace std;
static constexpr int Maxn = 1e5 + 5;
static constexpr int BLOCK = 350;
int n, m, q;
int blk, bls, bl[Maxn];
int bL[BLOCK], bR[BLOCK];
int prv[Maxn];
vector<int> nxt[Maxn];
int right_19260817[Maxn][BLOCK];
int ans[Maxn][BLOCK];
int stk[Maxn], stk_top;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cout << fixed << setprecision(12);
cin >> n >> m;
blk = (int)sqrt(n);
for (int i = 1; i <= n; ++i) bl[i] = (i - 1) / blk + 1;
bls = bl[n];
for (int i = 1; i <= bls; ++i) {
bL[i] = (i - 1) * blk + 1;
bR[i] = i * blk;
if (bR[i] > n) bR[i] = n;
}
for (int i = 1; i <= m; ++i) {
int l, r;
cin >> l >> r;
prv[r] = l;
nxt[l].push_back(r);
}
for (int i = 1; i <= n; ++i) sort(nxt[i].begin(), nxt[i].end());
for (int i = 1; i <= n; ++i) {
for (int ii = 0, j = 1; j <= bls; ++j) {
if (bR[j] < i) continue;
while (ii < (int)nxt[i].size() && nxt[i][ii] <= bR[j]) ++ii;
right_19260817[i][j] = (!ii ? i : nxt[i][ii - 1]);
}
}
for (int j = 1; j <= bls; ++j) {
stk_top = 0;
for (int i = bR[j]; i >= 1; --i) {
ans[i][j] = right_19260817[i][j];
while (stk_top > 0 && right_19260817[i][j] >= stk[stk_top])
ans[i][j] = max(ans[i][j], ans[stk[stk_top--]][j]);
stk[++stk_top] = i;
}
}
auto query = [&](int l, int r) -> int {
int pl = bl[l], pr = bl[r];
int res = (pl == pr ? l : ans[l][pr - 1]);
int from = (pl == pr ? l + 1 : bL[pr]);
for (int i = from; i <= r; ++i)
if (prv[i] >= l && prv[i] <= res) res = i;
return res;
};
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
cout << query(l, r) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using std::make_pair;
using std::max;
using std::min;
using std::pair;
using std::vector;
inline int read() {
char c = getchar();
int h = 0;
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') h = (h << 1) + (h << 3) + c - '0', c = getchar();
return h;
}
const int MAXN = 400100;
int n, m, q;
vector<int> mdf[MAXN];
vector<pair<int, int> > qry[MAXN];
int ans[MAXN];
struct Segment_Tree {
int mx[MAXN], sec[MAXN];
int col[MAXN];
void push_up(int rt) {
if (mx[rt << 1] == mx[rt << 1 | 1])
mx[rt] = mx[rt << 1], sec[rt] = max(sec[rt << 1], sec[rt << 1 | 1]);
else if (mx[rt << 1] > mx[rt << 1 | 1])
mx[rt] = mx[rt << 1], sec[rt] = max(sec[rt << 1], mx[rt << 1 | 1]);
else
mx[rt] = mx[rt << 1 | 1], sec[rt] = max(mx[rt << 1], sec[rt << 1 | 1]);
}
void color(int rt, int R) { col[rt] = mx[rt] = R; }
void push_down(int rt) {
int tmp = max(mx[rt << 1], mx[rt << 1 | 1]);
if (mx[rt << 1] == tmp) color(rt << 1, col[rt]);
if (mx[rt << 1 | 1] == tmp) color(rt << 1 | 1, col[rt]);
col[rt] = 0;
}
void build(int l, int r, int rt) {
if (l == r) return mx[rt] = l, sec[rt] = -0x3f3f3f3f, void();
int mid = (l + r) >> 1;
build(l, mid, rt << 1), build(mid + 1, r, rt << 1 | 1);
push_up(rt);
}
void modify(int l, int r, int rt, int nowl, int nowr, int L, int R) {
if (mx[rt] < L) return;
if (nowl <= l && r <= nowr && sec[rt] < L) return color(rt, R), void();
if (col[rt]) push_down(rt);
int mid = (l + r) >> 1;
if (nowl <= mid) modify(l, mid, rt << 1, nowl, nowr, L, R);
if (nowr > mid) modify(mid + 1, r, rt << 1 | 1, nowl, nowr, L, R);
push_up(rt);
}
int query(int l, int r, int rt, int pos) {
if (l == r) return mx[rt];
if (col[rt]) push_down(rt);
int mid = (l + r) >> 1;
if (pos <= mid)
return query(l, mid, rt << 1, pos);
else
return query(mid + 1, r, rt << 1 | 1, pos);
}
} t;
int main() {
n = read();
t.build(1, n, 1);
m = read();
for (int i = 1; i <= m; i++) {
int L = read(), R = read();
mdf[R].push_back(L);
}
q = read();
for (int i = 1; i <= q; i++) {
int L = read(), R = read();
qry[R].push_back(make_pair(L, i));
}
for (int i = 1; i <= n; i++) {
for (int h = 0; h < mdf[i].size(); h++) {
t.modify(1, n, 1, 1, mdf[i][h], mdf[i][h], i);
}
for (int h = 0; h < qry[i].size(); h++) {
ans[qry[i][h].second] = t.query(1, n, 1, qry[i][h].first);
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m, Q, l, r, x, y;
int lft[N], ans[N];
vector<pair<int, int> > q[N];
pair<int, int> tag[N * 4];
struct Tre {
int mx, second;
} tre[N * 4];
void push_up(int rt) {
tre[rt].mx = max(tre[rt << 1].mx, tre[rt << 1 | 1].mx);
tre[rt].second = max(tre[rt << 1].second, tre[rt << 1 | 1].second);
if (tre[rt << 1].mx != tre[rt].mx)
tre[rt].second = max(tre[rt].second, tre[rt << 1].mx);
if (tre[rt << 1 | 1].mx != tre[rt].mx)
tre[rt].second = max(tre[rt].second, tre[rt << 1 | 1].mx);
}
void merge(pair<int, int> &x, pair<int, int> y) {
if (y.first <= x.first)
x = make_pair(y.first, y.second);
else if (x.first < y.first && y.first <= x.second)
x = make_pair(x.first, y.second);
else if (x.second < y.first)
x = make_pair(y.first, y.second);
}
int work(int rt, pair<int, int> tmp) {
if (tre[rt].mx < tmp.first) return 1;
tre[rt].mx = tmp.second;
if (tre[rt].second < tmp.first) {
merge(tag[rt], tmp);
return 1;
} else if (tmp.first <= tre[rt].second)
return 0;
}
void pushdown(int rt) {
if (!tag[rt].first && !tag[rt].second) return;
work(rt << 1, tag[rt]), work(rt << 1 | 1, tag[rt]);
tag[rt].first = tag[rt].second = 0;
}
void build(int rt, int l, int r) {
if (l == r) {
tre[rt] = (Tre){l, -1};
return;
}
int mid = l + r >> 1;
build(rt << 1, l, mid), build(rt << 1 | 1, mid + 1, r);
push_up(rt);
}
void upd(int rt, int l, int r, int p1, int q1, pair<int, int> tmp) {
if (tre[rt].mx < tmp.first) return;
if (l != r) pushdown(rt);
int mid = l + r >> 1;
if (p1 <= l && r <= q1) {
if (work(rt, tmp) || l == r)
return;
else {
upd(rt << 1, l, mid, p1, q1, tmp),
upd(rt << 1 | 1, mid + 1, r, p1, q1, tmp);
push_up(rt);
return;
}
}
if (p1 <= mid) upd(rt << 1, l, mid, p1, q1, tmp);
if (mid < q1) upd(rt << 1 | 1, mid + 1, r, p1, q1, tmp);
push_up(rt);
}
int query(int rt, int l, int r, int tt) {
if (l == r) return tre[rt].mx;
pushdown(rt);
int mid = l + r >> 1;
return (tt <= mid) ? query(rt << 1, l, mid, tt)
: query(rt << 1 | 1, mid + 1, r, tt);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &l, &r), lft[r] = l;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++)
scanf("%d%d", &x, &y), q[y].push_back(make_pair(i, x));
build(1, 1, n);
for (int i = 1; i <= n; i++) {
if (lft[i]) upd(1, 1, n, 1, lft[i], make_pair(lft[i], i));
int sz = q[i].size();
for (int j = 0; j < sz; j++)
ans[q[i][j].first] = query(1, 1, n, q[i][j].second);
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int L[1000000];
int Left[1000000];
int R[1000000];
int Next[1000000];
int Pr[1000000];
int Ans[1000000];
pair<int, pair<int, pair<int, int> > > a[1000000];
const int SZ = 3000;
set<pair<int, int> > S;
set<pair<int, int> >::iterator it;
void clean() { S.clear(); }
void add(int v) {
int l = L[v], r = R[v];
while (1) {
if (S.size() == 0) {
break;
}
it = S.lower_bound(make_pair(l, r));
if (it == S.end()) {
break;
}
int ll = it->first;
int rr = it->second;
if (r < ll || rr < l) {
break;
}
l = min(l, ll);
r = max(r, rr);
S.erase(it);
}
while (1) {
if (S.size() == 0) {
break;
}
it = S.lower_bound(make_pair(l, r));
if (it == S.begin()) {
break;
}
it--;
int ll = it->first;
int rr = it->second;
if (r < ll || rr < l) {
break;
}
l = min(l, ll);
r = max(r, rr);
S.erase(it);
}
S.insert(make_pair(l, r));
}
int main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> L[i] >> R[i];
Left[R[i]] = i;
Next[i] = Pr[L[i]];
Pr[L[i]] = i;
}
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
int l, r;
cin >> l >> r;
a[i].first = -r / SZ;
a[i].second.first = -l;
a[i].second.second.first = r;
a[i].second.second.second = i;
}
sort(a + 1, a + q + 1);
int pl = -1, pr = -1;
for (int i = 1; i <= q; i++) {
int l = -a[i].second.first;
int r = a[i].second.second.first;
int num = a[i].second.second.second;
if (i == 1 || pr / SZ != r / SZ) {
clean();
for (int i = l; i <= (r / SZ) * SZ - 1; i++) {
if (Left[i] > 0 && L[Left[i]] >= l) {
add(Left[i]);
}
}
} else {
for (int i = pl - 1; i >= l; i--) {
for (int j = Pr[i]; j; j = Next[j]) {
if (R[j] <= (r / SZ) * SZ - 1) {
add(j);
}
}
}
}
pl = l, pr = r;
int lo = l, hi = l;
if (S.size() > 0) {
if (S.begin()->first == lo) {
hi = S.begin()->second;
}
}
for (int i = (r / SZ) * SZ; i <= r; i++) {
if (Left[i] > 0 && L[Left[i]] >= l) {
if (L[Left[i]] <= hi) {
hi = max(hi, i);
}
}
}
Ans[num] = hi;
}
for (int i = 1; i <= q; i++) {
cout << Ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long mod = 1000000007;
const int N = 1e5 + 5, blksz = 400;
int jumpx[N];
int jumpblk[blksz][blksz];
void update(int x, int y) {
int blknm = x / blksz;
jumpx[x] = max(jumpx[x], y);
for (int i = blksz - 1; i >= 0; i--) {
if (jumpblk[blknm][i] >= x) {
jumpblk[blknm][i] = max(jumpblk[blknm][i], y);
}
}
}
void consturct(int n) {
for (int i = 1; i <= n; i++) {
jumpx[i] = i;
jumpblk[i / blksz][i % blksz] = i;
}
}
int query(int x, int y) {
int s = x;
int e = x;
while (s % blksz && s <= e) {
e = max(e, jumpx[s]);
s++;
}
if (s > e) return e;
while (s <= e) {
int at = e - s;
if (at >= blksz) at = blksz - 1;
e = max(e, jumpblk[s / blksz][at]);
s += blksz;
}
return e;
}
int res[N];
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, m;
cin >> n >> m;
vector<pair<int, int> > g(m);
for (int i = 0; i < m; i++) {
cin >> g[i].second >> g[i].first;
}
sort(g.begin(), g.end());
int q;
cin >> q;
vector<pair<int, pair<int, int> > > qur(q);
for (int i = 0; i < q; i++) {
cin >> qur[i].second.first >> qur[i].first, qur[i].second.second = i;
}
consturct(n);
sort(qur.begin(), qur.end());
for (int i = 0, indx = 0; i < (int)qur.size(); i++) {
while (indx < (int)g.size() && g[indx].first <= qur[i].first)
update(g[indx].second, g[indx].first), indx++;
res[qur[i].second.second] = query(qur[i].second.first, qur[i].first);
}
for (int i = 0; i < q; i++) cout << res[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int mi[maxn * 120], id[maxn * 120], lc[maxn * 120], rc[maxn * 120], tot = 0;
int n, m, q;
void up(int rt, int l, int r) {
int lp = lc[rt], rp = rc[rt];
if (lp == 0) {
mi[rt] = 0;
id[rt] = l;
return;
} else if (rp == 0) {
mi[rt] = 0;
if (lp == 0)
id[rt] = id[lp];
else
id[rt] = ((l + r) >> 1) + 1;
} else {
mi[rt] = min(mi[lp], mi[rp]);
if (mi[rt] == mi[lp])
id[rt] = id[lp];
else
id[rt] = id[rp];
}
return;
}
void update(int &rt, int l, int r, int L, int R) {
if (!rt) rt = ++tot, mi[rt] = 0, id[rt] = l;
if (L <= l && r <= R) {
mi[rt] = 1;
id[rt] = l;
return;
}
if (mi[rt] == 1) return;
if (L <= ((l + r) >> 1)) update(lc[rt], l, ((l + r) >> 1), L, R);
if (R > ((l + r) >> 1)) update(rc[rt], ((l + r) >> 1) + 1, r, L, R);
up(rt, l, r);
return;
}
int qry(int rt, int l, int r, int L, int R) {
if (!rt) {
return max(l, L);
}
if (mi[rt] == 1) return -1;
if (L <= l && r <= R) {
if (l == r) return l;
int res = qry(lc[rt], l, ((l + r) >> 1), L, R);
if (res == -1) res = qry(rc[rt], ((l + r) >> 1) + 1, r, L, R);
return res;
}
int res = -1;
if (L <= ((l + r) >> 1)) res = qry(lc[rt], l, ((l + r) >> 1), L, R);
if (R > ((l + r) >> 1) && res == -1)
res = qry(rc[rt], ((l + r) >> 1) + 1, r, L, R);
return res;
}
int T[maxn << 2];
void ins(int rt, int l, int r, int L, int R, int x, int y) {
if (L <= l && r <= R) {
update(T[rt], 1, n + 1, x, y);
return;
}
if (L <= ((l + r) >> 1)) ins(rt << 1, l, ((l + r) >> 1), L, R, x, y);
if (R > ((l + r) >> 1)) ins(rt << 1 | 1, ((l + r) >> 1) + 1, r, L, R, x, y);
return;
}
int qry(int rt, int l, int r, int pos) {
if (l == r) {
return qry(T[rt], 1, n + 1, pos, n + 1);
}
int res;
if (pos <= ((l + r) >> 1))
res = qry(rt << 1, l, ((l + r) >> 1), pos);
else
res = qry(rt << 1 | 1, ((l + r) >> 1) + 1, r, pos);
res = qry(T[rt], 1, n + 1, res, n + 1);
return res;
}
vector<int> h[maxn];
vector<pair<int, int> > g[maxn];
int ans[maxn];
int main() {
cin >> n >> m;
for (int i = (1); i < (m + 1); ++i) {
int x, y;
scanf("%d%d", &x, &y);
h[y].push_back(x);
}
cin >> q;
for (int i = (1); i < (q + 1); ++i) {
int x, y;
scanf("%d%d", &x, &y);
g[y].push_back(pair<int, int>(x, i));
}
for (int i = (1); i < (n + 1); ++i) {
for (int x : h[i])
if (x < i) ins(1, 1, n, 1, x, x, i - 1);
for (auto t : g[i]) {
int id = t.second;
ans[id] = qry(1, 1, n, t.first);
}
}
for (int i = (1); i < (q + 1); ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 1e5 + 5;
const int B = 350;
int rm[N][B];
int n, m;
int co[N];
int blk;
int g[N][B];
int sta[N], top;
int main() {
n = get();
m = get();
for (int i = 1; i <= m; i++) {
int l = get(), r = get();
co[r] = l;
}
blk = sqrt(n) + 1;
for (int i = 1; i <= n; i++) rm[i][0] = g[i][0] = i;
for (int x = 1; x * blk <= n; x++) {
for (int i = 1; i <= n; i++) rm[i][x] = rm[i][x - 1];
for (int i = (x - 1) * blk + 1; i <= x * blk; i++)
if (co[i]) rm[co[i]][x] = i;
for (int i = 1; i <= n; i++) g[i][x] = rm[i][x];
}
for (int x = 1; x * blk <= n; x++) {
top = 0;
for (int i = x * blk; i >= 1; i--) {
sta[++top] = i;
while (top && sta[top] < rm[i][x]) top--;
g[i][x] = (top ? sta[top] : 0);
}
}
for (int T = get(); T; T--) {
int l = get(), r = get();
int x = r / blk;
int now = g[l][x];
for (int i = x * blk + 1; i <= r; i++)
if (co[i] <= now && co[i] >= l) now = i;
printf("%d\n", now);
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 100005;
const int inf = 2e9;
using namespace std;
int n, m, pos[N], ans[N];
struct Query {
int l, r, id;
bool operator<(const Query &x) const { return r < x.r; }
} q[N];
inline int read() {
int f = 1, x = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f * x;
}
struct Segment_Tree_Beats {
int maxv[N << 2], tag[N << 2], cntv[N << 2], secv[N << 2];
inline void puttag(int o, int a, int b) {
if (maxv[o] >= a) {
maxv[o] = b;
tag[o] = b;
if (!cntv[o]) cntv[o] = 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 pushup(int o) {
maxv[o] = secv[o] = -1 << 30;
calc(maxv[o], secv[o], maxv[(o << 1)]);
calc(maxv[o], secv[o], secv[(o << 1)]);
calc(maxv[o], secv[o], maxv[(o << 1 | 1)]);
calc(maxv[o], secv[o], secv[(o << 1 | 1)]);
}
inline void pushdown(int o) {
if (!tag[o]) return;
puttag((o << 1), cntv[o], tag[o]);
puttag((o << 1 | 1), cntv[o], tag[o]);
tag[o] = 0;
cntv[o] = 0;
}
inline void build(int o, int l, int r) {
if (l == r) {
maxv[o] = l;
secv[o] = -1 << 30;
return;
}
int mid = (l + r) >> 1;
build((o << 1), l, mid);
build((o << 1 | 1), mid + 1, r);
pushup(o);
}
inline void change(int o, int l, int r, int ql, int qr, int a, int b) {
if (maxv[o] < a) return;
if (ql <= l && r <= qr && secv[o] < a) {
puttag(o, a, b);
return;
}
pushdown(o);
int mid = (l + r) >> 1;
if (ql <= mid) change((o << 1), l, mid, ql, qr, a, b);
if (qr > mid) change((o << 1 | 1), mid + 1, r, ql, qr, a, b);
pushup(o);
}
inline int query(int o, int l, int r, int q) {
if (l == r) return maxv[o];
pushdown(o);
int mid = (l + r) >> 1;
if (q <= mid)
return query((o << 1), l, mid, q);
else
return query((o << 1 | 1), mid + 1, r, q);
}
} T;
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int l = read(), r = read();
pos[r] = l;
}
int Q = read();
for (int i = 1; i <= Q; i++) {
q[i].l = read();
q[i].r = read();
q[i].id = i;
}
sort(q + 1, q + Q + 1);
T.build(1, 1, n);
int cur = 1;
for (int i = 1; i <= n; i++) {
if (pos[i]) T.change(1, 1, n, 1, pos[i], pos[i], i);
for (; cur <= Q && q[cur].r == i; cur++)
ans[q[cur].id] = T.query(1, 1, n, q[cur].l);
}
for (int i = 1; i <= Q; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2,fma")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long maxn = 1e5 + 100;
const long long mod = 1e9 + 7;
const long double PI = acos((long double)-1);
long long pw(long long a, long long b, long long md = mod) {
long long res = 1;
while (b) {
if (b & 1) {
res = (a * res) % md;
}
a = (a * a) % md;
b >>= 1;
}
return (res);
}
int n, m, t;
int l[maxn];
vector<int> r[maxn];
vector<pair<int, int> > q[maxn];
int ans[maxn];
int mx[maxn * 4];
void build(int v = 1, int l = 1, int r = n + 1) {
mx[v] = 1e9;
if (r - l == 1) return;
build((v << 1), l, ((l + r) >> 1));
build(((v << 1) | 1), ((l + r) >> 1), r);
}
void shift(int v, int l, int r) {
if (r - l == 1) return;
mx[(v << 1)] = min(mx[(v << 1)], mx[v]);
mx[((v << 1) | 1)] = min(mx[((v << 1) | 1)], mx[v]);
}
int query(int L, int R, int x, int v = 1, int l = 1, int r = n + 1) {
shift(v, l, r);
if (mx[v] <= x or r <= L or R <= l) return (1e9);
if (L <= l) {
for (; r - l > 1;) {
if (mx[(v << 1)] > x)
v = (v << 1), r = ((l + r) >> 1);
else
v = ((v << 1) | 1), l = ((l + r) >> 1);
}
return (l);
}
int res = query(L, R, x, (v << 1), l, ((l + r) >> 1));
if (res < 1e9) return (res);
return (query(L, R, x, ((v << 1) | 1), ((l + r) >> 1), r));
}
void update(int L, int R, int x, int v = 1, int l = 1, int r = n + 1) {
shift(v, l, r);
if (r <= L or R <= l) return;
if (L <= l and r <= R) {
mx[v] = min(mx[v], x);
shift(v, l, r);
return;
}
update(L, R, x, (v << 1), l, ((l + r) >> 1));
update(L, R, x, ((v << 1) | 1), ((l + r) >> 1), r);
mx[v] = max(mx[(v << 1)], mx[((v << 1) | 1)]);
}
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
if (a == b) continue;
l[b] = a;
r[a].push_back(b);
}
cin >> t;
for (int i = 1; i <= t; i++) {
int a, b;
cin >> a >> b;
q[a].push_back({b, i});
}
build();
for (int i = n; i; i--) {
for (auto R : r[i]) update(i, R, R);
for (auto [R, ind] : q[i]) ans[ind] = query(i, R + 1, R);
}
for (int i = 1; i <= t; i++) cout << ans[i] << '\n';
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename num_t>
inline void addmod(num_t& a, const long long& b, const int& m) {
a = (a + b) % m;
if (a < 0) a += m;
}
template <typename num_t>
inline void update_max(num_t& a, const num_t& b) {
a = max(a, b);
}
template <typename num_t>
inline void update_min(num_t& a, const num_t& b) {
a = min(a, b);
}
template <typename num_t>
num_t gcd(num_t lhs, num_t rhs) {
return !lhs ? rhs : gcd(rhs % lhs, lhs);
}
template <typename num_t>
num_t pw(num_t n, num_t k, num_t mod) {
long long res = 1;
for (; k; k >>= 1) {
if (k & 1) res = res * n % mod;
n = 1ll * n * n % mod;
}
return (num_t)res;
}
const int inf = 1e9 + 7;
const long long ll_inf = 1ll * inf * inf;
const int MAX_N = 100000 + 7;
const int mod = 998244353;
int n, m;
vector<int> robe[MAX_N];
vector<pair<int, int>> query[MAX_N];
int ans[MAX_N];
const int MAGIC = 2000;
struct Block {
int left_index, right_index;
int nxt[MAX_N], rev[MAX_N];
set<int> current_state;
int max_merge = 0;
void init() {
for (int j = left_index; j <= right_index; ++j) {
rev[j] = j;
current_state.insert(j);
}
}
void merge(int right, int last) {
if (*current_state.rbegin() < right || max_merge == last) return;
bool found = false;
while (true) {
auto it = current_state.lower_bound(right);
if (it == current_state.end() || *it == last) break;
nxt[*it] = last;
current_state.erase(it);
found = true;
}
if (found) current_state.insert(last);
max_merge = last;
}
int get_state(int u) {
return (nxt[u] == 0) ? u : nxt[u] = get_state(nxt[u]);
}
int get_f(int u) {
int temp = rev[u];
return get_state(temp);
}
void fix(int u, int v, int right, int last) {
bool found = false;
for (int j = u; j <= v; ++j) {
int temp = rev[j];
if (get_state(temp) < right) continue;
rev[j] = last;
found = true;
}
if (found) current_state.insert(last);
}
};
Block block[MAX_N / MAGIC + 7];
int k = 0;
void solve() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
robe[v].push_back(u);
}
int q;
cin >> q;
for (int t = 0; t < q; ++t) {
int u, v;
cin >> u >> v;
query[v].push_back({u, t});
}
for (int i = 1; i <= n; ++i) {
if (i == 1 || i / MAGIC != (i - 1) / MAGIC) {
k = i / MAGIC;
block[k].left_index = i;
block[k].right_index = min(n, i + MAGIC - 1);
block[k].init();
}
}
for (int i = 1; i <= n; ++i) {
for (auto v : robe[i]) {
for (int t = 0; t <= k; ++t)
if (block[t].right_index <= v) {
block[t].merge(v, i);
} else if (block[t].left_index <= v) {
block[t].fix(block[t].left_index, v, v, i);
} else
break;
}
for (auto p : query[i]) {
int v = p.first;
int idx = p.second;
ans[idx] = block[v / MAGIC].get_f(v);
}
}
for (int t = 0; t < q; ++t) cout << ans[t] << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
|
#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 SegmentBeat {
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;
int n, m;
vector<int> v[100005];
int cur[100005], back[100005], f[100005][320];
inline bool cmp(int a, int b) { return a > b; }
int main() {
int lp, rp, q, i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &lp, &rp);
v[lp].push_back(rp);
back[rp] = lp;
}
for (i = 1; i <= n; i++) {
sort(v[i].begin(), v[i].end(), cmp);
}
for (i = 320; i <= n; i += 320) {
int id = i / 320;
for (j = 1; j <= n; j++) {
while (!v[j].empty() && v[j].back() <= i) {
cur[j] = v[j].back();
v[j].pop_back();
}
}
f[i][id] = i;
stack<int> s;
s.push(i);
for (j = i - 1; j >= 1; j--) {
f[j][id] = j;
while (!s.empty() && s.top() <= cur[j]) {
f[j][id] = max(f[j][id], f[s.top()][id]);
s.pop();
}
s.push(j);
}
}
scanf("%d", &q);
for (i = 1; i <= q; i++) {
scanf("%d%d", &lp, &rp);
int x = max(lp, f[lp][(rp - 1) / 320]);
for (j = max(lp, (rp - 1) / 320 * 320); j <= rp; j++) {
if (back[j] >= lp && back[j] <= x) {
x = j;
}
}
printf("%d\n", x);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, pos = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') pos = 0;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
return pos ? x : -x;
}
const int N = 1e5 + 200;
pair<int, int> p[N];
int cmp(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
pair<int, int> stk[N];
vector<int> G[N];
int f[112][N], g[N];
int c[N], B, maxr, n, m;
void add(int x, int w) {
for (; x <= maxr; x += x & (-x)) c[x] = max(c[x], w);
}
int query(int x) {
int res = 0;
for (; x; x -= x & (-x)) res = max(res, c[x]);
return res;
}
int calc(int l, int r, int ql, int qr) {
for (int j = ql; j <= qr; ++j) {
if (l <= g[j] && g[j] <= r) r = j;
}
return r;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; ++i) {
p[i].first = read(), p[i].second = read();
G[p[i].first].push_back(p[i].second);
g[p[i].second] = p[i].first;
}
for (int i = 1; i <= n; ++i) {
if (G[i].size()) sort(G[i].begin(), G[i].end());
}
sort(p + 1, p + m + 1);
B = sqrt(n * 10);
for (int i = 0; i <= n / B; ++i) {
int l = i * B, r = min(n, (i + 1) * B - 1);
maxr = r;
if (l > r) continue;
for (int j = 1; j <= r; ++j) f[i][j] = j, c[j] = 0;
for (int j = r; j >= 1; --j) {
for (int k = 0; k < (int)G[j].size(); k++) {
if ((k + 1 != (int)G[j].size() && (int)G[j][k + 1] > maxr) ||
k + 1 == (int)G[j].size()) {
if (G[j][k] <= maxr) f[i][j] = max(G[j][k], query(G[j][k]));
break;
}
}
if (f[i][j]) {
add(j, f[i][j]);
}
}
}
int q = read();
for (int i = 1; i <= q; ++i) {
int ql = read(), qr = read();
int l = ql / B, r = qr / B;
if (l == r) {
printf("%d\n", calc(ql, ql, ql, qr));
} else {
printf("%d\n", calc(ql, f[r - 1][ql], r * B, qr));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void in(T &x) {
T c = getchar();
while (((c < 48) || (c > 57)) && (c != '-')) c = getchar();
bool neg = false;
if (c == '-') neg = true;
x = 0;
for (; c < 48 || c > 57; c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) x = (x * 10) + (c - 48);
if (neg) x = -x;
}
const int MAXN = 1e5 + 100;
const int MAGIC = 330;
int from[MAXN];
pair<int, int> ropes[MAXN];
int go[MAXN][MAGIC];
int to[MAXN][MAGIC];
int n, q, ht;
int k;
inline void smax(int &a, int b) { a = max(a, b); }
inline void smin(int &a, int b) { a = min(a, b); }
int main() {
in(ht);
k = sqrt(ht);
in(n);
for (int i = 1; i <= n; i++) {
in(ropes[i].first), in(ropes[i].second);
from[ropes[i].second] = ropes[i].first;
smax(to[ropes[i].first][1 + (ropes[i].second - 1) / k], ropes[i].second);
}
for (int i = 1; i <= ht; i++) {
for (int j = 1; j * k <= ht; j++) {
smax(to[i][j], to[i][j - 1]);
}
}
for (int j = 1; j * k <= ht; j++) {
stack<int> s;
for (int i = j * k; i > 0; i--) {
go[i][j] = to[i][j];
while (s.size() && s.top() <= to[i][j]) {
smax(go[i][j], go[s.top()][j]);
s.pop();
}
s.push(i);
}
}
int q, x, y;
in(q);
while (q--) {
in(x), in(y);
int res = x;
int up_k = (y - 1) / k;
smax(res, go[x][up_k]);
for (int i = up_k * k + 1; i <= y; i++) {
if (from[i] <= res && from[i] >= x) {
res = i;
}
}
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace SHENZHEBEI {
inline char gc() { return getchar(); }
inline int read() {
int x = 0, fa = 1;
char ch = gc();
for (; !isdigit(ch); ch = gc())
if (ch == '-') fa = -1;
for (; isdigit(ch); ch = gc()) x = x * 10 - 48 + ch;
return x * fa;
}
inline void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(int x) {
write(x);
puts("");
}
void Print(long long *a, int s, int t) {
for (int i = s; i <= t; ++i) printf("%lld ", a[i]);
}
void Print(int *a, int s, int t) {
for (int i = s; i <= t; ++i) printf("%d ", a[i]);
}
void Print(char *a, int s, int t) {
for (int i = s; i <= t; ++i) putchar(a[i]);
}
} // namespace SHENZHEBEI
using namespace SHENZHEBEI;
int top, cnt, m, k, Q, Left[1000010], q[1000010], lzh[2000010], L[4000010],
R[4000010], guyue[20000010], naer[20000010], fa[1000010], n, ans, x, y;
int max(int x, int y) { return x > y ? x : y; }
inline int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
inline void Max(int &x, int y) { x = x < y ? y : x; }
void build(int l, int r, int p) {
top = 0;
for (int i = l; i <= r; ++i)
if (Left[i] && Left[i] < l) q[++top] = Left[i];
sort(q + 1, q + top + 1);
top = unique(q + 1, q + top + 1) - 1 - q;
for (int i = 1; i <= top; ++i) lzh[i] = 0;
for (int i = l; i <= r + 1; ++i) fa[i] = i;
for (int i = r; i >= l; --i)
if (Left[i]) {
if (Left[i] < l)
Max(lzh[lower_bound(q + 1, q + top + 1, Left[i]) - q], find(i));
else
for (int j = find(Left[i]); j < i; j = find(j + 1)) fa[j] = i;
}
L[p] = cnt + 1;
for (int i = top - 1; i >= 1; --i) Max(lzh[i], lzh[i + 1]);
for (int i = 1; i <= top; ++i) naer[++cnt] = lzh[i], guyue[cnt] = q[i];
R[p] = cnt;
if (l == r) return;
int mid = (l + r) >> 1;
build(mid + 1, r, p << 1 | 1);
build(l, mid, p << 1);
}
inline void query(int l, int r, int s, int t) {
int pos = lower_bound(guyue + l, guyue + r + 1, s) - guyue;
if ((pos <= r) && (guyue[pos] <= t)) ans = naer[pos];
}
void Query(int l, int r, int p, int s, int t) {
if (s <= l && r <= t) return query(L[p], R[p], x, ans), void(0);
int mid = (l + r) >> 1;
if (s <= mid) Query(l, mid, p << 1, s, t);
if (t > mid) Query(mid + 1, r, p << 1 | 1, s, t);
}
int main() {
n = read(), k = read();
for (; k--;) {
int x = read(), y = read();
if (x ^ y) Left[y] = x;
}
Q = read();
if (n > 1) {
int mid = (1 + n) / 2;
build(1, mid, 2);
build(mid + 1, n, 3);
}
for (; Q--;) {
x = read(), y = read();
ans = x;
if (x == y)
writeln(y);
else {
Query(1, n, 1, x + 1, y);
writeln(ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, B = 321;
inline void read(int &x) {
x = 0;
char ch = getchar();
while (ch > '9' || ch < '0') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
}
int n, m, top, Q, go[N], to[N], s[N], dp[321][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y;
read(x);
read(y);
go[y] = x;
}
for (int i = 1; i * B <= n; i++) {
for (int j = (i - 1) * B + 1; j <= i * B; j++) to[go[j]] = j;
top = 0;
for (int j = i * B; j; j--) {
dp[i][j] = j;
while (top && s[top] <= to[j]) {
dp[i][j] = dp[i][s[top]];
top--;
}
s[++top] = j;
}
}
scanf("%d", &Q);
for (int i = 1; i <= Q; i++) {
int x, y, k;
read(x);
read(y);
if (x <= y / B * B)
k = dp[y / B][x];
else
k = x;
for (int j = max(y / B * B + 1, x); j <= y; j++)
if (go[j] >= x && go[j] <= k) k = j;
printf("%d\n", k);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, inf = 1e18;
int n, m, q, l, r, seg[4 * N], lazy[4 * N], ans[N];
vector<int> vec[N];
vector<pair<int, int> > Q[N];
void relax(int id) {
seg[2 * id] = min(seg[2 * id], lazy[id]);
seg[2 * id + 1] = min(seg[2 * id + 1], lazy[id]);
lazy[2 * id] = min(lazy[2 * id], lazy[id]);
lazy[2 * id + 1] = min(lazy[2 * id + 1], lazy[id]);
lazy[id] = n;
}
void upd(int s, int e, int id, int L, int R, int val) {
long long mid = (L + R) / 2;
if (s <= L && R <= e) {
seg[id] = min(seg[id], val);
lazy[id] = min(lazy[id], val);
return;
}
if (e <= L || R <= s) {
return;
}
relax(id);
upd(s, e, 2 * id, L, mid, val);
upd(s, e, 2 * id + 1, mid, R, val);
seg[id] = max(seg[2 * id], seg[2 * id + 1]);
}
pair<int, int> get(int s, int e, int id, int L, int R, int val) {
long long mid = (L + R) / 2;
if (s <= L && R <= e) {
if (R - L < 2 || seg[id] <= val) return {seg[id], L + 1};
relax(id);
if (seg[2 * id] > val)
return get(s, e, 2 * id, L, mid, val);
else
return get(s, e, 2 * id + 1, mid, R, val);
}
if (e <= L || R <= s || seg[id] <= val) {
return {-1, -1};
}
relax(id);
pair<int, int> P = get(s, e, 2 * id, L, mid, val);
if (P.first > val)
return P;
else
return get(s, e, 2 * id + 1, mid, R, val);
}
int main() {
scanf("%d %d", &n, &m);
fill(lazy, lazy + 4 * N, n);
fill(seg, seg + 4 * N, n);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &l, &r);
l--;
r--;
vec[l].push_back(r);
}
cin >> q;
for (int i = 1; i <= q; i++) {
scanf("%d %d", &l, &r);
l--;
r--;
Q[l].push_back({r, i});
}
for (int i = n - 1; i >= 0; i--) {
for (auto X : vec[i]) upd(i, X, 1, 0, n, X);
for (auto X : Q[i])
ans[X.second] = get(i, X.first + 1, 1, 0, n, X.first).second;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100005;
int n, m, q, ans[Maxn];
vector<int> R[Maxn];
vector<pair<int, int> > Q[Maxn];
struct Tree {
int lt, rt;
pair<int, int> maxi, tag;
} tree[4 * Maxn];
pair<int, int> merge(pair<int, int> x, pair<int, int> y) {
int tmp[] = {x.first, x.second, y.first, y.second};
sort(tmp, tmp + 4, greater<int>());
if (unique(tmp, tmp + 4) - tmp - 1 == 1) return make_pair(tmp[0], 0);
return make_pair(tmp[0], tmp[1]);
}
void build(int root, int lt, int rt) {
tree[root] = (Tree){lt, rt};
tree[root].tag = make_pair(0x3f3f3f3f, 0);
if (lt + 1 == rt)
tree[root].maxi.first = lt;
else {
int mid = (lt + rt) >> 1;
build(root << 1, lt, mid);
build(root << 1 | 1, mid, rt);
tree[root].maxi = merge(tree[root << 1].maxi, tree[root << 1 | 1].maxi);
}
}
pair<int, int> tag_merge(pair<int, int> x, pair<int, int> y) {
return make_pair(min(x.first, y.first), max(x.second, y.second));
}
void pushdown(int root) {
if (tree[root << 1].maxi.first >= tree[root].tag.first) {
tree[root << 1].maxi.first = tree[root].tag.second;
tree[root << 1].tag = tag_merge(tree[root].tag, tree[root << 1].tag);
}
if (tree[root << 1 | 1].maxi.first >= tree[root].tag.first) {
tree[root << 1 | 1].maxi.first = tree[root].tag.second;
tree[root << 1 | 1].tag =
tag_merge(tree[root].tag, tree[root << 1 | 1].tag);
}
tree[root].tag = make_pair(0x3f3f3f3f, 0);
}
void modify(int root, int lt, int rt, int w, int val) {
if (lt == tree[root].lt && rt == tree[root].rt) {
if (lt + 1 == rt) {
if (tree[root].maxi.first >= w) tree[root].maxi.first = val;
} else {
int mid = (lt + rt) >> 1;
if (w > tree[root].maxi.first) return;
if (w > tree[root].maxi.second)
tree[root].maxi.first = val,
tree[root].tag = tag_merge(tree[root].tag, make_pair(w, val));
else {
pushdown(root);
modify(root << 1, lt, mid, w, val),
modify(root << 1 | 1, mid, rt, w, val);
tree[root].maxi = merge(tree[root << 1].maxi, tree[root << 1 | 1].maxi);
}
}
} else {
pushdown(root);
int mid = (tree[root].lt + tree[root].rt) >> 1;
if (lt >= mid)
modify(root << 1 | 1, lt, rt, w, val);
else if (rt <= mid)
modify(root << 1, lt, rt, w, val);
else
modify(root << 1, lt, mid, w, val),
modify(root << 1 | 1, mid, rt, w, val);
tree[root].maxi = merge(tree[root << 1].maxi, tree[root << 1 | 1].maxi);
}
}
int ask(int root, int pos) {
if (tree[root].lt + 1 == tree[root].rt)
return tree[root].maxi.first;
else {
pushdown(root);
int mid = (tree[root].lt + tree[root].rt) >> 1;
if (pos >= mid)
return ask(root << 1 | 1, pos);
else
return ask(root << 1, pos);
}
}
int main() {
scanf("%d%d", &n, &m);
build(1, 1, n + 1);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
R[y].push_back(x);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int x, y;
scanf("%d%d", &x, &y);
Q[y].push_back(make_pair(x, i));
}
for (int i = 1; i <= n; i++) {
for (vector<int>::iterator it = R[i].begin(); it != R[i].end(); it++)
modify(1, 1, *it + 1, *it, i);
for (vector<pair<int, int> >::iterator it = Q[i].begin(); it != Q[i].end();
it++)
ans[it->second] = ask(1, it->first);
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
const int maxn = (1 << 21) + 3;
const int INF = 0x3f3f3f3f;
struct segtree {
int n;
int tag[maxn], mmin[maxn];
int ul, ur, uv;
void update(int o, int l, int r) {
if (ul <= l && ur >= r) {
tag[o] = max(tag[o], uv);
mmin[o] = max(mmin[o], uv);
return;
}
int mid = (l + r) / 2;
if (ul <= mid) update(o * 2, l, mid);
if (ur > mid) update(o * 2 + 1, mid + 1, r);
mmin[o] = max(min(mmin[o * 2], mmin[o * 2 + 1]), tag[o]);
}
void modify(int l, int r, int v) {
if (l > r) return;
ul = l, ur = r, uv = v;
update(1, 1, n);
}
int p, x;
int query2(int o, int l, int r) {
if (mmin[o] >= x) return n + 1;
if (l == r) return l;
int mid = (l + r) / 2;
if (mmin[o * 2] < x)
return query2(o * 2, l, mid);
else
return query2(o * 2 + 1, mid + 1, r);
}
int query(int o, int l, int r) {
if (mmin[o] >= x) return n + 1;
if (l == r) return l;
int mid = (l + r) / 2;
if (p > mid)
return query(o * 2 + 1, mid + 1, r);
else {
int ans = query(o * 2, l, mid);
if (ans != n + 1)
return ans;
else
return query2(o * 2 + 1, mid + 1, r);
}
}
int query(int p, int x) {
if (p > n) return n + 1;
this->p = p, this->x = x;
return query(1, 1, n);
}
} t;
struct edge {
int l, r;
bool operator<(const edge& rhs) const { return r < rhs.r; }
} e[maxn];
struct query {
int id, x, y;
bool operator<(const query& rhs) const { return y < rhs.y; }
} q[maxn];
int ans[maxn];
void write(int x) {
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(int x) {
write(x);
putchar('\n');
}
int main() {
int n = t.n = read(), k = read();
for (int i = 1; i <= k; i++) e[i].l = read(), e[i].r = read();
sort(e + 1, e + k + 1);
int m = read();
for (int i = 1; i <= m; i++) q[i].id = i, q[i].x = read(), q[i].y = read();
sort(q + 1, q + m + 1);
int now = 1;
for (int i = 1; i <= m; i++) {
while (now <= k && e[now].r <= q[i].y) {
t.modify(e[now].l + 1, e[now].r, e[now].l);
now++;
}
ans[q[i].id] = min(t.query(q[i].x + 1, q[i].x), q[i].y + 1) - 1;
}
for (int i = 1; i <= m; i++) writeln(ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x[100005];
vector<int> g[100005];
int c[100005];
int w[318][100001];
int main() {
scanf("%d%d", &n, &m);
memset(x, -1, sizeof(x));
for (int i = 0; i < (m); i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
g[a].push_back(b);
x[b] = a;
}
for (int i = 0; i < (n); i++) sort(g[i].begin(), g[i].end());
for (int k = 0; k * 317 < n; ++k) {
w[k][k * 317] = k * 317;
stack<pair<int, int> > st;
st.push(make_pair(k * 317, k * 317));
for (int i = k * 317 - 1; i >= 0; --i) {
while (c[i] < g[i].size() && g[i][c[i]] <= k * 317) c[i]++;
if (c[i]) {
c[i]--;
int j = g[i][c[i]];
assert(j <= k * 317);
while (!st.empty() && st.top().first <= j)
j = max(j, st.top().second), st.pop();
w[k][i] = j;
st.push(make_pair(i, j));
} else
w[k][i] = i;
}
}
int q;
scanf("%d", &q);
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
int j = b / 317 * 317, r, i;
if (j >= a)
i = j, r = w[b / 317][a];
else
i = r = a;
while (i < b) {
i++;
if (x[i] >= a && x[i] <= r) r = i;
}
printf("%d\n", r + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int k = 400;
int start[100000];
vector<int> kdfgh[100000];
int reach[400][100000];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) start[i] = i;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
l--, r--;
start[r] = l;
kdfgh[l].push_back(r);
}
for (int r = 0; r < n; r += k) {
vector<pair<int, int>> deq;
int* a = reach[r / k];
for (int l = 0; l < n; l++) a[l] = l;
for (int l = r - 1; l >= 0; l--) {
for (int e : kdfgh[l]) {
if (e <= r) a[l] = max(a[l], e);
}
while (deq.size() && a[l] >= deq.back().first) {
a[l] = max(a[l], deq.back().second);
deq.pop_back();
}
deq.push_back({l, a[l]});
}
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
l--, r--;
int x = reach[r / k][l];
for (int i = max(r / k * k + 1, l); i <= r; i++) {
if (x >= start[i] && start[i] >= l) x = max(x, i);
}
cout << x + 1 << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int p[100100], t[100100];
int id[100100], L[100100], R[100100], ans[100100];
bool cmp(int i, int j) { return R[i] < R[j]; }
struct RMQ_Tree {
int n;
int mx[1 << 20];
void init(int _n) {
for (n = 1; n < _n; n <<= 1)
;
for (int i = n << 1; --i;) mx[i] = 0;
}
void insert(int p, int val) {
p += n - 1;
for (; p && val > mx[p]; p >>= 1) mx[p] = val;
}
int calc(int st, int ed) {
if (st > ed) return 0;
st += n - 1;
ed += n;
int ans = 0;
while (st < ed) {
if (st & 1) smax(ans, mx[st++]);
if (ed & 1) smax(ans, mx[ed ^ 1]);
st >>= 1;
ed >>= 1;
}
return ans;
}
} Tree;
int find_root(int l, int r) {
if (l == r) return l;
int nr = Tree.calc(l, r);
if (r >= nr) return r;
return find_root(l, nr);
}
int main() {
int n, m, q;
gn(n, m);
Tree.init(n);
for (int i = 1; i <= n; i++) p[i] = i, t[i] = i;
for (int i = 0; i < m; i++) {
int first, second;
gn(first, second);
p[second] = first;
}
gn(q);
for (int i = 0; i < q; i++) {
gn(L[i], R[i]);
id[i] = i;
}
sort(id, id + q, cmp);
for (int i = 1, j = 0; i <= n; i++) {
Tree.insert(p[i], i);
smax(t[p[i]], i);
while (j < q && R[id[j]] == i) {
ans[id[j]] = find_root(L[id[j]], t[L[id[j]]]);
Tree.insert(L[id[j]], ans[id[j]]);
j++;
}
}
for (int i = 0; i < q; i++) println(ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
class node {
public:
int x;
node() { x = 1e9; }
};
node operator+(node x, node y) {
node res;
res.x = max(x.x, y.x);
return res;
}
node tree[N << 2];
int lazy[N << 2];
void doit(int x, int v) {
if (!v) return;
if (!lazy[x])
lazy[x] = v;
else
lazy[x] = min(lazy[x], v);
tree[x].x = min(tree[x].x, v);
}
void push(int x) {
doit(x + x, lazy[x]);
doit(x + x + 1, lazy[x]);
lazy[x] = 0;
}
void update(int x, int l, int r, int x1, int x2, int d) {
if (x2 < l or r < x1) return;
if (x1 <= l and r <= x2) {
doit(x, d);
return;
}
push(x);
int m = (l + r) >> 1;
update(x + x, l, m, x1, x2, d);
update(x + x + 1, m + 1, r, x1, x2, d);
tree[x] = tree[x + x] + tree[x + x + 1];
}
int query(int x, int l, int r, int x1, int x2, int k) {
if (r < x1 or x2 < l or tree[x].x <= k) return -1;
if (l == r) {
return tree[x].x > k ? l : -1;
}
int m = (l + r) >> 1;
push(x);
int res = query(x + x, l, m, x1, x2, k);
if (res == -1) res = query(x + x + 1, m + 1, r, x1, x2, k);
return res;
}
int n, m, q;
vector<int> rope[N];
vector<pair<int, int> > qu[N];
int ans[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d %d", &l, &r);
rope[l].push_back(r);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d %d", &l, &r);
qu[l].push_back({r, i});
}
for (int l = n; l >= 1; l--) {
for (auto r : rope[l]) update(1, 1, n, l, r - 1, r);
for (auto tmp : qu[l]) {
int r, id;
tie(r, id) = tmp;
int res = query(1, 1, n, l, r - 1, r);
if (res == -1) res = r;
ans[id] = res;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int x = 0;
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
const int maxn = (1 << 21) + 3;
const int INF = 0x3f3f3f3f;
struct segtree {
int n;
int tag[maxn], mmin[maxn];
int ul, ur, uv;
void update(int o, int l, int r) {
if (ul <= l && ur >= r) {
tag[o] = max(tag[o], uv);
mmin[o] = max(mmin[o], uv);
return;
}
int mid = (l + r) / 2;
if (ul <= mid) update(o * 2, l, mid);
if (ur > mid) update(o * 2 + 1, mid + 1, r);
mmin[o] = max(min(mmin[o * 2], mmin[o * 2 + 1]), tag[o]);
}
void modify(int l, int r, int v) {
if (l > r) return;
ul = l, ur = r, uv = v;
update(1, 1, n);
}
int p, x;
int query2(int o, int l, int r) {
if (max(tag[o], mmin[o]) >= x) return n + 1;
if (l == r) return l;
int mid = (l + r) / 2;
if (mmin[o * 2] < x)
return query2(o * 2, l, mid);
else
return query2(o * 2 + 1, mid + 1, r);
}
int query(int o, int l, int r) {
if (max(tag[o], mmin[o]) >= x) return n + 1;
if (l == r) return l;
int mid = (l + r) / 2;
if (p > mid)
return query(o * 2 + 1, mid + 1, r);
else {
int ans = query(o * 2, l, mid);
if (ans != n + 1)
return ans;
else
return query2(o * 2 + 1, mid + 1, r);
}
}
int query(int p, int x) {
if (p > n) return n + 1;
this->p = p, this->x = x;
return query(1, 1, n);
}
} t;
struct edge {
int l, r;
bool operator<(const edge& rhs) const { return r < rhs.r; }
} e[maxn];
struct query {
int id, x, y;
bool operator<(const query& rhs) const { return y < rhs.y; }
} q[maxn];
int ans[maxn];
void write(int x) {
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(int x) {
write(x);
putchar('\n');
}
int main() {
int n = t.n = read(), k = read();
for (int i = 1; i <= k; i++) e[i].l = read(), e[i].r = read();
sort(e + 1, e + k + 1);
int m = read();
for (int i = 1; i <= m; i++) q[i].id = i, q[i].x = read(), q[i].y = read();
sort(q + 1, q + m + 1);
int now = 1;
for (int i = 1; i <= m; i++) {
while (now <= k && e[now].r <= q[i].y) {
t.modify(e[now].l + 1, e[now].r, e[now].l);
now++;
}
ans[q[i].id] = t.query(q[i].x + 1, q[i].x) - 1;
}
for (int i = 1; i <= m; i++) writeln(ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int X = 0;
char ch = 0, fl = 0;
while (ch < 48 || ch > 57) ch = getchar(), fl |= (ch == '-');
while (ch >= 48 && ch <= 57) X = X * 10 + (ch ^ 48), ch = getchar();
return fl ? -X : X;
}
struct Node {
int mx, mx2;
void ladd(int tg) { mx = tg; }
} a[1 << 18 | 500];
inline void up(int u) {
int l = u << 1, r = u << 1 | 1;
if (a[l].mx == a[r].mx) {
a[u].mx = a[l].mx;
a[u].mx2 = max(a[l].mx2, a[r].mx2);
} else if (a[l].mx < a[r].mx) {
a[u].mx = a[r].mx;
a[u].mx2 = max(a[l].mx, a[r].mx2);
} else {
a[u].mx = a[l].mx;
a[u].mx2 = max(a[l].mx2, a[r].mx);
}
}
void build(int l, int r, int u) {
if (l == r) {
a[u].mx = l;
return;
}
int mid = (l + r) >> 1;
build(l, mid, u << 1);
build(mid + 1, r, u << 1 | 1);
up(u);
}
inline void ladd(int u) {
if (a[u << 1].mx > a[u].mx2) a[u << 1].ladd(a[u].mx);
if (a[u << 1 | 1].mx > a[u].mx2) a[u << 1 | 1].ladd(a[u].mx);
}
int wfl, wfr, wfcl, wfcr;
void chg(int l, int r, int u) {
if (a[u].mx < wfcl) return;
if (wfl <= l && r <= wfr && a[u].mx2 < wfcl) {
a[u].ladd(wfcr);
return;
}
int mid = (l + r) >> 1;
ladd(u);
if (wfl <= mid) chg(l, mid, u << 1);
if (mid < wfr) chg(mid + 1, r, u << 1 | 1);
up(u);
}
int to;
int qry(int l, int r, int u) {
if (l == r) return a[u].mx;
int mid = (l + r) >> 1;
ladd(u);
if (to <= mid) return qry(l, mid, u << 1);
return qry(mid + 1, r, u << 1 | 1);
}
vector<int> g[100500];
struct Data {
int l, p;
};
vector<Data> b[100500];
int n, m, q, ans[100500];
int main() {
n = read();
m = read();
for (int i = 1, l, r; i <= m; i++) {
l = read();
r = read();
g[r].push_back(l);
}
q = read();
for (int i = 1, l, r; i <= q; i++) {
l = read();
r = read();
b[r].push_back((Data){l, i});
}
build(1, n, 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < g[i].size(); j++) {
wfl = 1;
wfr = wfcl = g[i][j];
wfcr = i;
chg(1, n, 1);
}
for (int j = 0; j < b[i].size(); j++) {
to = b[i][j].l;
ans[b[i][j].p] = qry(1, n, 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 = 1e5 + 5;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long sq(long long x) { return (x * x) % MOD; }
long long modP(long long a, long long b) {
return (!b ? 1 : (sq(modP(a, b / 2)) * (b % 2 ? a : 1)) % MOD);
}
int n, res[maxN];
int seg[4 * maxN], lazy[4 * maxN];
vector<int> S[maxN];
vector<pair<int, int> > Q[maxN];
void apply(int id, int x) {
seg[id] = min(seg[id], x);
lazy[id] = min(lazy[id], x);
return;
}
void shift(int id) {
apply(2 * id, lazy[id]);
apply(2 * id + 1, lazy[id]);
lazy[id] = MOD;
return;
}
void update(int l, int r, int x, int id = 1, int s = 0, int e = n) {
if (l <= s && e <= r) {
apply(id, x);
return;
}
if (l >= e || s >= r) return;
int md = (s + e) / 2;
shift(id);
update(l, r, x, 2 * id, s, md);
update(l, r, x, 2 * id + 1, md, e);
seg[id] = max(seg[2 * id], seg[2 * id + 1]);
return;
}
int get(int l, int r, int id = 1, int s = 0, int e = n) {
if (l <= s && e <= r) return seg[id];
if (l >= e || s >= r) return 0;
int md = (s + e) / 2;
shift(id);
return max(get(l, r, 2 * id, s, md), get(l, r, 2 * id + 1, md, e));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(seg, 63, sizeof seg);
memset(lazy, 63, sizeof lazy);
cin >> n;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
l--;
r--;
S[l].push_back(r);
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--;
r--;
Q[l].push_back({r, i});
}
for (int l = n - 1; l > -1; l--) {
for (auto r : S[l]) {
update(l, r, r);
}
for (auto pp : Q[l]) {
int r = pp.first;
int i = pp.second;
int lt = l;
int rt = r + 1;
while (rt - lt > 1) {
int md = (lt + rt) / 2;
if (get(l, md) <= r)
lt = md;
else
rt = md;
}
res[i] = lt + 1;
}
}
for (int i = 0; i < q; i++) cout << res[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int p[100100], t[100100];
int id[100100], L[100100], R[100100], ans[100100];
bool cmp(int i, int j) { return R[i] < R[j]; }
struct RMQ_Tree {
int n;
int mx[1 << 20];
void init(int _n) {
for (n = 1; n < _n; n <<= 1)
;
for (int i = n << 1; --i;) mx[i] = 0;
}
void insert(int p, int val) {
p += n - 1;
for (; p && val > mx[p]; p >>= 1) mx[p] = val;
}
int calc(int st, int ed) {
if (st > ed) return 0;
st += n - 1;
ed += n;
int ans = 0;
while (st < ed) {
if (st & 1) smax(ans, mx[st++]);
if (ed & 1) smax(ans, mx[ed ^ 1]);
st >>= 1;
ed >>= 1;
}
return ans;
}
} Tree;
int find_root(int l, int r) {
if (l == r) return l;
int nr = Tree.calc(l, r);
if (r >= nr) return r;
return find_root(l, nr);
}
int main() {
int n, m, q;
gn(n, m);
Tree.init(n);
for (int i = 1; i <= n; i++) p[i] = i, t[i] = i;
for (int i = 0; i < m; i++) {
int first, second;
gn(first, second);
p[second] = first;
}
gn(q);
for (int i = 0; i < q; i++) {
gn(L[i], R[i]);
id[i] = i;
}
sort(id, id + q, cmp);
for (int i = 1, j = 0; i <= n; i++) {
Tree.insert(p[i], i);
smax(t[p[i]], i);
while (j < q && R[id[j]] == i) {
ans[id[j]] = find_root(L[id[j]], t[L[id[j]]]);
Tree.insert(L[id[j]], ans[id[j]]);
j++;
}
}
for (int i = 0; i < q; i++) println(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, 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;
const int N = 1e5 + 5;
const int B = 320;
int n, m, q;
int R[N][B], ans[N][B], L[N];
vector<int> rope[N], stk[B];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1, a, b; i <= m; i++) {
scanf("%d %d", &a, &b);
rope[a].emplace_back(b);
L[b] = a;
}
for (int i = 1; i <= n; i++) {
rope[i].emplace_back(i);
sort(rope[i].begin(), rope[i].end());
for (int j = 1, ptr = 0; j < B; j++) {
while (ptr + 1 < rope[i].size() && rope[i][ptr + 1] <= j * B) ++ptr;
R[i][j] = rope[i][ptr];
}
}
for (int i = n; i; i--)
for (int j = 1; j < B; j++) {
ans[i][j] = R[i][j];
while (!stk[j].empty() && stk[j].back() <= R[i][j]) {
ans[i][j] = max(ans[i][j], ans[stk[j].back()][j]);
stk[j].pop_back();
}
stk[j].emplace_back(i);
}
scanf("%d", &q);
for (int i = 1, l, r; i <= q; i++) {
scanf("%d %d", &l, &r);
if (r - l <= B) {
int now = l;
for (int j = l + 1; j <= r; j++)
if (L[j] <= now && L[j] >= l) now = j;
printf("%d\n", now);
} else {
int x = r - (r % B), now = ans[l][x / B];
for (int j = x + 1; j <= r; j++)
if (L[j] <= now && L[j] >= l) now = j;
printf("%d\n", now);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int block = 318;
const int maxn = 101124 + 9;
const int inf = 1l << 30;
int n, m, q, dn[maxn], f[maxn][block], dp[maxn][block];
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)]) =
((f[i][(int)ceil((double)up[i][j] / block)]) > (up[i][j])
? (f[i][(int)ceil((double)up[i][j] / block)])
: (up[i][j]));
for (register int(j) = (1); (j) < (block); ++(j))
(f[i][j]) = ((f[i][j]) > (f[i][j - 1]) ? (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]) =
((dp[j][i]) > (dp[stk.top()][i]) ? (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);
for (register int(i) = (0); (i) < (m); ++(i)) {
int l, r;
cin >> l >> r;
dn[r] = l, up[l].push_back(r);
}
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 <= dn[po] && dn[po] <= res) res = po;
cout << res << '\n';
}
}
|
#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], dn[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] = 1ll << 25, up[i].push_back(i);
for (register int(i) = (0); (i) < (m); ++(i)) {
int l, r;
cin >> l >> r;
dn[r] = l, up[l].push_back(r);
}
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 <= dn[po] && dn[po] <= res) res = po;
cout << res << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int m;
vector<int> v[100002];
int dp[100002][330];
int ans[100002];
int id[100002];
int en[100002];
vector<int> vv;
struct MAX_BIT {
int bit[100002];
MAX_BIT() {
for (int i = 0; i < 100002; i++) bit[i] = -1;
}
void add(int i, int j) {
i++;
while (i < 100002) {
bit[i] = max(bit[i], j);
i += i & -i;
}
}
int sum(int i) {
int r = 0;
i++;
while (i) {
r = max(r, bit[i]);
i -= i & -i;
}
return r;
}
};
MAX_BIT bit[330];
int belong[100002];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
en[i] = -1;
}
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
l--;
r--;
v[l].push_back(r);
en[r] = l;
}
for (int i = 0; i < n; i++) {
sort(v[i].begin(), v[i].end());
}
int q;
cin >> q;
memset(id, -1, sizeof(id));
int ord = 0;
for (int i = 0; i < n; i++) {
if (i % 330 == 0) {
id[i] = ord;
ord++;
vv.push_back(i);
}
}
if (id[n - 1] == -1) {
id[n - 1] = ord;
ord++;
vv.push_back(n - 1);
}
memset(dp, -1, sizeof(dp));
for (int i = n - 1; i >= 0; i--) {
if (id[i] == -1) {
belong[i] = belong[i + 1];
continue;
} else {
belong[i] = id[i];
}
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < ord; j++) {
if (j == id[i]) {
dp[i][j] = i;
continue;
}
if (i > vv[j]) continue;
dp[i][j] = i;
int las_go = -1;
for (int k = 0; k < v[i].size(); k++) {
int go = v[i][k];
if (go <= vv[j]) {
las_go = go;
}
}
if (las_go != -1) {
dp[i][j] = max(dp[i][j], bit[j].sum(las_go));
}
}
for (int j = 0; j < ord; j++) {
if (dp[i][j] != -1) {
bit[j].add(i, dp[i][j]);
}
}
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
int cur = upper_bound(vv.begin(), vv.end(), y) - vv.begin();
int go = max(dp[x][cur - 1], x);
int ans = go;
for (int i = max(go, y - 330 - 1); i <= y; i++) {
if (en[i] <= ans && en[i] >= x && i <= y) {
ans = i;
}
}
ans++;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int n, m, q;
int L[MAXN];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) (ch == '-') && (f = -f), ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
struct Query {
int pos, ord;
Query(int pos = 0, int ord = 0) : pos(pos), ord(ord){};
};
vector<Query> Q[MAXN];
int prt[MAXN];
struct Node {
int l, r;
int maxn, sec;
int add;
} t[MAXN << 2];
inline void pushup(int k) {
if (t[(k << 1)].maxn > t[(k << 1 | 1)].maxn) {
t[k].maxn = t[(k << 1)].maxn;
t[k].sec = max(t[(k << 1)].sec, t[(k << 1 | 1)].maxn);
} else if (t[(k << 1)].maxn < t[(k << 1 | 1)].maxn) {
t[k].maxn = t[(k << 1 | 1)].maxn;
t[k].sec = max(t[(k << 1)].maxn, t[(k << 1 | 1)].sec);
} else {
t[k].maxn = t[(k << 1)].maxn;
t[k].sec = max(t[(k << 1)].sec, t[(k << 1 | 1)].sec);
}
}
inline void addtag(int k, int v) {
t[k].add += v;
t[k].maxn += v;
}
inline void pushdown(int k) {
int maxn = max(t[(k << 1)].maxn, t[(k << 1 | 1)].maxn);
if (t[(k << 1)].maxn == maxn) addtag((k << 1), t[k].add);
if (t[(k << 1 | 1)].maxn == maxn) addtag((k << 1 | 1), t[k].add);
t[k].add = 0;
}
void build(int k, int l, int r) {
t[k].l = l;
t[k].r = r;
if (l == r) return t[k].maxn = l, void();
int mid = (l + r) >> 1;
build((k << 1), l, mid);
build((k << 1 | 1), mid + 1, r);
pushup(k);
}
void modify(int k, int l, int r, int lim, int val) {
if (t[k].l > r || t[k].r < l || t[k].maxn < lim) return;
if (t[k].l >= l && t[k].r <= r && t[k].sec < lim)
return addtag(k, val - t[k].maxn);
pushdown(k);
modify((k << 1), l, r, lim, val);
modify((k << 1 | 1), l, r, lim, val);
pushup(k);
}
int query(int k, int pos) {
if (t[k].l == t[k].r) return t[k].maxn;
pushdown(k);
int mid = (t[k].l + t[k].r) >> 1;
if (pos <= mid)
return query((k << 1), pos);
else
return query((k << 1 | 1), pos);
}
int main() {
register int i;
n = read();
m = read();
for (i = 1; i <= m; ++i) {
int l = read(), r = read();
L[r] = l;
}
q = read();
for (i = 1; i <= q; ++i) {
int l = read(), r = read();
Q[r].push_back(Query(l, i));
}
build(1, 1, n);
for (i = 1; i <= n; ++i) {
if (L[i]) modify(1, 1, L[i], L[i], i);
for (unsigned int j = 0; j < Q[i].size(); ++j)
prt[Q[i][j].ord] = query(1, Q[i][j].pos);
}
for (i = 1; i <= q; ++i) printf("%d\n", prt[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, 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].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 (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;
long long read() {
long long a = 0, fh = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') fh = -1;
c = getchar();
}
while ('0' <= c && c <= '9') {
a = a * 10 + c - 48;
c = getchar();
}
return a * fh;
}
long long n, m, q, X[100005], Y[100005], ans[100005];
pair<long long, long long> a[100005];
vector<long long> chg[100005], Q[100005];
long long mx[100005 << 2], sec[100005 << 2], tag[100005 << 2];
void pd(long long first) {
if (tag[first]) {
if (mx[(first << 1)] == mx[(first << 1 | 1)])
tag[(first << 1)] = tag[(first << 1 | 1)] = mx[(first << 1)] =
mx[(first << 1 | 1)] = tag[first];
else if (mx[(first << 1)] > mx[(first << 1 | 1)])
tag[(first << 1)] = mx[(first << 1)] = tag[first];
else
tag[(first << 1 | 1)] = mx[(first << 1 | 1)] = tag[first];
tag[first] = 0;
}
}
void pushup(long long first) {
mx[first] = max(mx[(first << 1)], mx[(first << 1 | 1)]);
if (mx[(first << 1)] == mx[(first << 1 | 1)])
sec[first] = max(sec[(first << 1)], sec[(first << 1 | 1)]);
else if (mx[(first << 1)] < mx[(first << 1 | 1)])
sec[first] = max(mx[(first << 1)], sec[(first << 1 | 1)]);
else
sec[first] = max(sec[(first << 1)], mx[(first << 1 | 1)]);
}
void build(long long first, long long l, long long r) {
if (l == r) {
mx[first] = l;
return;
}
build((first << 1), l, ((l + r) >> 1));
build((first << 1 | 1), ((l + r) >> 1) + 1, r);
pushup(first);
}
void change(long long first, long long l, long long r, long long b, long long e,
long long X, long long Y) {
if (l > e || r < b || mx[first] < X) return;
if (b <= l && r <= e) {
if (l == r) {
if (mx[first] >= X) mx[first] = Y;
return;
}
if (sec[first] < X) {
mx[first] = Y;
tag[first] = Y;
return;
}
}
pd(first);
if (b <= ((l + r) >> 1)) change((first << 1), l, ((l + r) >> 1), b, e, X, Y);
if (e > ((l + r) >> 1))
change((first << 1 | 1), ((l + r) >> 1) + 1, r, b, e, X, Y);
pushup(first);
}
long long ask(long long first, long long l, long long r, long long loc) {
if (l == r) return mx[first];
pd(first);
if (loc <= ((l + r) >> 1))
return ask((first << 1), l, ((l + r) >> 1), loc);
else
return ask((first << 1 | 1), ((l + r) >> 1) + 1, r, loc);
}
signed main() {
n = read();
m = read();
for (long long i = 1; i <= m; ++i) {
a[i].first = read(), a[i].second = read();
chg[a[i].second].push_back(a[i].first);
}
q = read();
for (long long i = 1; i <= q; ++i) {
X[i] = read(), Y[i] = read();
Q[Y[i]].push_back(i);
}
build(1, 1, n);
for (long long i = 1; i <= n; ++i) {
for (long long j = 0; j < chg[i].size(); ++j) {
change(1, 1, n, 1, chg[i][j], chg[i][j], i);
}
for (long long j = 0; j < Q[i].size(); ++j) {
ans[Q[i][j]] = ask(1, 1, n, X[Q[i][j]]);
}
}
for (long long i = 1; i <= q; ++i) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, Q;
int line[N], ans[N];
vector<pair<int, int> > q[N];
struct Seq {
int mx1[N * 4], mx2[N * 4], tagx[N * 4], tagy[N * 4];
void pushup(int u) {
if (mx1[u << 1] == mx1[u << 1 | 1]) {
mx1[u] = mx1[u << 1];
mx2[u] = max(mx2[u << 1], mx2[u << 1 | 1]);
return;
}
mx1[u] = mx1[u << 1];
mx2[u] = mx1[u << 1 | 1];
if (mx1[u] < mx2[u]) swap(mx1[u], mx2[u]);
}
void build(int u, int l, int r) {
tagx[u] = N;
tagy[u] = 0;
if (l == r) {
mx1[u] = 0;
mx2[u] = -1;
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void covr(int u, int x, int y) {
if (mx1[u] < x) return;
mx1[u] = y;
tagx[u] = min(tagx[u], x);
tagy[u] = y;
}
void pushdown(int u) {
if (tagy[u])
covr(u << 1, tagx[u], tagy[u]), covr(u << 1 | 1, tagx[u], tagy[u]),
tagx[u] = N, tagy[u] = 0;
}
void upd(int u, int l, int r, int ul, int ur, int x, int y) {
if (l >= ul && r <= ur && mx2[u] < x) {
covr(u, x, y);
return;
}
int mid = (l + r) >> 1;
pushdown(u);
if (mid >= ul) upd(u << 1, l, mid, ul, ur, x, y);
if (mid < ur) upd(u << 1 | 1, mid + 1, r, ul, ur, x, y);
pushup(u);
}
int qval(int u, int l, int r, int x) {
if (l == r) return mx1[u];
int mid = (l + r) >> 1;
pushdown(u);
return mid >= x ? qval(u << 1, l, mid, x) : qval(u << 1 | 1, mid + 1, r, x);
}
} qt;
int main() {
int x, y;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d%d", &x, &y), line[y] = x;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++)
scanf("%d%d", &x, &y), q[y].push_back(make_pair(x, i));
qt.build(1, 1, n);
for (int i = 1; i <= n; i++) {
if (line[i]) qt.upd(1, 1, n, 1, line[i], line[i], i);
qt.upd(1, 1, n, i, i, 0, i);
for (int j = 0; j < q[i].size(); j++)
ans[q[i][j].second] = qt.qval(1, 1, n, 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;
const int k = 300;
const int arr = 1e5 + 100;
vector<int> vec[arr];
vector<pair<int, int> > steck[arr / k + 10];
int too[arr][arr / k + 10], from[arr];
int get_ans(int l, int r, int x) {
for (int i = max(r / k * k, x) + 1; i <= r; i++) {
if (from[i] >= l && from[i] <= x) x = i;
}
return (x);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
int m;
cin >> m;
for (int i = 1; i <= n; i++) from[i] = i;
while (m--) {
int l, r;
cin >> l >> r;
vec[l].push_back(r);
from[r] = l;
}
for (int i = 1; i <= n; i++) {
vec[i].push_back(i);
vec[i].push_back(1e9);
sort(vec[i].begin(), vec[i].end());
int last = 0;
for (int j = 1; j * k <= n; j++) {
while (vec[i][last] <= j * k) last++;
if (last == 0) continue;
too[i][j] = vec[i][last - 1];
}
}
for (int i = n; i >= 0; i--)
for (int j = 1; j * k <= n; j++)
if (i <= k * j) too[i][j] = max(too[i][j], i);
for (int j = 1; j * k <= n; j++) steck[j].push_back({n + 1, 0});
for (int i = n; i >= 1; i--)
for (int j = 1; j * k <= n; j++) {
while (too[i][j] >= steck[j][steck[j].size() - 1].first) {
too[i][j] = max(too[i][j], steck[j][steck[j].size() - 1].second);
steck[j].pop_back();
}
steck[j].push_back({i, too[i][j]});
}
int q;
cin >> q;
while (q--) {
int l, r;
cin >> l >> r;
cout << get_ans(l, r, max(l, too[l][r / k])) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int size = 100 * 1000 + 100;
const int bsize = 400;
int n, m, q;
int fin[size];
int l[size], r[size];
vector<int> vertex[size];
vector<int> qs[size];
int st[size];
int qx[size], qy[size];
int ans[size];
int lene;
int go_small(int lb, int rb) {
int cur = lb;
for (int i = lb; i <= rb; i++)
if (fin[i] >= lb && fin[i] <= cur) {
cur = i;
}
return cur;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) fin[i] = -1;
for (int i = 0; i < m; i++) {
scanf("%d%d", &l[i], &r[i]);
l[i]--, r[i]--;
vertex[l[i]].push_back(r[i]);
fin[r[i]] = l[i];
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d", &qx[i], &qy[i]);
qx[i]--, qy[i]--;
qs[qx[i]].push_back(i);
if (qx[i] / bsize == qy[i] / bsize) {
ans[i] = go_small(qx[i], qy[i]);
}
}
for (int j = bsize; j < n; j += bsize) {
lene = 0;
for (int i = j - 1; i >= 0; i--) {
st[lene++] = i;
for (auto& e : vertex[i]) {
if (e <= j) {
while (lene > 0 && st[lene - 1] < e) lene--;
}
}
for (auto& mq : qs[i]) {
if (qy[mq] >= j && qy[mq] < j + bsize) {
int cur;
if (lene == 0) {
cur = j;
} else {
cur = st[lene - 1];
}
for (int k = j; k <= qy[mq]; k++) {
if (fin[k] >= i && fin[k] <= cur) cur = k;
}
ans[mq] = cur;
}
}
}
}
for (int i = 0; i < q; i++) printf("%d\n", ans[i] + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1500 + 10;
char s[N];
int n, q, a[N];
int memo[N][30];
int solve(int x, int c) {
int j = 0, miss = 0, ret = 0;
for (int i = 1; i <= n; i++) {
if (a[i] != c && j < i) miss++, j = i;
while (j + 1 <= n && (a[j + 1] == c || miss + 1 <= x)) {
j++;
if (a[j] != c) miss++;
}
if (miss <= x) ret = max(ret, j - i + 1);
if (a[i] != c) miss--;
}
return ret;
}
int main() {
scanf("%d%s%d", &n, s, &q);
for (int i = 0; i < n; i++) a[i + 1] = (int)(s[i] - 'a');
memset(memo, -1, sizeof memo);
while (q--) {
int x, c;
char ch[2];
scanf("%d %s", &x, ch);
c = (int)(ch[0] - 'a');
if (memo[x][c] == -1) memo[x][c] = solve(x, c);
printf("%d\n", memo[x][c]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void max_self(T& a, const T& b) {
if (a < b) a = b;
}
template <class T>
void min_self(T& a, const T& b) {
if (a > b) a = b;
}
const int INF = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = (1e-9);
int N, q, opt[1505][1505], memo[30][1505];
string in;
void solve(char c) {
for (int idx = 0; idx < N; ++idx) {
if (in[idx] != c) {
opt[idx][0] = 0;
continue;
}
opt[idx][0] = 1 + (idx ? opt[idx - 1][0] : 0);
}
for (int diff = 1; diff <= N; ++diff) {
opt[0][diff] = 1;
}
for (int idx = 1; idx < N; ++idx) {
for (int diff = 1; diff <= N; ++diff) {
if (in[idx] == c) {
opt[idx][diff] = 1 + opt[idx - 1][diff];
} else {
opt[idx][diff] = 1 + opt[idx - 1][diff - 1];
}
}
}
for (int diff = 1, bst; diff <= N; ++diff) {
bst = 0;
for (int idx = 0; idx < N; ++idx) {
max_self(bst, opt[idx][diff]);
}
memo[c - 'a'][diff] = bst;
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> N;
cin >> in;
cin >> q;
for (char c = 'a'; c <= 'z'; ++c) solve(c);
for (int rep = 0; rep < q; ++rep) {
int diff;
char c;
cin >> diff >> c;
cout << memo[c - 'a'][diff] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
bool you[26];
int need[26][1550];
int q;
int main() {
scanf("%d", &n);
cin >> s;
for (int i = 0; i < n; i++) {
you[s[i] - 'a'] = 1;
int ndd = 0;
for (int j = i; j < n; j++) {
if (s[j] != s[i]) ndd++;
need[s[i] - 'a'][ndd] = max(need[s[i] - 'a'][ndd], j - i + 1);
}
for (int j = i - 1; j >= 0; j--) {
if (s[j] != s[i]) ndd++;
need[s[i] - 'a'][ndd] = max(need[s[i] - 'a'][ndd], n - j);
}
}
for (int i = 0; i < 26; i++)
for (int j = 1; j < 1550; j++) need[i][j] = max(need[i][j - 1], need[i][j]);
scanf("%d", &q);
int a;
char b;
while (q--) {
scanf("%d %c", &a, &b);
if (!you[b - 'a'])
printf("%d\n", a);
else
printf("%d\n", need[b - 'a'][a]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int dp[26][1505];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < 26; i++) {
for (int l = 0; l < n; l++) {
int cnt = 0;
for (int r = l; r < n; r++) {
if (s[r] - 'a' != i) cnt++;
dp[i][cnt] = max(dp[i][cnt], r - l + 1);
}
}
for (int t = 1; t < n + 1; t++) dp[i][t] = max(dp[i][t], dp[i][t - 1]);
}
int q;
cin >> q;
while (q--) {
int m;
char c;
cin >> m >> c;
cout << dp[c - 'a'][m] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[1501][1501], an[200000], n, q, mnan[1501];
vector<pair<int, int> > qu[26];
char s[1502];
int main() {
scanf("%d%s%d", &n, s + 1, &q);
for (int i = 0; i < (int)(q); ++i) {
int a;
char c;
scanf("%d %c", &a, &c);
qu[c - 'a'].push_back(make_pair(a, i));
}
for (int i = 0; i < (int)(26); ++i) {
for (int k = 0; k < (int)(n + 1); ++k) mnan[k] = 0;
for (int j = 1; j < (int)(n + 1); ++j)
for (int k = 0; k < (int)(j + 1); ++k) {
if (s[j] == 'a' + i)
dp[j][k] = dp[j - 1][k] + 1;
else if (k)
dp[j][k] = dp[j - 1][k - 1] + 1;
else
dp[j][k] = 0;
mnan[k] = max(mnan[k], dp[j][k]);
}
for (int j = 1; j < (int)(n + 1); ++j) mnan[j] = max(mnan[j], mnan[j - 1]);
for (int j = 0; j < (int)(qu[i].size()); ++j)
an[qu[i][j].second] = mnan[qu[i][j].first];
}
for (int i = 0; i < (int)(q); ++i) printf("%d\n", an[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
const double error = 1e-8;
const double PI = acos(-1);
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
inline long long int MOD(long long int x, long long int m = mod) {
long long int y = x % m;
return (y >= 0) ? y : y + m;
}
const int inf = INT_MAX;
const long long int infl = LLONG_MAX;
const int nmax = 2e3 + 10;
char str[nmax];
int memo[26][nmax];
void dp(int n) {
for (char c = 'a'; c <= 'z'; c++) {
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = i; j >= 0; j--) {
if (str[j] != c) cnt++;
memo[c - 'a'][cnt] = max(i - j + 1, memo[c - 'a'][cnt]);
}
}
for (int i = 1; i <= n; i++)
memo[c - 'a'][i] = max(memo[c - 'a'][i], memo[c - 'a'][i - 1]);
}
}
int main() {
int n;
scanf("%d", &n);
scanf("%s", str);
dp(n);
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int m;
char c[4];
scanf("%d %s", &m, c);
printf("%d\n", memo[c[0] - 'a'][m]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[30][1505];
char str[1505];
int n;
int get(int x, int len) {
int p = 1;
int q = 1;
int cnt = 0;
if (str[1] - 'a' != x) cnt++;
int Max = cnt;
while (p < n) {
while (cnt <= len && p < n) {
p++;
if (str[p] - 'a' != x) {
cnt++;
}
if (cnt <= len) {
Max = max(Max, p - q + 1);
}
}
while (cnt > len) {
if (str[q] - 'a' != x) {
cnt--;
}
q++;
}
}
return Max;
}
int main() {
scanf("%d", &n);
scanf("%s", str + 1);
for (int i = 0; i <= 25; i++) {
for (int j = 1; j <= n; j++) {
ans[i][j] = get(i, j);
}
}
int q;
scanf("%d", &q);
while (q--) {
char c;
int m;
scanf("%d %c", &m, &c);
printf("%d\n", ans[c - 'a'][m]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q;
cin >> n;
string s;
cin >> s;
map<char, vector<int>> data, ans;
for (char t = 'a'; t <= 'z'; t++) {
vector<int> tmp(n + 1);
for (int j = 1; j <= n; j++) {
if (s[j - 1] == t) {
tmp[j]++;
}
tmp[j] += tmp[j - 1];
}
data[t] = tmp;
}
for (char t = 'a'; t <= 'z'; t++) {
vector<int> tmp(n + 1);
ans[t] = tmp;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int x = j - i + 1 - (data[t][j] - data[t][i - 1]);
if (ans[t][x] <= j - i + 1) {
ans[t][x] = j - i + 1;
}
}
}
for (int i = 1; i <= n; i++) {
ans[t][i] = max(ans[t][i], ans[t][i - 1]);
}
}
cin >> q;
for (int i = 0; i < q; i++) {
int a;
char c;
cin >> a >> c;
cout << ans[c][a] << endl;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.