【学习笔记】决策单调性优化DP

LK自动机

已于 2024-08-02 22:13:24 修改

阅读量430

点赞数 10

文章标签：学习笔记动态规划 DP优化决策单调性

于 2024-08-02 21:58:02 首次发布

本文链接：https://blog.csdn.net/Eric1561759334/article/details/140878762

版权

背景

GDCPC还在发力，清华出题组出的牛客还是 4 题。
这次没有min25筛，不然我能5题（bushi

除了一道用 prufer 序列的恶心 DP 外，还有一道DP题是一个状态难想，并且还需要决策单调性优化的DP，被认为是偏简单的银牌题。

先来看个相对简单的问题

鸡蛋掉落

在这里插入图片描述

这是一道非常经典的面试题。本博客不会介绍这题的最优方法（时间复杂度 $O(\sqrt n)$ ）

暴力DP

设 $f_{i,j}$ 为还剩 $i$ 个鸡蛋，楼高 $j$ 层，需要的最少实验次数。
显然有转移：
$f_{i,j} = \min\{\max (f_{i-1,w-1}+1,f_{i,j-w}+1)\}, 1 \leq w \leq j$
我们称这种问题为 $minma x$ 问题
时间复杂度 $O(kn\log n)$

优化1

显然，如果鸡蛋足够多，我们可以直接二分出高度。所以当 $k>\log n$ 时可以令 $\log n$

优化2

考虑决策单调性。
一个很显然的结论：

$i$ 相同时， $j$ 越小， $f$ 越小

也就是说：

$f_{i-1,w-1}$ 关于 $w$ 单调递增
$f_{i,j-w}$ 关于 $w$ 单调递减

所以两个函数值的关系如图：
在这里插入图片描述

我们的最优决策点在红色点那里。显然，这玩意可以二分。
时间复杂度 $O(n \log ^2 n)$

class Solution {
public:
    int superEggDrop(int k, int n) {
        vector dp(k+1,vector<int>(n+1));
        for(int i=1; i<=n; i++)
        {
            dp[1][i]=i;
        }
        for(int i=2; i<=k; i++)
        {
            for(int j=1; j<=n; j++)
            {
                int l=1,r=j,pos=-1;
                while(l<=r)
                {
                    int mid=l+r>>1;
                    int x=dp[i-1][mid-1],y=dp[i][j-mid];
                    if(x==y)
                    {
                        pos=mid;
                        break;
                    }
                    else if(x<y)
                        l=mid+1;
                    else
                        r=mid-1;
                }
                if(pos!=-1)
                    dp[i][j]=max(dp[i-1][pos-1],dp[i][j-pos]);
                else
                {
                    dp[i][j]=1e9;
                    pos=l;
                    if(pos>0&&pos<=j) 
                        dp[i][j]=max(dp[i-1][pos-1],dp[i][j-pos]);
                    pos=r;
                    if(pos>0) 
                        dp[i][j]=min(dp[i][j],max(dp[i-1][pos-1],dp[i][j-pos]));
                }
                dp[i][j]++;
            }
        }
        return dp[k][n];
        // cout<<dp[k][n]<<"\n";
    }
};

优化3

回到DP式子
$f_{i,j} = \min\{\max (f_{i-1,w-1}+1,f_{i,j-w}+1)\}, 1 \leq w \leq j$
当 $j$ 增加的时候，最优决策点会发生什么变化？
显然， $f_{i-1,w-1}$ 不会变，但是 $f_{i,j-w}$ 是关于 $j$ 单调递增的。
不难想象，那个红色的点就会往右边走。也就说，最优决策点也满足单调性，当 $j$ 右移时，最优的 $w$ 也右移。
所以我们可以用双指针代替二分。

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


class Solution {
public:
    int superEggDrop(int k, int n) {
        vector dp(k+1,vector<int>(n+1));
        for(int i=1; i<=n; i++)
        {
            dp[1][i]=i;
        }
        for(int i=2; i<=k; i++)
        {
            int w=1;
            for(int j=1; j<=n; j++)
            {
                while(w<j&&dp[i-1][w-1]<dp[i][j-w])
                {
                    w++;
                }
                dp[i][j]=max(dp[i-1][w-1],dp[i][j-w]);
                if(w>1)
                    dp[i][j]=min(dp[i][j],max(dp[i-1][w-2],dp[i][j-w+1]));
                dp[i][j]++;
            }
        }
        return dp[k][n];
        // cout<<dp[k][n]<<"\n";
    }
};

其实还有一种很好的写法是：

先用当前决策点更新 $d p$ 值
如果决策点右移可以使 $d p$ 值更优就继续往右移并更新 $d p$ 值
否则就 $b re ak$

2024牛客暑期多校训练营5 K

在这里插入图片描述

暴力

最暴力的想法是区间DP，设 $dp_{l,r}$ 为已经把答案范围缩小到 $a_l,a_r]$ ，还需要多少代价才能确定答案。
但你很快会发现没办法直接区间DP，因为你根本不知道 $x$ 在哪。
但是如果我们知道之前我左边问过多少次，右边问过多少次，就可以计算区间扩展产生的代价。
所以我们可以设 $dp_{i,j,x,y}$ 代表已经把答案范围缩小到 $a_l,a_r]$ ，之前在区间左边问了 $x$ 次，右边问了 $y$ 次还需要多少代价。

转移就可以枚举中间点 $k$ ，令分割点为 $p$ ，那么转移就是
$dp_{l,r,x,y} = \min\{\max(dp_{l,p,x,y+1}+k-a_p+(a_r- a_p)\times y, dp_{p+1,r,x+1,y}+(a_{p+1}-a_l)\times x+a_{p+1}-k)\}$
时间复杂度 $O(n^4\times值域)$

优化1

思考一下，我们真的需要知道两边各询问了多少次吗？
假设 $x > y$ 那么询问代价就是 $x - y$ ，否则就是 $y - x$
$y$ 的代价可以在DP转移的时候直接记录
$x$ 的代价当 $x$ 确定下来的时候可以通过左边询问次数 - 右边询问次数来计算
所以其实我们只需记录三四维的差值就行。

设 $dp_{l,r,c}$ 代表已经把答案范围缩小到 $a_l,a_r]$ ，之前在区间左边和右边询问次数之差为 $c$ 次， $x$ 的全局代价计算 + 还需要的代价。
显然初始化为 $dp_{i,i,c} = a_i\times c$

同样的，转移就可以枚举中间点 $k$ ，令分割点为 $p$ ，那么转移就是
$dp_{l,r,c} = \min\{\max(dp_{l,p,c-1}+k, dp_{p+1,r,c+1}-k)\}$
时间复杂度 $O(n^3\times 值域)$

优化2

可证明， $c$ 不会超过 $O(\log n)$ 个，我不会证（）
时间复杂度 $O(n^2\log n\times 值域)$

优化3

首先，值域那玩意大的离谱。但是从 $d p$ 式子很容易看出来，一个 $+ k$ 一个 $- k$ ，显然是有单调性的， $k$ 的决策点可以 $O (1)$ 求

int get(int l,int r,int pos,int c)
{
	int L=a[pos]+1,R=a[pos+1];
	int x=dp[l][pos][c-1]+L,y=dp[pos+1][r][c+1]-L;
	if(x>=y) return x;
	int mx=min(R-L,(y-x)>>1);
	return max(x+mx,y-mx);
}

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

优化4

现在时间复杂度的瓶颈在于枚举 $p$ ，怎么把这玩意优化掉呢？
当区间左端点不动，右端点增加的时候，显然方程的第一项是不变的，第二项是单调递减的。这个时候把 $p$ 往右移动可以让第一项减小，第二项增大。所以最优决策点 $p$ 会关于 $r$ 单调递增，我们同样可以用双指针来处理决策点。
时间复杂度 $O(n^2\log n)$

代码

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e6+7,inf=1e18,C=60,base=30;
vector<vector<vector<int>>> dp,p;
vector<int> a;
int get(int l,int r,int pos,int c)
{
	int L=a[pos]+1,R=a[pos+1];
	int x=dp[l][pos][c-1]+L,y=dp[pos+1][r][c+1]-L;
	if(x>=y) return x;
	int mx=min(R-L,(y-x)>>1);
	return max(x+mx,y-mx);
}
void O_o()
{
	int n;
	cin>>n;
	a.assign(n,0);
	for(int i=1; i<=n; i++) cin>>a[i];
	dp.assign(n+1,vector<vector<int>>(n+1,vector<int>(C+1,inf)));
	p.assign(n+1,vector<vector<int>>(n+1,vector<int>(C+1,0)));
	for(int len=1; len<=n; len++)
	{
		for(int l=1; l<=n-len+1; l++)
		{
			int r=l+len-1;
			for(int c=1; c<C; c++)
			{
				if(l==r)
				{
					dp[l][r][c]=a[l]*(c-base);
					p[l][r][c]=l;
				}
				else
				{
					int pos=p[l][r-1][c];
					dp[l][r][c]=get(l,r,pos,c);
					while(pos<r-1)
					{
						int v=get(l,r,pos+1,c);
						if(v<dp[l][r][c])
						{
							pos++;
							dp[l][r][c]=v;
						}
						else
							break;
					}
					p[l][r][c]=pos;
				}
			}
		}
	}
	cout<<dp[1][n][base]<<"\n";
}
signed main()
{
	ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
	cout<<fixed<<setprecision(12);
	int T=1;
//	cin>>T;
	while(T--)
	{
		O_o();
	}
}

LK自动机

关注

10
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
【学习笔记】决策单调性优化DP

GDCPC还在发力，清华出题组出的牛客还是 4 题。这次没有min25筛，不然我能5题（bushi除了一道用 prufer 序列的恶心 DP 外，还有一道DP题是一个状态难想，并且还需要决策单调性优化的DP，被认为是偏简单的银牌题。
复制链接

扫一扫