线段树优化DP学习笔记 & JZOJ 孤独一生题解

在 $DP$ 的世界里
有一种题需要单调队列优化 $DP$
一般在此时，$f_i$ 和它的决策集合 $f_j$ 在转移时 $i$ 不和 $j$ 粘在一起（即所有的 $j$ 转移到 $i$时 关于$j$ 的部分全都与 $i$无关），
果真如此，我们就可以用单调队列优化，留下可能用到的更有决策
而很多情况下 $i,j$ 有联系，$i$ 对于不同的 $j$ ，转移计入的贡献和 $i,j$ 都有联系，如
$f_i = \min_{j=1}^{j<i} f_j+s_{i-1}-s_j+|h_i - h_{j-1}|$
此时单调队列就无用武之地了
那怎么办
各种奇妙的优化

本文我们来学习线段树优化 $DP$，解决上面问题

在例题中感受美

JZOJ孤独一生

题目大意：
将序列 $H$ 划分为两个可空集合。
对于一个集合 $S={P1,P2,...P|S|}$，其中要求 $P1<P2<...<P|S|$，它的花费是 $\sum_{i=1}^{|S|} |H_{P_i}-H_{P_{i-1}}|$
最小化花费
解法：
还好的 $dp$
设 $f_i$ 表示处理完 $1--i$ 个元素的最小花费
那么转移考虑当前的 $i$ 所属集合前一个元素是谁
枚举一个 $j$， $j-1$ 和 $i$ 同属一个集合
那么转移就是 $f_i = \min_{j=1}^{j<i} f_j+s_{i-1}-s_j+|h_i - h_{j-1}|$
其中 $s_i = s_{i-1} + |h_i - h_{i-1}|$

一眼望去 $O(n^2)$
再望，绝对值太糟糕（单调队列挂了花）
怎办？
去！
用线段树维护
······
不会啊？

如何用线段树
君不见，绝对值从天上来，纠缠 $(i,j)$ 不可休······
插！
分类讨论，绝对值分开，把式子变好看，这样 $i,j$ 就分开了
$1$ 若 $h_i > h_j$ 则 $f_i = f_j+s_{i-1}-s_j+h_i-h_{j-1}$
整理得 $f_i = (s_{i-1}+h_i)+(f_j-s_j-h_{j-1})$
$2$ 若 $h_i > h_j$ 则 $f_i = f_j+s_{i-1}-s_j-h_i+h_{j-1}$
整理得 $f_i = (s_{i-1}-h_i)+(f_j-s_j+h_{j-1})$

总算把 $(i,j)$ 分开了
此时做商量

如何让 $1$ 式最小，因为决定于 $j$，所以让后面一堆最小
发现可以用线段树维护 $f_j-s_j-h_{j-1}$ 的最小值
因为判定时和 $j-1$ 有关，所以维护以 $h_{j-1}$ 为下标的权值线段树
具体来说就是在 $h_{j-1}$ 的位置插入值 $f_j-s_j-h_{j-1}$
因为顺序枚举，所以算完一个插一个，保证正确性
只需取出线段树中 $0--h_{i}$ 的最小值即可

$2$ 式同理（再开一棵权值线段树，因为另一种 $j$ 的贡献长得不一样）

代码（常数巨大，不得不开O）

#pragma GCC optimize(2)
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
 
const int N = 500000;
int n , h[N + 5] , id[N + 5];
LL f[N + 5] , s[N + 5];
 
inline LL Min(LL x , LL y) { return x < y ? x : y; }
inline int Abs(int x) { return x < 0 ? -x : x; }
struct node{ int l , r; }e[N + 5];
struct tree{
	LL tr[(N << 2) + 5];
	inline void full() { memset(tr , 120 , sizeof(tr)); }
	inline void change(int k , int l , int r , int x , LL v)
	{
		tr[k] = Min(tr[k] , v);
		if (l == r) return;
		register int mid = (l + r) >> 1;
		if (x <= mid) change(k << 1 , l , mid , x , v);
		else change(k << 1 | 1 , mid + 1 , r , x , v);
	}
	inline LL query(int k , int l , int r , int x , int y)
	{
		if (l >= x && r <= y) return tr[k];
		register int mid = (l + r) >> 1;
		register LL res = 1e18;
		if (x <= mid) res = Min(res , query(k << 1 , l , mid , x , y));
		if (y > mid) res = Min(res , query(k << 1 | 1  , mid + 1 , r , x , y));
		return res;
	}
}p,q;
 
inline int read()
{
	register char ch = getchar();
	register LL res = 0;
	while (ch < '0' || ch > '9') ch = getchar();
	while (ch >= '0' && ch <= '9') res = res * 10 + ch - '0' , ch = getchar();
	return (int)res;
}
 
inline bool cmp(node x , node y) { return x.l < y.l; }
 
int main()
{
//	freopen("a.in" , "r" , stdin);
	n = read();
	for(register int i = 1; i <= n; i++) 
	{
		h[i] = read() , e[i].l = h[i] , e[i].r = i;
		s[i] = s[i - 1] + (LL)Abs(h[i] - h[i - 1]);
	}
	sort(e + 1 , e + n + 1 , cmp);
	for(register int i = 1; i <= n; i++) id[e[i].r] = i;
 
	q.full() , p.full();
	q.change(1 , 0 , n , 0 , 0);
	p.change(1 , 0 , n , 0 , 0);
	f[0] = 0;
	
	for(register int i = 1; i <= n; i++)
	{
		LL x = q.query(1 , 0 , n , 0 , id[i]);
		LL y = p.query(1 , 0 , n , id[i] , n);
		f[i] = Min(s[i - 1] + h[i] + x , s[i - 1] - h[i] + y);
		q.change(1 , 0 , n , id[i - 1] , f[i] - s[i] - h[i - 1]);
		p.change(1 , 0 , n , id[i - 1] , f[i] - s[i] + h[i - 1]);
	}
	for(register int i = 1; i <= n; i++) f[n] = Min(f[n] , f[i] + s[n] - s[i]);
	printf("%lld" , f[n]);
}

很多时候，线段树优化 $DP$ 的具体方法因题而异，不可一概而论
要想更好的掌握，就要多做题