[题解] CF809D Hitchhiking in the Baltic States
前言
题意
给定 \(n\) 个区间 \([l_i,r_i]\) ，请你构造一个序列，每个元素 \(a_i\) 满足 \(a_i\in[l_i,r_i]\) ，且该序列的最长严格上升子序列最长。
思路
\(n^2\) 的 DP 都想了半天 QAQ 。
首先在第一维枚举区间。
定义 \(dp[i][j]\) ：枚举到第 \(i\) 个区间时，长度为 \(j\) 的严格上升子序列的结尾的最小值，若不存在，则为极大值。
显然，初值为 \(dp[0][0]=0\) ，其余为极大值。最后统计 \(dp[i](i\in n)\) 中不等于极大值的有多少。转移方程如下：
\(dp[i][j]= \begin{cases} min(dp[i-1][j],l),& \text{dp[i-1][j-1]<l,}\\ min(dp[i-1][j],dp[i-1][j-1]+1),& \text{dp[i-1][j-1]>=l,dp[i-1][j-1]<r,}\\ dp[i-1][j],& \text{dp[i-1][j-1]>=r.} \end{cases}\)
可以数组降维，将第一维删去，然后倒着更新。暴力 DP 伪代码：
for(int i = 1; i <= n; i++) {
for(int j = n; j >= 1; j--) {
if(dp[j - 1] < l[i]) dp[j] = Min(dp[j], l[i]);
if(l[i] <= dp[j - 1] && dp[j - 1] < r[i]) dp[j] = Min(dp[j], dp[j - 1] + 1);
}
}
在考虑用平衡树优化。
由于是从后往前更新，所以先考虑第二类 dp 的影响。第二类 dp 可以分解为三部：
- 先删除第一个大于等于 \(r\) 的点。
- 区间 \([l,r)\) 的所有数平移为 \([l+1,r+1)\) 。
- 最后插入实行第二部前，第一个大于等于 \(l\) 的数。
值得注意的是，若区间 \([l,r)\) 没有任何数，则忽略第二步操作。
在执行第一类 dp ，可以发现，它只更新一个数，即第一个大于等于 \(l\) 的数。具体分为两步：
- 先删除第一个大于等于 \(l\) 的数。
- 插入 \(l\) 。
可以将其合并为 \(3\) 个操作，即第二类 dp 的 \(1\) ， \(2\) 操作，与第一类 dp 的 \(2\) 操作。
由于涉及到区间操作，需要打懒标记。
Code
#include <cstdio>
namespace Quick_Function {
template <typename Temp> void Read(Temp &x) {
x = 0; char ch = getchar(); bool op = 0;
while(ch < '0' || ch > '9') { if(ch == '-') op = 1; ch = getchar(); }
while(ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + (ch ^ 48); ch = getchar(); }
if(op) x = -x;
}
template <typename T, typename... Args> void Read(T &t, Args &... args) { Read(t); Read(args...); }
template <typename Temp> Temp Max(Temp x, Temp y) { return x > y ? x : y; }
template <typename Temp> Temp Min(Temp x, Temp y) { return x < y ? x : y; }
template <typename Temp> Temp Abs(Temp x) { return x < 0 ? (-x) : x; }
template <typename Temp> void Swap(Temp &x, Temp &y) { x ^= y ^= x ^= y; }
}
using namespace Quick_Function;
#define INF 0x3f3f3f3f
const int MAXN = 6e5 + 5;
int n, ans;
struct Splay_Node {
int son[2], fa, val, tag;
#define ls t[pos].son[0]
#define rs t[pos].son[1]
};
struct Splay_Tree {
Splay_Node t[MAXN];
int root, tot, Top, stk[MAXN];
int Ident(int pos) { return t[t[pos].fa].son[1] == pos ? 1 : 0; }
void Connect(int pos, int fa, int flag) { t[fa].son[flag] = pos, t[pos].fa = fa; }
void Push_Down(int pos) {
if(!t[pos].tag) return;
if(ls) { t[ls].val += t[pos].tag, t[ls].tag += t[pos].tag; }
if(rs) { t[rs].val += t[pos].tag, t[rs].tag += t[pos].tag; }
t[pos].tag = 0;
}
int New(int val, int fa) { t[++tot].fa = fa, t[tot].val = val; return tot; }
void Build() { root = New(-INF, 0); t[root].son[1] = New(INF, root); }
void Rotate(int pos) {
int fa = t[pos].fa, grand = t[fa].fa;
int flag1 = Ident(pos), flag2 = Ident(fa);
Connect(pos, grand, flag2);
Connect(t[pos].son[flag1 ^ 1], fa, flag1);
Connect(fa, pos, flag1 ^ 1);
}
void Splay(int pos, int to) {
int tmp = pos; Top = 0;
stk[++Top] = tmp;
while(tmp) stk[++Top] = tmp = t[tmp].fa;
while(Top) Push_Down(stk[Top--]);//以上为释放懒标记
for(int fa = t[pos].fa; t[pos].fa != to; Rotate(pos), fa = t[pos].fa)
if(t[fa].fa != to) Ident(pos) == Ident(fa) ? Rotate(fa) : Rotate(pos);
if(!to) root = pos;
}
void Insert(int &pos, int val, int fa) {
if(!pos) { ++ans; pos = New(val, fa); Splay(pos, 0); return; }
Push_Down(pos);//几乎每个操作都有释放懒标，别忘了
if(val < t[pos].val) Insert(ls, val, pos);
else Insert(rs, val, pos);
}
void Erase(int pos) {
Splay(pos, 0);
int l = ls, r = rs;
while(t[l].son[1]) l = t[l].son[1];
while(t[r].son[0]) r = t[r].son[0];
Splay(l, 0); Splay(r, l);
t[r].son[0] = 0; --ans;
}
int Get_Pre(int val) {//查找第一个小于val的点的编号
int pos, res, newroot;
pos = newroot = root;
while(pos) {
Push_Down(pos);
if(t[pos].val < val) { res = pos; pos = rs; }
else pos = ls;
}
Splay(newroot, 0);
return res;
}
int Get_Nxt(int val) {//查找第一个大于val的点的编号
int pos, res, newroot;
pos = newroot = root;
while(pos) {
Push_Down(pos);
if(t[pos].val > val) { res = pos; pos = ls; }
else pos = rs;
}
Splay(newroot, 0);
return res;
}
void Move(int l, int r) {//平移区间[l,r)
int u = Get_Nxt(l - 1), v = Get_Pre(r);
if(t[u].val > t[v].val) return;//没有数字就跳过
if(u == v) t[u].val++;
else if(t[u].val < t[v].val) {
Splay(u, 0); Splay(v, u);
int rson = t[v].son[0];
++t[u].val; ++t[v].val, t[rson].val++;
if(rson) ++t[rson].tag;
}
}
};
Splay_Tree tree;
int main() {
Read(n); tree.Build();
tree.Insert(tree.root, 0, 0); ans = 0;
for(int i = 1, l, r; i <= n; i++) {
Read(l, r);
int pos = tree.Get_Nxt(r - 1);
if(pos && pos != 1 && pos != 2) tree.Erase(pos);
tree.Move(l, r);
tree.Insert(tree.root, l, 0);
}
printf("%d", ans);
return 0;
}
