CF1197E Culture Code （无后效性+线性dp+线段树优化）

无后效性+线性dp+线段树优化

看到求最值以及方案数，考虑 dp。当前的顺序显然是无从下手的，因为套娃的顺序是乱的，考虑能否找到偏序满足无后效性。可以按照 $i n_{i}$ 从大到小排序，那么存在极大区间 $[1, j] \in [1, i)$ ， $i n_{j} > o u t_{i} > i n_{i}$ ，也就是当前的套娃只可能套在前面的套娃里，并且是一段前缀。

那么可以考虑状态了，设 $f_{i}$ 表示考虑前 $i$ 个套娃，第 $i$ 个套娃套在最里面，能套出的最小剩余空间。转移有 $f_{i} = max_{k < j} f_{k} - o u t_{i} + i n_{i}$ ；同时维护 $g_{i}$ 表示 $f_{i}$ 的方案数。那么直接线段树维护即可。可以记录 $a n s$ 表示当前最小剩余空间的方案，记录当前最小剩余空间 $m n$ ，当 $f_{i} < m n$ 时， $a n s = g_{i}$ ；当 $f_{i} = m n$ 时， $a n s = a n s + g_{i}$ 。

复杂度 $O (n \log n)$ 。

#include <bits/stdc++.h>
#define pii std::pair<int, int>
#define fi first
#define se second
#define pb push_back

typedef long long i64;
const i64 iinf = 0x3f3f3f3f, linf = 0x3f3f3f3f3f3f3f3f;
const int N = 2e5 + 10, mod = 1e9 + 7;
i64 n, ans, mn = iinf, tot;
i64 b[N];
struct node {
	i64 in, out; 
} a[N];
bool cmp(node a, node b) {
	return a.in > b.in;
}
bool cmp2(int a, int b) {
	return a > b;
}
struct seg {
	i64 f, g;
} t[N << 2];
void pushup(int u) {
	if(t[u << 1].f == t[u << 1 | 1].f) {
		t[u].f = t[u << 1].f, t[u].g = (t[u << 1].g + t[u << 1 | 1].g) % mod;
	} else if(t[u << 1].f < t[u << 1 | 1].f) {
		t[u].f = t[u << 1].f, t[u].g = t[u << 1].g;
	} else {
		t[u].f = t[u << 1 | 1].f, t[u].g = t[u << 1 | 1].g;
	}
}
void build(int u, int l, int r) {
	t[u].f = iinf, t[u].g = 1;
	if(l == r) return;
	int mid = (l + r) >> 1;
	build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
} 
void ins(int u, int l, int r, int x, i64 y, i64 z) {
	if(l == r) {
		t[u].f = y, t[u].g = z;
		return;
	}
	int mid = (l + r) >> 1;
	if(x <= mid) ins(u << 1, l, mid, x, y, z);
	else ins(u << 1 | 1, mid + 1, r, x, y, z);
	pushup(u);
}
seg qry(int u, int l, int r, int L, int R) {
	if(L <= l && r <= R) return t[u];
	int mid = (l + r) >> 1;
	if(R <= mid) return qry(u << 1, l, mid, L, R);
	if(L > mid) return qry(u << 1 | 1, mid + 1, r, L, R);
	seg ret, ls = qry(u << 1, l, mid, L, R), rs = qry(u << 1 | 1, mid + 1, r, L, R);
	if(ls.f == rs.f) {
		ret.f = ls.f, ret.g = (ls.g + rs.g) % mod;
	} else if(ls.f < rs.f) {
		ret.f = ls.f, ret.g = ls.g;
	} else {
		ret.f = rs.f, ret.g = rs.g;
	}
	return ret;
}
int upper(int r, i64 x) {
	int l = 1, ret = 0;
	while(l <= r) {
		int mid = (l + r) >> 1;
		if(a[mid].in >= x) ret = mid, l = mid + 1;
		else r = mid - 1;
	}
	return ret;
}
void Solve() {
	std::cin >> n;
	for(int i = 1; i <= n; i++) {
		std::cin >> a[i].out >> a[i].in;
		b[i] = a[i].in;
	}
	std::sort(b + 1, b + n + 1, cmp2);
	std::sort(a + 1, a + n + 1, cmp);
	
	build(1, 1, n);
	for(int i = 1; i <= n; i++) {
		int pos = upper(i - 1, a[i].out);
		seg ret;
		if(!pos) ret = {a[i].in, 1};
		else ret = qry(1, 1, n, 1, pos), ret.f = ret.f - a[i].out + a[i].in;
		if(ret.f < mn) {
			mn = ret.f;
			ans = ret.g;
		} else if(ret.f == mn) {
			ans = (ans + ret.g) % mod;
		}
		ins(1, 1, n, i, ret.f, ret.g);
	}
	
	std::cout << ans << "\n";
}
int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
	Solve();

	return 0;
}