【动态规划之斜率优化】

最新推荐文章于 2023-09-02 09:27:17 发布
最新推荐文章于 2023-09-02 09:27:17 发布
阅读量418 收藏 1
点赞数 1
文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/computs/article/details/123172439
版权

当填表时有枚举行为，就可能涉及到优化，通常就是斜率优化。

  1. 问题描述：给出5个参数，N，M，row，col，k，表示在N * M的区域上，李四初始在(row,col)位置，他一共要迈出k步，且每步都会等概率向上下左右四个方向走一个单位，任何时候李四只要离开N*M的区域，就直接死亡，走了k步之后，李四还在N * M区域的概率，即李四活着的概率。

分析：每一步都有种可能，走k步一共4k种可能，计算有多少种可能在区域内（注意当走出区域后直接死亡）

#include<iostream>
#include<cmath>
using namespace std;
//当前在(row,col)，还有rest要走，返回还在范围内的可能数
int f(int N,int M,int row,int col,int rest) {
	if(row<0 ||row>=N ||col<0 || col>=M) { //越界了直接返回0种可能
		return 0;
	}
	if(rest==0) {
		return 1;//如果还在范围内，rest为0，返回1种可能
	}
	int up=f(N,M,row-1,col,rest-1);
	int down=f(N,M,row+1,col,rest-1);
	int left=f(N,M,row,col-1,rest-1);
	int right=f(N,M,row,col+1,rest-1);
	return up+down+left+right;

}
int main() {


	double result=(double)f(6,5,2,3,5)/pow(4,5);
	cout<<result;
	return 0;
}
  1. 问题描述：给出3个参数，N,M,K,怪兽有N滴血，等着英雄来砍自己，英雄每一次打击，都会让怪兽流失[0M]的血量，到底流失多少？每一次在[0M]上等概率的获取一个值，求K次打击之后，英雄把怪兽砍死的概率

分析：
样本对应模型
这也是一个概率的题目，同样要计算被砍死的情况数。
注意这道题和上一题的区别在于，由于要计算砍死的可能性，所以这道题只有k为0时才是终止情况，因此即使当前怪兽血量小于等于0l依然要继续砍，而上一题是计算存活的情况数，当走出区域后就直接死亡了，自然也不用计算了。

#include<iostream>
#include<cmath>
using namespace std;
//当前怪兽还有N滴血，还剩K刀
//在0-M范围上砍血
//返回当前被该死的情况数
int f(int N,int M,int K){
	if(K==0){//如果血量小于等于0，说明已经砍死。（注意如果当前怪兽已经是小于等于0了，但是K大于0，依然要继续砍，因为被砍到0了，之后的情况依然要算上
		return N<=0?1:0;
	}
	int ways=0;
	for(int i=0;i<=M;i++){
		ways+=f(N-i,M,K-1);
	}
	return ways;
}
int main(){
	int N;
	int M;
	int K;
	cin>>N>>M>>K;
	int sum=f(N,M,K);
	double result=(double)sum/(double)pow((M+1),K);
	cout<<result;
	return 0;
}

改进的暴力递归：
当前血量小于等于0时假设还剩K刀，死亡的可能性：（M+1）K

#include<iostream>
#include<cmath>
#include<vector>
using namespace std;
//当前怪兽还有N滴血，还剩K刀
//在0-M范围上砍血
//返回当前被该死的情况数
int f(int N,int M,int K){
	if(K==0){//如果血量小于等于0，说明已经砍死。（注意如果当前怪兽已经是小于等于0了，但是K大于0，依然要继续砍，因为被砍到0了，之后的情况依然要算上
		return N<=0?1:0;
	}
	if(N<=0){	
		return pow(M+1,K);//死亡的情况数
	}
	int ways=0;
	for(int i=0;i<=M;i++){
		ways+=f(N-i,M,K-1);
	}
	return ways;
}
int main(){
	int N;
	int M;
	int K;
	cin>>N>>M>>K;
	int sum=f(N,M,K);
	double result=(double)sum/(double)pow((M+1),K);
	cout<<result;
	return 0;
}

严格表结构的动态规划初级版

#include<iostream>
#include<cmath>
#include<vector>
using namespace std;

//当前怪兽还有N滴血，还剩K刀
//在0-M范围上砍血
//返回当前被该死的情况数
int f(int N,int M,int K){
	if(K==0){//如果血量小于等于0，说明已经砍死。（注意如果当前怪兽已经是小于等于0了，但是K大于0，依然要继续砍，因为被砍到0了，之后的情况依然要算上
		return N<=0?1:0;
	}
	if(N<=0){	
		return pow(M+1,K);//死亡的情况数
	}
	int ways=0;
	for(int i=0;i<=M;i++){
		ways+=f(N-i,M,K-1);
	}
	return ways;
}
int main() {
	int N;
	int M;
	int K;
	cin>>N>>M>>K;
	vector<vector<int>>dp(K+1,vector<int>(N+1));
	dp[0][0]=1;
	for(int times=1; times<=K;times++) {
		dp[times][0]=pow(M+1,times);//第一列符合递归的终止条件，可以直接计算出来
		for(int j=1; j<=N; j++) {
			int ways=0;
			for(int i=0; i<=M; i++) {
				if(j-i<0){
					ways+=pow(M+1,times-1);//列越界的直接计算出来
				}
				
				else{
					ways+=dp[times-1][j-i];
				}
			}
			dp[times][j]=ways;
		}
	}
	//int sum=dp[K][N];
	int sum=f(N,M,K);
	double result=(double)sum/(double)pow((M+1),K);
	cout<<result;
	return 0;
}

可以看到在填表时有枚举行为，所以还可以继续优化

举个例子：M等于7，如果times等于5，j等于7，那么该位置依赖：dp[4][7,6 5 4 ……0]；
如果times等于5，j等于6,那么该位置依赖：dp[4][6 5 4 3 ……0 -1]。
所以dp[i][j]=dp[i][j-1]+dp[i-1][j]-dp[i-1][j-M-1]，注意最后的j-M-1如果小于0了依然要算进去，只不过要用公式算

#include<iostream>
#include<cmath>
#include<vector>
using namespace std;

//当前怪兽还有N滴血，还剩K刀
//在0-M范围上砍血
//返回当前被该死的情况数
int f(int N,int M,int K) {
	if(K==0) { //如果血量小于等于0，说明已经砍死。（注意如果当前怪兽已经是小于等于0了，但是K大于0，依然要继续砍，因为被砍到0了，之后的情况依然要算上
		return N<=0?1:0;
	}
	if(N<=0) {
		return pow(M+1,K);//死亡的情况数
	}
	int ways=0;
	for(int i=0; i<=M; i++) {
		ways+=f(N-i,M,K-1);
	}
	return ways;
}
int main() {
	int N;
	int M;
	int K;
	cin>>N>>M>>K;
	vector<vector<int>>dp(K+1,vector<int>(N+1));
	dp[0][0]=1;
	for(int times=1; times<=K; times++) {
		dp[times][0]=pow(M+1,times);//第一列符合递归的终止条件，可以直接计算出来
		for(int j=1; j<=N; j++) {
			dp[times][j]=dp[times][j-1]+dp[times-1][j];
			if(j-M-1>=0) {
				dp[times][j]-=dp[times][j-M-1];
			} else {
				dp[times][j]-=pow(M+1,times-1);//注意越界了的情况
			}
		}
	}
	int sum=dp[K][N];
	//int sum=f(N,M,K);
	double result=(double)sum/(double)pow((M+1),K);
	cout<<result;
	return 0;
}
  1. 剑指 Offer II 103. 最少的硬币数目

分析：从左往右的尝试模型
注意在更新最小个数时的操作

class Solution {
public:
//返回从index开始选择硬币来构成rest大小最小需要多少张
    int f(vector<int>&coins,int index,int rest){
        if(index==coins.size()){
            return rest==0?0:INT_MAX;//当前没有硬币可以选了且rest为0，返回0
        }
        int minAmount=INT_MAX;
        for(int t=0;t*coins[index]<=rest;t++){//从0张开始枚举
            int next=f(coins,index+1,rest-t*coins[index]);//从index开始选择硬币来构成rest大小最小需要多少张
            if(next!=INT_MAX){
                minAmount=min(minAmount,t+next);
            }
        }
        return minAmount;
    }
    int coinChange(vector<int>& coins, int amount) {
        return f(coins,0,amount)==INT_MAX?-1:f(coins,0,amount);
    }
};

严格表结构的动态规划 (版本一 含枚举行为)

class Solution {
	public:
		int coinChange(vector<int>& coins, int amount) {
			int n=coins.size();
			vector<vector<int>>dp(n+1,vector<int>(amount+1));
			for(int rest=1; rest<=amount; rest++) {
				dp[n][rest]=INT_MAX;
			}
			for(int index=n-1; index>=0; index--) {
				for(int rest=0; rest<=amount; rest++) {
					int minAmount=INT_MAX;
					for(int t=0; t*coins[index]<=rest; t++) {				            int next=dp[index+1][rest-t*coins[index]];
						if(next!=INT_MAX) {
							minAmount=min(minAmount,t+next);
						}
					}
                    dp[index][rest]=minAmount;
				}

			}
            return dp[0][amount]==INT_MAX?-1:dp[0][amount];
		}
};

改进版的动态规划
其实这个枚举行为也是可以省去的
假设index=3,coins[3]=2，rest=10
所以要填3,10位置的值依赖：4,10；4,8；4,6;4,4；4，2；4,0这几个的最小值加个数
而3,8位置的值依赖：,8；4,6;4,4；4，2；4,0这几个的最小值加个数。注意这个和上一个个数是差1的，最后不要忘了加1

class Solution {
public:
    int f(vector<int>coins,int index,int rest){
        if(index==coins.size()){
            return rest==0?0:INT_MAX;
        }
        int minAmount=INT_MAX;
        for(int t=0;t*coins[index]<=rest;t++){
            int next=f(coins,index+1,rest-t*coins[index]);
            if(next!=INT_MAX){
                minAmount=min(minAmount,t+next);
            }
        }
        return minAmount;
    }
    int coinChange(vector<int>& coins, int amount) {
        int n=coins.size();
			vector<vector<int>>dp(n+1,vector<int>(amount+1));
			for(int rest=1; rest<=amount; rest++) {
				dp[n][rest]=INT_MAX;
			}
			for(int index=n-1; index>=0; index--) {
				for(int rest=0; rest<=amount; rest++) {
                    int minAmount=INT_MAX;
                    if(rest-coins[index]>=0){
                        minAmount=dp[index][rest-coins[index]];
                        if(minAmount!=INT_MAX){//个数加1
                            minAmount++;
                        }
                    }      
                    minAmount=min(minAmount,dp[index+1][rest]);
                    dp[index][rest]=minAmount;
				}

			}
            return dp[0][amount]==INT_MAX?-1:dp[0][amount];

       
    }
};
  1. 给定一个正数n，求n的裂开方法数。规定：后面的数不能比前面的数小 。比如4的裂开方法有： 1+1+1+1、1+1+2、1+3、2+2、4，5种，所以返回5

分析：从左往右尝试，假设当前选择了index，那么后续都要从index开始选择，新的目标值就是aim-index

int f(int index,int aim) {

	if(aim==0) { //找到了一个方法
		return 1;
	}
	if(index>aim){
		return 0;
	}
	
	int ways=0;
	for(int i=index; i<=aim; i++) {
		ways+=f(i,aim-i);//选择了i，后续从i到aim-i选择，每次选择都是非递减的，所以不会出现重复
	}
	return ways;
}

含枚举行为的动态规划

int splitNum(int num) {
	if(num<=0) {
		return 0;
	}
	vector<vector<int>>dp(num+1,vector<int>(num+1));
	for(int index=1; index<=num; index++) {
		dp[index][0]=1;
	}
	for(int index=num; index>=1; index--) {
		for(int aim=index; aim<=num; aim++) {//左下角的元素都是0
			int ways=0;
			for(int i=index; i<=aim; i++) {
				ways+= dp[i][aim-i];//选择了i，后续从i到aim-i选择，每次选择都是非递减的，所以不会出现重复
			}
			dp[index][aim]= ways;
		}
	}

	return dp[1][num];

}

最终版的动态规划
第一处优化：对角线都是1
第二处：省去枚举行为，p[index][aim]和dp[index+1][aim]其实就差了一个dp[index][aim-index]

#include<iostream>
#include<vector>
using namespace std;

int splitNum(int num) {
	if(num<=0) {
		return 0;
	}
	vector<vector<int>>dp(num+1,vector<int>(num+1));
	for(int index=1; index<=num; index++) {
		dp[index][0]=1;
		dp[index][index]=1;//对角线都是1
	}
	for(int index=num-1; index>=1; index--) {//从倒数第二行开始填
		for(int aim=index+1; aim<=num; aim++) {
			dp[index][aim]=dp[index+1][aim]+dp[index][aim-index];//不难发现dp[index][aim]和dp[index+1][aim]其实就差了一个dp[index][aim-index]		
		}
	}

	return dp[1][num];

}


int main() {

	cout<<splitNum(13);
	return 0;
}

总结：当填表有枚举行为时，就分析它旁边的位置，通常都可以替代枚举行为。

progressiveFighting
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
斜率优化动态规划
Zbr162的博客
07-15 330
文章目录$斜率优化的作用$$斜率优化的内容$ 斜率优化的作用斜率优化的作用斜率优化的作用 给出一个化简过的状态转移方程 Fi=min⁡( Fj+si2+(sj+L)2−2si(sj+L) )F_i = \min(\ F_j + s_i^2+(s_j+L)^2-2s_i(s_j+L) \ )Fi​=min( Fj​+si2​+(sj​+L)2−2si​(sj​...
『动态规划优化』优化
Ronaldo7_ZYB的博客
08-26 205
题目描述 现在有一个长度为N的整数序列{ai}\{a_i\}{ai​} ，你需要从中选出KKK个不相交的连续子区间（可以存在元素不被选），从左到右记它们的和为s1,s2,...,sks1,s2,...,sks1,s2,...,sk。我们的优化目标是最大化下述和式： ∑i=1k∣si−si+1∣\sum_{i=1}^{k} |s_i-s_{i+1}|i=1∑k​∣si​−si+1​∣ 你只需要输出这...
动态规划（9）斜率优化
weixin_64197656的博客
10-25 323
简单斜率优化
斜率优化详解(超详细, 有图有代码有注释)
Cherrt的博客
12-26 6144
文章目录斜率优化引入从例题开始斜率优化Part 1: 推为斜率式斜率优化Part 2: 合法点集的斜率单调性Part 3: 找到最优决策点Part 4: 斜率优化大流程Part 5: 斜率优化的优化Part 6: 代码详解斜率优化的一些问题 斜率优化引入 在说斜率优化之前，我们先说说一种更为简单的dpdpdp优化。 比如，有一个dpdpdp式子形如dpi=min⁡0≤j＜idpj+f(j)+g(i)dp_i=\min_{0≤j＜i} {dp_{j}+f(j)+g(i)}dpi​=0≤j＜imin​dpj​+
动态规划的斜率优化
02-03
动态规划的斜率优化，数形结合的运用。不错的论文。
斜率优化动态规划DP
01-11
斜率优化DP
第6章 斜率优化动态规划 测试数据.rar
12-02
斜率优化动态规划是一种在解决动态规划问题时提高效率的策略，主要应用于具有大量重复状态转移的情况。在信息学竞赛中，特别是在面对如《信息学奥赛一本通(提高篇)》这样的教材时，掌握这种优化技巧对于解决复杂的...
浅谈动态规划的几种优化方法
09-09
动态规划是求解最优化问题的一种方法；动态规划虽然空间复杂度一般较大，但时间效率可观。但是，动态规划在求解中也会存在一些不必要... 关键词：动态规划优化，四边形不等式，斜率优化，单调队列，状态压缩动态规划。
动态规划优化、凸包优化 斜率优化
06-06
动态规划优化， 斜率优化 凸包优化 决策单调性 二分优化
史上最详尽的斜率优化！
jz_terry的博客
11-23 1325
最近被钦定要写教材，负责斜率优化那一块，就把写的内容搬了些上来。 3.6.1 斜率优化DP的基本思想 考虑这样一个问题：现在要给n个数a[1],a[2]…a[n]分组，每分出一组，你的代价为该组所有数的和的平方+一个常数M（即设你分出的一组数字是2,3,4，M=5，则你分出该组的代价为（2+3+4）^2+5），求出一种分组方式使得代价总和最小，输出这个最小的代价和。 如果是最基础的dp......
【斜率优化】笔记
C2024XSC184的博客
01-12 200
无
[学习笔记]斜率优化dp 总结
最新发布
sophilex的博客
09-02 633
我们学过不少优化类的算法了，大部分都是基于凸函数的性质给出的优化，比如Slope Trick，Wqs二分，又比如今天的斜率优化（不知道什么时候会有空把Slope Trick写掉）当dp式子满足cy−cxby−bx≤−aiby​−bx​cy​−cx​​≤−ai​的时候，我们要维护的是一个下凸包i
斜率优化DP
qq_55788328的博客
09-05 692
斜率优化DP
学习笔记——斜率优化dp
Young_20220202的博客
07-19 232
优异算法，动态规划。掌上明珠，斜率优化。确实，斜率优化很重要，并且通常式子比码长，脑袋想不清。新手易懂的斜率优化博客来啦！注：其中全部图片均为手绘，不喜勿喷。
斜率优化---感谢此文让我彻底弄懂斜率优化
热门推荐
mrcrack的博客
03-06 1万+
斜率优化---感谢此文让我彻底弄懂斜率优化 若深究斜率优化,有重重疑惑,建议学习此文. 阅遍网上大量 斜率优化 文章,唯独此文,将本人疑惑一一解清,作为之前几乎不转载的作者,今日,郑重将此文转载,原文来自https://www.cnblogs.com/terribleterrible/p/9669614.html有删改。 在https://www.luogu.org/problemnew/s...
动态规划之斜率优化
xiang_yu_pai的博客
02-21 346
其实斜率优化也是用的单调队列来的。 一般的例如： dp[ i ]=min( dp[ j ] + f（j）) ( i-k< j < i ) 我们可以用单调队列来优化，因为变量只有j。 而如dp[ i ]=min(dp[ j ]+ f ( i ) * f ( j ) )的话,i和j在一起的了，就不能单调队列优化了。 先上一道斜率优化模板题https://www.luogu.com.cn/...
动态规划（DP）优化之斜率优化讲解
PomeCat的博客
06-01 5419
“DP的斜率优化——对不必要的状态量进行抛弃，对不优的状态量进行搁置，使得在常数时间内找到最优解成为可能。斜率优化依靠的是数形结合的思想，通过将每个阶段和状态的答案反映在坐标系上寻找解答的单调性，来在一个单调的答案（下标）队列中O（1）得到最优解。”在呈交给教练的总结里，我这样写到。确实，集训了几天，对斜率优化感受颇多，就此写一下自己的理解。斜率优化的思想在2004年国家集训队员周源大神撰写的《浅谈
斜率优化v2022.pptx
01-12
斜率优化是指通过优化斜率的计算方法来优化问题的解决过程。在斜率优化v2022.pptx中，展示了一个斜率优化DP例子，即最大平均值问题。题目要求读入一列正整数以及一个整数F，然后求一段长度大于等于F且平均值最大的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值