[CF559E]Gerald and Path

题目

传送门 to CF

思路

一般而言，我们会将区间排序。因为区间实质上是 二维偏序 关系，按照端点排序 可以使得某一维度上有序，相当于 降维。

本题中，区间不太固定。但是两种可能的区间中，$a_i$ 是共有的端点；所以按照 $a_i$ 排序是比较自然的。

接下来考虑 $\mathtt{dp}$ 转移。比如当前选择 $[a_i-l_i,a_i]$，我们需要找出它的新增覆盖区间。但是，这一大段区间内，可能选择了若干小段，不可能全部记录下来。怎么办？

一种想法是，忽略细碎段。无用的信息就不要往 $\mathtt{dp}$ 状态里塞。有用的区间可能是 $[s_i,t_i](s_i<a_i-l_i<t_i)$ 和 $[s_i,t_i](s_i<a_i<t_i)$，也就是覆盖前缀或后缀。

那么我们枚举一个区间 $p$，它覆盖一段前缀，其余的区间就不能覆盖到它的右边。$p$ 可能是选左，此时不被忽略的区间只有 $p$ 之前的区间；$p$ 可能选右，不被忽略的区间则是 $[1,i)$ 的区间，这个 $i$ 与 $p$ 没有关系。

所以我们不要拘泥于一维 $\mathtt{dp}$，记 $f(p,i)$ 为只考虑 $[1,i]$ 区间、$p$ 区间选右、其余区间不覆盖 $p$ 之右，最长覆盖距离和。转移还是用同样的方法，枚举覆盖前缀的区间 $j$，从 $f(j,p-1)$ 转移过来。

$g(p)$ 为只考虑 $[1,p]$ 区间、$p$ 区间选左、其余区间不覆盖 $p$ 之右，最长覆盖距离和。相较之下，它的转移容易些，故此处从略。

时间复杂度 $\mathcal{O}(n^3)$ 。代码实现比较流畅。交上去就过不了，又调试了很久。

代码

可能不存在覆盖前缀的区间，故最好令初值为区间长度（相当于只选出自己）。

#include <cstdio> // JZM yydJUNK!!!
#include <iostream> // XJX yyds!!!
#include <algorithm> // XYX yydLONELY!!!
#include <cstring> // (the STRONG long for LONELINESS)
#include <cctype> // ZXY yydSISTER!!!
using namespace std;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
typedef long long llong;
inline int readint(){
	int a = 0, c = getchar(), f = 1;
	for(; !isdigit(c); c=getchar())
		if(c == '-') f = -f;
	for(; isdigit(c); c=getchar())
		a = (a<<3)+(a<<1)+(c^48);
	return a*f;
}
inline void getMax(int &x, const int &y){
	if(x < y) x = y;
}

const int MAXN = 105;
std::pair<int,int> a[MAXN];
int lef[MAXN], rig[MAXN][MAXN];

const int INF = 200000000;
int main(){
	int n = readint();
	rep(i,1,n) a[i].first = readint(), a[i].second = readint();
	std::sort(a+1,a+n+1); // sort by COORD
	for(int i=1; i<=n; ++i){
		lef[i] = a[i].second; // only itself
		for(int j=1; j!=i; ++j){ // last longest
			if(a[j].first+a[j].second <= a[i].first)
				getMax(lef[i],rig[i-1][j]+min(a[i].first
					-a[j].first-a[j].second,a[i].second));
			getMax(lef[i],lef[j]+min(a[i].first-a[j].first,a[i].second));
		}
		int l = a[i].first; // whatever
		for(int j=i; j; --j){ // my longest
			const int w = a[j].first+a[j].second;
			l = std::min(l,a[j].first); // itself's left point
			if(w >= a[i].first){ // really longer
				rig[i][j] = w-l; // only itself
				for(int k=1; k!=j; ++k){ // previous longest
					getMax(rig[i][j],rig[j-1][k]+w
						-max(a[k].first+a[k].second,l));
					getMax(rig[i][j],lef[k]+w-max(l,a[k].first));
				}
			}
			else rig[i][j] = rig[i-1][j]; // not to choose it
			l = min(l,a[j].first-a[j].second); // be toL
		}
	}
	int ans = lef[n]; // @a lef is non-decreasing
	rep(i,1,n) getMax(ans,rig[n][i]);
	printf("%d\n",ans);
	return 0;
}

后记

仿照 $\text{Lanterns}$ 的做法，不以区间为决策，以覆盖情况为决策，至少应该能做到 $\mathcal{O}(n^2\log n)$ 。将 $a_i-l_i,a_i,a_i+l_i$ 一起离散化，预处理 $g(i,j)$ 为能否用内部区间覆盖第 $i$ 段到第 $j$ 段。对于某个 $i$，用 $\text{Lanterns}$ 的方法是 $\mathcal{O}(n\log n)$ 的。

纯口胡，似乎可以做到 $\mathcal{O}(n^2)$ 。因为 $\mathtt{ST}$ 表是 $\mathcal{O}(n\log n)$ 的，瓶颈在于，求出形如 $h(i)⩾w_j$ 的最小 $i$ 。如果先把 $w_j$ 离散化出来，对于每个 $f(i)$ 立刻更新其可以转移到的 $j$，就没有二分的过程了。注意 $h(i)$ 是 “段” 的编号，所以应该可以预处理后 $\mathcal{O}(1)$ 查出可更新区间。

最后，其实存在 $\mathcal{O}(n^2)$ 的纯 $\mathtt{dp}$ 做法，已经被 $\mathsf{OUYE}$ 在看到题后的 $10\min$ 内想出。我花了 $2h30min$ 只想出 $\mathcal{O}(n^3)$ 。