倍增优化DP

概述

倍增优化DP是一类常见的DP优化方式，多见于多询问的DP问题，这是因为倍增优化DP可以在 $O(\log n)$ 的时间内拼出一个区间，如果用普通DP，很可能出现爆空间等错误。

倍增优化DP的基本状态设计是 $f_{i,j}$ ，通常表示 $i$ 走 $2^j$ 步出现的结果或构成的区间的贡献。当然，这只是框架，还要加其他状态依题目具体而定。

在设计倍增的状态时，要注意几点：

“步”，必须是整体。注意：权值往往是不能划分的，但是，权值所属的物品有时可以当做 “步”。
树上倍增的题目， $f_{i,j}$ 表示 $i$ 到 $2^j$ 级祖先路径上的信息，或表示 $i$ 的 $2^j$ 祖先的信息。
倍增修改相对困难，若一道题的倍增支持修改，那么 $f_{i,j}$ 中的 $i$ 一般不大，由于 $j$ 是 $2$ 的指数，所以当做常数看待，这种题基本用数据结构维护。
$f_j$ 是由两个 $f_{j-1}$ 合并得来，可以理解为满足区间可加性。
如果是一步步跳，那么一般考虑倍增。
如果 $f_{i,j}$ 表示的不是区间，那么通常要记录从 $i$ 出发，走 $2^j$ 步，走到哪里。不然不能用两个 $j-1$ 的状态拼凑出 $j$ 的状态。

应用

这种优化思想在题目中用的很多，在不少算法中也有涉及。

倍增求LCA ：设 $f_{i,j}$ 表示 $i$ 的 $2^j$ 辈祖先节点，可以发现，这里的 “步” 就是每次跳的一步，不是权值， $O(n\log n)$ 预处理， $O(\log n)$ 查询。

RMQ区间最值：设 $f_{i,j}$ 表示区间 $[i,i+2^j-1]$ 的最值，可以做到 $O(n\log n)$ 预处理， $O(1)$ 查询。

题目

跑路

先找上面提到的 “步”，发现无论是 “秒”，还是两个点之间的长度，都是 $1$ ，于是我们可以设秒为步，规范的说：设 $f_{i,j,k}$ 表示从 $i$ 出发，经过 $2^k$ 秒能否到 $j$ ，然后在 $f_{i,j,k}=1$ 的 $(i,j)$ 之间连权值为 $1$ 的边（跑路器每秒可以跑 $2^k$ 米），跑一遍最短路即可。

为什么要用倍增？题目提示很明显：

每秒钟可以跑 $2^k$ 千米。

 const int N = 100;
int n, m;
int g[N][N][N];
int f[N][N];
 
void init() {
	fr(k, 1, 65)
	  fr(z, 1, n)
		fr(i, 1, n)
		  fr(j, 1, n)
			g[i][j][k] |= (g[i][z][k - 1] && g[z][j][k - 1]);
}
 
void Floyed() {
	fr(k, 1, n)
	  fr(i, 1, n)
	  	fr(j, 1, n)
	  	  if(k != i && i != j && j != k) f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
}
 
int main() {
	cin >> n >> m;
	fr(i, 1, m) {
		int u, v; cin >> u >> v;
		g[u][v][0] = 1;
	}
 
	init();
	memset(f, 0x3f, sizeof(f));
	fr(i, 1, n)
	  fr(j, 1, n)
	  	fr(k, 0, 65)
	  	  if(g[i][j][k]) f[i][j] = 1;
	
	Floyed();
	
	cout << f[1][n] << '\n';
 
	return 0;
}

Minimal Segment Cover

首先，肯定不能设出 $f_{i,j}$ 这种从 $i$ 开始，跨越 $2^j$ 长度的最小线段数，这种倍增纯粹胡来。因为权值一般是不能放进 $j$ 里面的，这不符合我们对 "步" 的定义，而且没有办法转移，因为没有办法将两个 $j-1$ 的状态进行合并。

可以设 $f_{i,j}$ 表示从点 $i$ 出发，跨越 $2^j$ 条线段，最远可以到达的点，这里用到了上面提及的技巧，“权值是不能作为状态的，但是权值的主人往往可以作为状态”。很容易写出转移方程：

f_{i, j} = f_{f_{i, j - 1}, j - 1}

$f_{i,j}=f_{f_{i,j-1},j-1}$

初始化 $f$ 数组一定不能只算端点值，要将区间中间的点也计算进去。详细见代码。

对于每次询问，我们从 $x$ 出发，用类似二进制拆分的思想，从高位到低位依次向后跳，依次统计答案，这里的代码实现有点类似倍增求LCA，详见代码。

 const int N = 5e5 + 10;
int n, m, maxn;
int f[N][20];
 
int main() {
    cin >> n >> m;
	fr(i, 1, n) {
		int l, r; cin >> l >> r;
		f[l][0] = max(f[l][0], r);
		maxn = max(maxn, r);
	}
	fr(i, 1, maxn) if(f[i - 1][0] >= i) f[i][0] = max(f[i][0], f[i - 1][0]);
	fr(i, 1, 19)
		fr(j, 0, maxn) {
			f[j][i] = max(f[j][i], f[f[j][i - 1]][i - 1]);
		}
	while(m --) {
		int l, r, np, ans = 0; cin >> l >> r;
		np = l;
		rf(i, 19, 0) {
			if (f[np][i] < r) ans += (1 << i), np = f[np][i];
            //不能写小于等于，如果r是右端点，那么跳再多次也是白搭
		}
		if (f[np][0] >= r) cout << ans + 1 << '\n';
		else cout << -1 << '\n';
	}
    return 0;
}

[CERC2017]Donut Drone

如果没有修改操作，直接设 $f_{i,j,k}$ 表示从 $(i,j)$ 出发，走 $2^k$ 步可以到的坐标，就是道纯纯的屑题。

但是有修改操作。。。

众所周知，暴力可以极大的降低题目难度。

考虑每次先暴力的将在矩阵上的点 $(x,y)$ 跳到第一列 $(x',1)$ ，然后一圈圈的跳，最后再将没有跳够的暴力补上。如果中间的跳圈可以倍增实现，那么查询一次的时间复杂度就是 $O(m+\log k)$ ，完全可以接受。

由于我们只关心从第一列的某行，跳几圈会到第一列的第几行，所以可以设 $f_{i,j}$ 表示从第1列的 $i$ 行出发，跳 $2^j$ 圈，会跳到哪里。

现在我们考虑如何支持修改。

我们再维护一个数组 $dp_{l,r,i}$ 表示在第 $i$ 行，从 $l$ 开始走，走完区间 $[l,r]$ ，也就是走到 $r+1$ ，会处于哪一行。考虑这个dp如何转移，显然，这种类似区间dp的东西可以选择一个断点，记作 $k$ . 于是：

d p_{l, r, i} = d p_{k + 1, r, d p_{l, k, i}}

$dp_{l,r,i}=dp_{k+1,r,dp_{l,k,i}}$

由于这不是最优化或者计数问题，所以我们可以随意取一个点，取中点吧。设 $k=mid=\frac{l+r}{2}$ ，式子改写为：

d p_{l, r, i} = d p_{m i d + 1, r, d p_{l, m i d, i}}

$dp_{l,r,i}=dp_{mid+1,r,dp_{l,mid,i}}$

是不是很像线段树的pushup ？

没错，这个东西是满足区间可加性的，所以考虑用线段树储存。

对于修改 $(x, y)$ 的状态，最近的会影响 $y-1$ 列的状态，所以对 $y-1$ 列进行单点修改即可。

于是， $dp_{1,m,i}$ 就是 $f_{i,0}$ 的答案，在每次询问时，暴力修改倍增数组 $f$ 即可。

时间复杂度： $O(n\log n)$

 const int N = 2100;
int n, m, q;
int a[N][N];
int tr[N << 2][N], f[N][31];
 
int to(int x, int y) {
	int ty = (y+1<=m?y+1:1), tx1 = x, tx2 = (x+1<=n?x+1:1), tx3 = (x-1>=1?x-1:n);
	if (a[tx1][ty] > a[tx2][ty] && a[tx1][ty] > a[tx3][ty]) return tx1;
	else if (a[tx2][ty] > a[tx1][ty] && a[tx2][ty] > a[tx3][ty]) return tx2;
	else return tx3;
}
 
struct Segment_Tree {
	void pushup(int nd) {
		fr(i, 1, n) tr[nd][i] = tr[nd << 1 | 1][tr[nd << 1][i]];
	}
	
	void build(int nd, int l, int r)  {
		if (l == r) {
			fr(i, 1, n) tr[nd][i] = to(i, l);
			return ;
		}
		int mid = l + r >> 1;
		build(nd << 1, l, mid);
		build(nd << 1| 1, mid + 1, r);
		pushup(nd);
	}
	
	void change(int nd, int l, int r, int x) { // 更新第 x 列 
		if (l > x || r < x) return ;
		if (x == l && l == r) {
			fr(i, 1, n) tr[nd][i] = to(i, l);
			return ;
		}
		int mid = l + r >> 1;
		change(nd << 1, l, mid, x);
		change(nd << 1 | 1, mid + 1, r, x);
		pushup(nd);
	}
}T;
 
int main() {
	cin >> n >> m;
	fr(i, 1, n) fr(j, 1, m) cin >> a[i][j];
	cin >> q;
	T.build(1, 1, m);
	int nx, ny; nx = ny = 1;
	while(q --) {
		string s; int k, x, y;
		cin >> s;
		if (s == "move") {
			cin >> k;
			if (ny != 1) {
				while(k) {
					nx = to(nx, ny);
					ny = (ny+1<=m?ny+1:1);
					k --;
					if (ny == 1) break;
				}
			}
			if (!k) { cout << nx << ' ' << ny << '\n'; continue; }
			
			fr(i, 1, n) f[i][0] = tr[1][i];
			fr(i, 1, 30) fr(j, 1, n) f[j][i] = f[f[j][i - 1]][i - 1];
			int cnt = k / m, bcnt = k % m;
			rf(i, 30, 0) {
				if ((1 << i) <= cnt) { nx = f[nx][i]; cnt -= (1 << i); }
			}
			fr(i, 1, bcnt) {
				nx = to(nx, ny);
				ny = (ny+1<=m?ny+1:1);
			}
			cout << nx << ' ' << ny << '\n';
		}
		else {
			cin >> x >> y >> k;
			a[x][y] = k;
			int ty = (y-1>=1?y-1:m);
			T.change(1, 1, m, ty);
		}
	}
 
	return 0;
}

开车旅行

为了方便，首先用set求出小A和小B分别从城市i出发，会走到的城市，分别记作 $ga_i,gb_i$ .

多询问的DP问题，比较明显是倍增了。

考虑如何倍增，可以发现，记城市个数和天数都是可以的，毕竟两者都可以看做一步，或者说一个整体。

设 $f_{i,j,0/1}$ 表示，从城市 $i$ 出发，走 $2^j$ 天，第一天是小A/小B 开车，会到达的城市。

转移方程也很简单：

f_{i, 0, 0 / 1} = g a_{i} / g b_{i} f_{i, 1, 0 / 1} = f_{f_{i, 0, 1 / 0}, 0, 1 / 0} f_{i, j > 1, 0 / 1} = f_{f_{i, j - 1, 0 / 1}, j - 1, 0 / 1}

$f_{i,0,0/1}=ga_i/gb_i\\ f_{i,1,0/1}=f_{f_{i,0,1/0},0,1/0}\\ f_{i,j>1,0/1}=f_{f_{i,j-1,0/1},j-1,0/1}$

其中 $j=1$ 的情况一定要注意，因为这两天先是A开车，再是B开车。

由于题目还要求小A和小B分别行驶的路程，我们设 $da_{i,j,0/1}$ 表示从城市 $i$ 出发，走 $2^j$ 天，小A/小B 先开车，小A行驶的距离； $db_{i,j,0/1}$ 表示从城市 $i$ 出发，走 $2^j$ 天，小A/小B 先开车，小B行驶的距离。

转移方程类似于 $f$ 数组，详见代码。

 const int N = 1e5 + 10;
const LL INF = 1e12;
int n, m, h[N];
int ga[N], gb[N];
LL f[18][N][2], da[18][N][2], db[18][N][2];
set<PII> s;
 
void init() {
	s.insert({INF, 0}); s.insert({INF + 1, 0});
	s.insert({-INF, 0}); s.insert({-INF - 1, 0});
	//提前插入4个最值，有利于避免越界。
    rf(i, n, 1) {
		PII t = {h[i], i};
		auto it = s.lower_bound(t);
		++it;
		vector <PII> g; g.clear();
		fr(j, 0, 3) {
			g.push_back(*it);
			--it;
		}
		LL minn = INF + 10, cmin = INF + 10; int p1 = 0, p2 = 0;
		rf(j, 3, 0) {
			LL d = abs(g[j].first - h[i]);
			if (d < minn) {
				cmin = minn; minn = d;
				p2 = p1; p1 = g[j].second;
			}
			else if (d < cmin) {
				cmin = d; p2 = g[j].second;
			}
		}
		s.insert({h[i], i});
		ga[i] = p2; gb[i] = p1;
	}
}
 
void calc(int p, int x, int &la, int &lb) {
	la = lb = 0;
	rf(i, 17, 0) {
		if (f[i][p][0] && la + lb + da[i][p][0] + db[i][p][0] <= x) {
			la += da[i][p][0]; lb += db[i][p][0];
			p = f[i][p][0];
		}
	}
}
 
int main() {
	ios::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);
 
	cin >> n;
	fr(i, 1, n) cin >> h[i];
	init();
	fr(i, 1, n) {
		f[0][i][0] = ga[i]; f[0][i][1] = gb[i];
		da[0][i][0] = abs(h[i] - h[ga[i]]);
		db[0][i][1] = abs(h[i] - h[gb[i]]);
	}
	fr(i, 1, 17)
	  fr(j, 1, n)
		fr(k, 0, 1) {
			if (i == 1) f[i][j][k]=f[i-1][f[i-1][j][k]][1-k];
			else f[i][j][k]=f[i-1][f[i-1][j][k]][k];
			if (i == 1) da[i][j][k]=da[0][j][k]+da[0][f[0][j][k]][1-k];
			else da[i][j][k] = da[i-1][j][k] + da[i-1][f[i-1][j][k]][k];
			if (i == 1) db[i][j][k]=db[0][j][k]+db[0][f[0][j][k]][1-k];
			else db[i][j][k] = db[i-1][j][k] + db[i-1][f[i-1][j][k]][k];
		}
	
	int x; cin >> x >> m;
	LL maxh = -INF, res = 0; double minn = INF;
	fr(i, 1, n) {
		int la, lb; calc(i, x, la, lb);
		double s = lb?la*1.0/lb:INF;
		if (s < minn || (s == minn && h[i] > maxh)) {
			minn = s;
			maxh = h[i];
			res = i;
		}
	}
	cout << res << '\n';
 
	fr(i, 1, m) {
		int x, s, la, lb;
		cin >> s >> x;
		calc(s, x, la, lb);
		cout << la << ' ' << lb << '\n';
	}
	return 0;
}

posted @ 2022-11-11 23:18 2017BeiJiang 阅读(469) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 单线程的Redis速度为什么快？
· 展开说说关于C#中ORM框架的用法！
· Pantheons：用 TypeScript 打造主流大模型对话的一站式集成库
· SQL Server 2025 AI相关能力初探
· 为什么退出登录或修改密码无法使 token 失效

公告

昵称： 2017BeiJiang
园龄： 4年3个月
粉丝： 2
关注： 4

+加关注

2025年3月

日

一

二

三

四

五

六

随笔档案 (76)

文章档案 (7)

2022年11月(7)

阅读排行榜

评论排行榜

1. Edu 169 补题记录(1)

Oracle's Blog

倍增优化DP

概述

应用

题目

跑路

Minimal Segment Cover

[CERC2017]Donut Drone

开车旅行

公告

搜索

常用链接

最新随笔

我的标签

积分与排名

随笔档案 (76)

文章档案 (7)

相册 (5)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

	const int N = 100;
	int n, m;
	int g[N][N][N];
	int f[N][N];

	void init() {
	fr(k, 1, 65)
	fr(z, 1, n)
	fr(i, 1, n)
	fr(j, 1, n)
	g[i][j][k] \|= (g[i][z][k - 1] && g[z][j][k - 1]);
	}

	void Floyed() {
	fr(k, 1, n)
	fr(i, 1, n)
	fr(j, 1, n)
	if(k != i && i != j && j != k) f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
	}

	int main() {
	cin >> n >> m;
	fr(i, 1, m) {
	int u, v; cin >> u >> v;
	g[u][v][0] = 1;
	}

	init();
	memset(f, 0x3f, sizeof(f));
	fr(i, 1, n)
	fr(j, 1, n)
	fr(k, 0, 65)
	if(g[i][j][k]) f[i][j] = 1;

	Floyed();

	cout << f[1][n] << '\n';

	return 0;
	}

	const int N = 5e5 + 10;
	int n, m, maxn;
	int f[N][20];

	int main() {
	cin >> n >> m;
	fr(i, 1, n) {
	int l, r; cin >> l >> r;
	f[l][0] = max(f[l][0], r);
	maxn = max(maxn, r);
	}
	fr(i, 1, maxn) if(f[i - 1][0] >= i) f[i][0] = max(f[i][0], f[i - 1][0]);
	fr(i, 1, 19)
	fr(j, 0, maxn) {
	f[j][i] = max(f[j][i], f[f[j][i - 1]][i - 1]);
	}
	while(m --) {
	int l, r, np, ans = 0; cin >> l >> r;
	np = l;
	rf(i, 19, 0) {
	if (f[np][i] < r) ans += (1 << i), np = f[np][i];
	//不能写小于等于，如果r是右端点，那么跳再多次也是白搭
	}
	if (f[np][0] >= r) cout << ans + 1 << '\n';
	else cout << -1 << '\n';
	}
	return 0;
	}

	const int N = 2100;
	int n, m, q;
	int a[N][N];
	int tr[N << 2][N], f[N][31];

	int to(int x, int y) {
	int ty = (y+1<=m?y+1:1), tx1 = x, tx2 = (x+1<=n?x+1:1), tx3 = (x-1>=1?x-1:n);
	if (a[tx1][ty] > a[tx2][ty] && a[tx1][ty] > a[tx3][ty]) return tx1;
	else if (a[tx2][ty] > a[tx1][ty] && a[tx2][ty] > a[tx3][ty]) return tx2;
	else return tx3;
	}

	struct Segment_Tree {
	void pushup(int nd) {
	fr(i, 1, n) tr[nd][i] = tr[nd << 1 \| 1][tr[nd << 1][i]];
	}

	void build(int nd, int l, int r) {
	if (l == r) {
	fr(i, 1, n) tr[nd][i] = to(i, l);
	return ;
	}
	int mid = l + r >> 1;
	build(nd << 1, l, mid);
	build(nd << 1\| 1, mid + 1, r);
	pushup(nd);
	}

	void change(int nd, int l, int r, int x) { // 更新第 x 列
	if (l > x \|\| r < x) return ;
	if (x == l && l == r) {
	fr(i, 1, n) tr[nd][i] = to(i, l);
	return ;
	}
	int mid = l + r >> 1;
	change(nd << 1, l, mid, x);
	change(nd << 1 \| 1, mid + 1, r, x);
	pushup(nd);
	}
	}T;

	int main() {
	cin >> n >> m;
	fr(i, 1, n) fr(j, 1, m) cin >> a[i][j];
	cin >> q;
	T.build(1, 1, m);
	int nx, ny; nx = ny = 1;
	while(q --) {
	string s; int k, x, y;
	cin >> s;
	if (s == "move") {
	cin >> k;
	if (ny != 1) {
	while(k) {
	nx = to(nx, ny);
	ny = (ny+1<=m?ny+1:1);
	k --;
	if (ny == 1) break;
	}
	}
	if (!k) { cout << nx << ' ' << ny << '\n'; continue; }

	fr(i, 1, n) f[i][0] = tr[1][i];
	fr(i, 1, 30) fr(j, 1, n) f[j][i] = f[f[j][i - 1]][i - 1];
	int cnt = k / m, bcnt = k % m;
	rf(i, 30, 0) {
	if ((1 << i) <= cnt) { nx = f[nx][i]; cnt -= (1 << i); }
	}
	fr(i, 1, bcnt) {
	nx = to(nx, ny);
	ny = (ny+1<=m?ny+1:1);
	}
	cout << nx << ' ' << ny << '\n';
	}
	else {
	cin >> x >> y >> k;
	a[x][y] = k;
	int ty = (y-1>=1?y-1:m);
	T.change(1, 1, m, ty);
	}
	}

	return 0;
	}

	const int N = 1e5 + 10;
	const LL INF = 1e12;
	int n, m, h[N];
	int ga[N], gb[N];
	LL f[18][N][2], da[18][N][2], db[18][N][2];
	set<PII> s;

	void init() {
	s.insert({INF, 0}); s.insert({INF + 1, 0});
	s.insert({-INF, 0}); s.insert({-INF - 1, 0});
	//提前插入4个最值，有利于避免越界。
	rf(i, n, 1) {
	PII t = {h[i], i};
	auto it = s.lower_bound(t);
	++it;
	vector <PII> g; g.clear();
	fr(j, 0, 3) {
	g.push_back(*it);
	--it;
	}
	LL minn = INF + 10, cmin = INF + 10; int p1 = 0, p2 = 0;
	rf(j, 3, 0) {
	LL d = abs(g[j].first - h[i]);
	if (d < minn) {
	cmin = minn; minn = d;
	p2 = p1; p1 = g[j].second;
	}
	else if (d < cmin) {
	cmin = d; p2 = g[j].second;
	}
	}
	s.insert({h[i], i});
	ga[i] = p2; gb[i] = p1;
	}
	}

	void calc(int p, int x, int &la, int &lb) {
	la = lb = 0;
	rf(i, 17, 0) {
	if (f[i][p][0] && la + lb + da[i][p][0] + db[i][p][0] <= x) {
	la += da[i][p][0]; lb += db[i][p][0];
	p = f[i][p][0];
	}
	}
	}

	int main() {
	ios::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);

	cin >> n;
	fr(i, 1, n) cin >> h[i];
	init();
	fr(i, 1, n) {
	f[0][i][0] = ga[i]; f[0][i][1] = gb[i];
	da[0][i][0] = abs(h[i] - h[ga[i]]);
	db[0][i][1] = abs(h[i] - h[gb[i]]);
	}
	fr(i, 1, 17)
	fr(j, 1, n)
	fr(k, 0, 1) {
	if (i == 1) f[i][j][k]=f[i-1][f[i-1][j][k]][1-k];
	else f[i][j][k]=f[i-1][f[i-1][j][k]][k];
	if (i == 1) da[i][j][k]=da[0][j][k]+da[0][f[0][j][k]][1-k];
	else da[i][j][k] = da[i-1][j][k] + da[i-1][f[i-1][j][k]][k];
	if (i == 1) db[i][j][k]=db[0][j][k]+db[0][f[0][j][k]][1-k];
	else db[i][j][k] = db[i-1][j][k] + db[i-1][f[i-1][j][k]][k];
	}

	int x; cin >> x >> m;
	LL maxh = -INF, res = 0; double minn = INF;
	fr(i, 1, n) {
	int la, lb; calc(i, x, la, lb);
	double s = lb?la*1.0/lb:INF;
	if (s < minn \|\| (s == minn && h[i] > maxh)) {
	minn = s;
	maxh = h[i];
	res = i;
	}
	}
	cout << res << '\n';

	fr(i, 1, m) {
	int x, s, la, lb;
	cin >> s >> x;
	calc(s, x, la, lb);
	cout << la << ' ' << lb << '\n';
	}
	return 0;
	}