第三节课：

最新推荐文章于 2024-11-16 10:02:08 发布
最新推荐文章于 2024-11-16 10:02:08 发布
阅读量306 收藏
点赞数
分类专栏： 左神课程笔记—高级提升篇 文章标签： 算法 动态规划 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45552815/article/details/126819365
版权
本文探讨了利用动态规划和递归策略解决计算机科学中的复杂问题，如蛇的最大长度、数学表达式的计算以及字符串的最长公共子串和子序列。通过代码实现和优化，展示了如何利用记忆化搜索和空间压缩来提高算法效率。文章还介绍了如何处理负数和优先级结合的问题，以及如何找到最长公共子串和子序列的解决方案。
摘要由CSDN通过智能技术生成

文章目录

题目一

在这里插入图片描述
蛇从最左侧某个点出发，来到(i,j)位置，获得的最大长度；分是否使用能力获得的最大长度；如果结果是负数，表示没有该答案；蛇有可能在任意位置获得最大长度；遍历所有位置，调用递归函数，取每个位置的最大值；basecase是蛇在最左列的情况；一般情况，三种情况：从左上、从左下、从左侧；
记忆化搜索对于没有枚举的情况，与最后的动态规划时间复杂度一样，只是空间复杂度可以再优化；如果存在枚举，从记忆化搜索到严格表结构就有一样了，可以优化枚举
代码实现：

class Info {
public:
	int yes;
	int no;
	Info(int yes, int no) {
		this->yes = yes;
		this->no = no;
	}
};

//从最左侧来到(i,j)位置，获得最大长度，存在两种情况：用/不用能力
//结果为0，表示没有答案
Info* process(vector<vector<int>>& arr, int i, int j) {
	if (j == 0) {
		return new Info(-arr[i][0], arr[i][0]);
	}

	//之前的路径和（获得的最大长度）
	int preno = -1;
	int preyes = -1;
	if (i > 0) {//有左上
		//里面的if可以省略，直接取最大值，因为-1是最大的负数
		Info* leftup = process(arr, i - 1, j - 1);
		if (leftup->no >= 0) {
			preno = leftup->no;
		}
		if (leftup->yes >= 0) {
			preyes = leftup->yes;
		}
	}
	Info* left = process(arr, i, j - 1);
	//if可以省略，直接取最大值，因为-1是最大的负数
	if (left->no >= 0) {
		preno = max(preno, left->no);
	}
	if (left->yes >= 0) {
		preyes = max(preyes, left->yes);
	}
	if (i < arr.size() - 1) {
		//里面的if可以省略，直接取最大值，因为-1是最大的负数
		Info* leftdown = process(arr, i + 1, j - 1);
		if (leftdown->no >= 0) {
			preno = max(preno, leftdown->no);
		}
		if (leftdown->yes >= 0) {
			preyes = max(preyes, leftdown->yes);
		}
	}


	//生成当前位置的信息
	int no = -1;
	int yes = -1;

	if (preno >= 0) {
		no = preno + arr[i][j];
		yes = preno - arr[i][j];
	}
	if (preyes >= 0) {
		yes = max(yes, preyes + arr[i][j]);
	}

	return new Info(yes, no);
}


//去除多余的判断
Info* process2(vector<vector<int>>& arr, int i, int j) {
	if (j == 0) {
		return new Info(-arr[i][0], arr[i][0]);
	}

	//之前的路径和（获得的最大长度）
	int preno = -1;
	int preyes = -1;
	if (i > 0) {//有左上
		Info* leftup = process(arr, i - 1, j - 1);
		preno = max(preno, leftup->no);
		preyes = max(preyes, leftup->yes);
	}

	Info* left = process(arr, i, j - 1);
	preno = max(preno, left->no);
	preyes = max(preyes, left->yes);

	if (i < arr.size() - 1) {
		Info* leftdown = process(arr, i + 1, j - 1);
		preno = max(preno, leftdown->no);
		preyes = max(preyes, leftdown->yes);
	}


	//生成当前位置的信息
	int no = -1;
	int yes = -1;

	if (preno >= 0) {
		no = preno + arr[i][j];
		yes = preno - arr[i][j];
	}
	if (preyes >= 0) {
		yes = max(yes, preyes + arr[i][j]);
	}

	return new Info(yes, no);
}

//改记忆化搜索的dp
Info* process3(vector<vector<int>>& arr, int i, int j,vector<vector<Info*>>&dp) {
	if (dp[i][j] != nullptr) {
		return dp[i][j];
	}
	if (j == 0) {
		dp[i][0] = new Info(-arr[i][0], arr[i][0]);
		return dp[i][0];
	}

	//之前的路径和（获得的最大长度）
	int preno = -1;
	int preyes = -1;
	if (i > 0) {//有左上
		Info* leftup = process(arr, i - 1, j - 1);
		preno = max(preno, leftup->no);
		preyes = max(preyes, leftup->yes);
	}

	Info* left = process(arr, i, j - 1);
	preno = max(preno, left->no);
	preyes = max(preyes, left->yes);

	if (i < arr.size() - 1) {
		Info* leftdown = process(arr, i + 1, j - 1);
		preno = max(preno, leftdown->no);
		preyes = max(preyes, leftdown->yes);
	}


	//生成当前位置的信息
	int no = -1;
	int yes = -1;

	if (preno >= 0) {
		no = preno + arr[i][j];
		yes = preno - arr[i][j];
	}
	if (preyes >= 0) {
		yes = max(yes, preyes + arr[i][j]);
	}

	dp[i][j] = new Info(yes, no);
	return dp[i][j];
}


//每个位置都有可能是最终的结果
int snack(vector<vector<int>>& arr) {
	if (arr.size() == 0 || arr[0].size() == 0) {
		return 0;
	}
	int res = 0;
	vector<vector<Info*>>dp(arr.size(), vector<Info*>(arr[0].size(), nullptr));
	for (int i = 0; i < arr.size(); i++) {
		for (int j = 0; j < arr[0].size(); j++) {
			//Info* cur = process(arr, i, j);
			//3Info* cur = process2(arr, i, j);
			Info* cur = process3(arr, i, j, dp);
			res = max(res, max(cur->no, cur->yes));
		}
	}
	return res;
}

题目二

在这里插入图片描述
介绍一种类似这种优先级（括号）结合的递归策略：f(str,i)返回两个值：1) 从i位置开始，遇到‘（’或者终止就停，返回i到停止的位置算的结果；2) 返回停止的位置
首先看公式中不存在括号时，这么计算：用栈。分遇到的是数字和运算符两种情况。遇到数字将数字和它后面的运算符压入栈中，但是如果栈顶元素是*或/，需要先将当前数字和栈中第一个数字用栈顶的运算符算出一个结果，将该结果和当前数的运算符压入栈中；最后单独算栈里剩余的元素。

在这里插入图片描述
如果公式中存在括号：按照上述不存在括号的方式计算，当遇到‘（’时，递归调用‘（’的下一位置，从放回结果的下一位置开始继续计算
在这里插入图片描述
优先级结合的问题，用这种递归方法包打一切。
代码实现：

void addNum(int num, char c,stack<string>& sk) {
	if (!sk.empty()) {
		if (sk.top() == "+" || sk.top() == "-") {
			sk.push(to_string(num));
		}
		else {
			if (sk.top() == "*") {//  *
				sk.pop();
				int top = stoi(sk.top());
				sk.pop();
				sk.push(to_string(num * top));
			}
			else {//  /
				sk.pop();
				int top = stoi(sk.top());
				sk.pop();
				sk.push(to_string(top / num));
			}
		}
	}
	else {
		sk.push(to_string(num));
	}
	if (c != '\0') {
		string s = "";
		s += c;
		sk.push(s);
	}
}

int getNum(stack<string>& sk) {
	if (sk.empty()) {
		return 0;
	}
	int res = stoi(sk.top());
	sk.pop();
	while (!sk.empty()) {
		if (sk.top() == "+") {
			sk.pop();
			res += stoi(sk.top());
		}
		else {
			sk.pop();
			res = stoi(sk.top()) - res;
		}
		sk.pop();
	}
	return res;
}

vector<int> f(string& s, int i) {
	stack<string>sk;
	int num = 0;
	vector<int>bra(2);//‘（’左边计算的结果和遇到‘）’或者终止位置
	while (i < s.length() && s[i] != ')') {
		if (s[i] >= '0' && s[i] <= '9') {//i位置为数
			num = num * 10 + s[i] - '0';
			i++;
		}
		else if (s[i] != '(') {//i位置为运算符
			addNum(num, s[i], sk);
			i++;
			num = 0;
		}
		else {//i位置为‘（’
			bra = f(s, i + 1);
			num = bra[0];
			i = bra[1] + 1;
		}
	}
	addNum(num, '\0', sk);
	return vector<int>({ getNum(sk),i });
}

int calculate(string& s) {
	return f(s, 0)[0];
}


//解决负数的问题
//分两种情况：
//1.负数作为开头：负号前加一个0，并用括号，将负号后的数连同新加的0用括号括起来
//2.负号不在开头，那么一定再‘（’后，直接再负号前加0即可
void p(string& s) {
	if (s[0] == '-') {
		s.insert(0, "0");
		if (s[1] != '(') {
			s.insert(0, "(");
			int i = 3;
			while (i < s.length() && s[i] >= '0' && s[i] <= '9') {
				i++;
			}
			s.insert(i, ")");
		}
	}
	for (int i = 1; i < s.length(); i++) {
		if (s[i] == '('&&s[i+1]=='-') {
			s.insert(i + 1, "0");
		}
	}
}

题目三

在这里插入图片描述
左神的方法：dp[i][j]表示最长公共子串必须以s1[i]和s2[j]结尾的长度，很明显，如果s1[i]!=s2[j]，则dp[i][j]=0；否则dp[i][j]=dp[i-1][j-1]+1，因此dp[i][j]之和它的左上角有关，可以使用有限几个变量进行空间压缩。
在这里插入图片描述
在这里插入图片描述
从右上角开始求解：

在这里插入图片描述
代码实现：

//dp[i][j]表示最长公共子串必须以s1[i]和s2[j]结尾的长度
string maxLenSubStr(string& s1, string& s2) {
	if (s1.length() == 0 || s2.length() == 0) {
		return "";
	}
	int maxLen = 0;
	int ed = -1;
	int row = 0;
	int col = s2.length() - 1;
	
	while (row < s1.length()) {
		int i = row;
		int j = col;
		int cur = 0;
		while (i < s1.length() && j < s2.length()) {
			if (s1[i] == s2[j]) {
				cur++;
			}
			else {
				cur = 0;
			}
			if (cur > maxLen) {
				maxLen = cur;
				ed = i;
			}
			i++;
			j++;
		}
		if (col == 0) {
			row++;
		}
		else {
			col--;
		}
	}

	return ed == -1 ? "" : s1.substr(ed + 1 - maxLen, maxLen);//substr(pos,n)
}

题目四

在这里插入图片描述

本题求的是最长公共子序列的长度。
dp[i][j]表示s1[0…i]和s2[0…j]的最长公共子序列的长度。上一题最长公共子串必须以s1[i]和s2[j]结尾，本题则不一定。四种可能：1) 最长公共子序列中不包含s1[i]，包含s2[j]–>dp[i][j]=dp[i-1][j]；2) 最长公共子序列中包含s1[i]，不包含s2[j]–>dp[i][j]=dp[i][j-1]；3) 最长公共子序列中不包含s1[i]，也不包含s2[j]–>dp[i][j]=dp[i-1][j-1]；4) 最长公共子序列中包含s1[i]，也包含s2[j]–>dp[i][j]=dp[i-1][j-1]。四种情况求最大值即为dp[i][j]

在这里插入图片描述
代码实现：

//dp[i][j]：s1[0..i]和s2[0..j]最长公共子序列的长度
int maxLenSub(string& s1, string& s2) {
	vector<vector<int>>dp(s1.length(), vector<int>(s2.length()));
	dp[0][0] = s1[0] == s2[0] ? 1 : 0;
	for (int i = 1; i < s1.length(); i++) {
		dp[i][0] = (dp[i - 1][0] == 1 || s1[i] == s2[0] ? 1 : 0);
	}
	for (int j = 1; j < s2.length(); j++) {
		dp[0][j] = (dp[0][j - 1] == 1 || s2[j] == s1[0] ? 1 : 0);
	}
	for (int i = 1; i < s1.length(); i++) {
		for (int j = 1; j < s2.length(); j++) {
			dp[i][j] = dp[i - 1][j - 1] + (s1[i] == s2[j] ? 1 : 0);
			dp[i][j] = max(dp[i][j], dp[i - 1][j]);
			dp[i][j] = max(dp[i][j], dp[i][j - 1]);
		}
	}
	return dp[s1.length() - 1][s2.length() - 1];
}
//可以进行空间压缩
int maxLenSub2(string& s1, string& s2) {
	vector<vector<int>>dp(2, vector<int>(s2.length()));
	dp[0][0] = s1[0] == s2[0] ? 1 : 0;

	for (int j = 1; j < s2.length(); j++) {
		dp[0][j] = (dp[0][j - 1] == 1 || s2[j] == s1[0] ? 1 : 0);
	}
	for (int i = 1; i < s1.length(); i++) {
		dp[i % 2][0] = s1[i] == s2[0] ? 1 : 0;
		for (int j = 1; j < s2.length(); j++) {
			dp[i % 2][j] = dp[(i - 1) % 2][j - 1] + (s1[i] == s2[j] ? 1 : 0);
			dp[i % 2][j] = max(dp[i % 2][j], dp[(i - 1) % 2][j]);
			dp[i % 2][j] = max(dp[i % 2][j], dp[i % 2][j - 1]);
		}
	}
	return dp[(s1.length() - 1) % 2][s2.length() - 1];
}
Leetcode快速入门之第三节课: 分治算法
herosunly的博客
06-19 1万+
如果大家认真学习了上节课的内容，自行编码完成了课程中的题目，那么恭喜你已经迈出了坚实的一步。如果没有自行编码完成作业，只是看了几遍文章，请一定要自行练习，否则收效甚微。话不多说，咱们继续今天的课程。 拆分+组合是解决问题常用的思维方式。上节课的双指针+区间法主要是通过循环体现了拆分和组合。其中循环中的每一轮体现了拆分后的每个子问题，而组合已经被包含在循环中了。那么是否有不通过循环来拆分问题的算法呢？答案就是咱们今天要学习的分治算法。那么分治算法究竟是
Leetcode快速入门之第四节课: 区间法边界值分析
herosunly的博客
06-25 1万+
1. 区间法核心思想介绍 最近有好几个付费读者表示，课程内容基本上学会了，但是区间边界值如何正确设置成为了一个难题。为了帮助同学们在学习初期早点避开同样的大坑，所以特意加上了这节内容。如果同学们有其他问题，也欢迎在评论区留言。 咱们先来回忆一下区间法。在开始之前，首先应当确定问题可以通过区间法来解决。具体来说，要把原有数据划分成若干个区间。每个区间是相互独立的，而区间内的数据满足一定的共性。 使用区间法解决问题的步骤为：一、确立正确区间，二、设置好区间的初始值，三、确定循环执行的条件(或者终止条件)，四
第三节课
BlueWasSky的博客
10-31 596
简单的操作系统：[rl]display ip interface brief //查看设备接口摘要信息 Physical:表示接口能否识别电流 down:不能 protocol：表示接口能否传递数据 up:能 接口配置地址： [rl]interface GigabitEthernet 0/0/0 ...
左神课程笔记——第三节课：详解桶排序以及排序内容大总结
qq_45552815的博客
08-15 400
b站左神算法课程笔记
第一节计算机课开场白,第一节课有趣的开场白
weixin_29327977的博客
07-08 1159
我是一名新老师，请问第一堂课的开场白怎么讲我：上课学生：起立我：同学们好学生：老师好我：请坐我：很高兴见到大家。我是你们的英语(或其他的学科)老师我叫*老师有一个小小的请求。大家一起喊一遍老师的名字学生：*。我：嗯很好大家知不知道老师为什么叫大家喊老师的名字呢学生：不知道我：大家都是初中二年级(或其他年级)的学生了，应该知道直接叫老师的名字是不礼貌的。但是，在什么情况下，可以直呼对方的名字呢学生：...
第一节计算机课学什么,第一节课计算机语言入门
weixin_35591093的博客
07-08 894
《第一节课计算机语言入门》由会员分享，可在线阅读，更多相关《第一节课计算机语言入门(19页珍藏版)》请在人人文库网上搜索。1、第一课,基,础,知,识,计算机是一种能够按照事先编写存储的程序，自动、高速,地进行数值计算和各种信息处理的现代化智能电子设备,程序是指令的集合，计算机程序是用来告诉计算机如何一,步一步执行任务,指令是指示计算机执行某种操作的命令，它由一串二进制,数码组成。计算机能识别的代码...
第一节计算机课开场白,老师第一节课的开场白
weixin_33427476的博客
07-08 1063
第一堂课是老师在学生面前建立第一印象的关键时刻，对于老师建立威性的意义不言而喻。一般说来，如果老师能在最开始的4小时教学中让学生信服，学生会在以后的整个教学过程中对老师产生很强的信赖，几乎会言听计从，这对于教学的顺利进行将非常有帮助。在第一堂课上，老师必须向学生明确：1、这个阶段的学习目的是什么。每个阶段中的教学任务和教学重点是不一样的，一个个阶段的合理连接和衔接使得学生步步为营，不断提高。基础阶...
Leetcode快速入门之第八节课: 掌握链表数据移动的小诀窍
热门推荐
herosunly的博客
10-26 1万+
文章目录 1. 对角线法则 1.1 左对角线法则(第一个) 1.2 右对角线法则 1.3 左对角线法则(第二个) 2. 更多题目 2.1 206题反转链表 2.2 92题反转链表IIII 2.3 25题K 个一组翻转链表 1. 对角线法则   什么是对角线法则呢？以交换两个整型变量为例，代码如下所示： void swap(int &a, int &b) { int t = a; a = b; b = t; }   想必大家对上述代码早已烂熟于心。但如果静下心来观察下，就会发现两个对角线法则。为什么要
Leetcode快速入门之第五节课: 使用多指针+区间法解决链表问题
herosunly的博客
06-30 1万+
文章目录1. 问题引入2. 链表基础概念3. Leetcode实战之删除元素3.1 Leetcode 83题：删除链表中的重复元素3.2 Leetcode 82题：删除链表中的重复元素II 1. 问题引入   之前在第二节课我们讲解了使用双指针解决数组问题。自己一直比较推崇的是学习方法之一是举一反三，那不禁就有人要问，那能否用来解决其他问题呢？比如与数组并驾齐驱的链表呢。答案是同样好用！   那么问题来了，如何使用双指针(多指针)来攻克Leetcode中的链表题目呢？ 2. 链表基础概念   在链表中，我
Leetcode快速入门之第二节课: 使用双指针+区间法解决数组问题
herosunly的博客
06-15 1万+
文章目录1. 问题引入2. 问题分析3. 双指针+区间法 引入 1. 问题引入   在学习Leetcode中，最忌讳的学习方法是：东一榔头西一棒槌。具体来说，就是今天做一道数组的题，明天做一道链表的题，后天再做一道二叉树的题目。如此一来，就把学习变成了纯粹了题海战术。而最有效的方法是通过归纳和分类，逐一攻克每个子类别。这是因为，在逐一攻克每个子类别的过程中，必然会深入思考一类题目的共同点，所以就更容易学到其中的精髓之处。   今天咱们要学习的内容使用双指针+区间法解决数组问题，在开始之前，先把题目链接列举一
（方法）03第三节课：绩效的目标.ppt
09-14
（方法）03第三节课：绩效的目标.ppt
（方法）13第十三节课：绩效结果运用（下）.ppt
09-14
（方法）13第十三节课：绩效结果运用（下）.ppt
公开课第十三节：性能测试方案设计.mp4
08-29
公开课第十三节：性能测试方案设计.mp4 公开课第十四节：python编程核心思想.mp4 公开课第十五节：python核心编程思想2.mp4 公开课第十六节：Python 编程六剑客&编程面试题实战.mp4 公开课第十七节：python 文件操作...
公开课第三节：浅谈测试的职业发展与破局.mp4
08-29
公开课第三节：浅谈测试的职业发展与破局.mp4 公开课第四节：软件测试人员面试的技巧和互联网大厂真题分享.mp4 公开课第五节：测试管理的那些事儿.mp4 公开课第六节：自动化测试的设计模式.mp4 公开课第七节（1）：...
公开课第一节：功能测试框架+实战分析.avi
08-29
公开课第三节：浅谈测试的职业发展与破局.mp4 公开课第四节：软件测试人员面试的技巧和互联网大厂真题分享.mp4 公开课第五节：测试管理的那些事儿.mp4 公开课第六节：自动化测试的设计模式.mp4 公开课第七节（1）：...
DAY63||拓扑排序精讲 |dijkstra（朴素版）精讲
2301_79865280的博客
11-14 704
某个大型软件项目的构建系统拥有 N 个文件，文件编号从 0 到 N - 1，在这些文件中，某些文件依赖于其他文件的内容，这意味着如果文件 A 依赖于文件 B，则必须在处理文件 A 之前处理文件 B （0 <= A, B <= N - 1）。请编写一个算法，用于确定文件处理的顺序。第一行输入两个正整数 N, M。表示 N 个文件之间拥有 M 条依赖关系。后续 M 行，每行两个正整数 S 和 T，表示 T 文件依赖于 S 文件。输出共一行，如果能处理成功，则输出文件顺序，用空格隔开。
C++入门基础知识150—【关于C++ 输入/输出运算符重载】
最新发布
zhaoylzy的博客
11-16 1046
关于【C++输入/输出运算符重载】 一、什么是输入/输出运算符 二、什么是输入输出运算符重载 三、输入输出运算符重载格式 四、输入输出运算符重载参数之间的区别 五、重载提取运算符 >> 和插入运算符
java计算文本相似度算法总结
sunsiny
11-14 925
计算两个字符串之间的最小单字符编辑（插入、删除、替换）次数。这是一种衡量字符串差异性的方法，常用于拼写检查和模糊匹配。：一种基于 Jaro 相似度的改进算法，特别适用于拼写检查和模糊匹配。：计算两个字符串之间的最长公共子序列长度，常用于文本差异比较。：通过计算两个字符串的 n-gram 向量的余弦夹角来评估它们的相似度。：基于子串的字符串相似度计算方法，计算它们共有的Q-gram（长度为Q的连续子串）的数量，然后将这个数量除以两个字符串中Q-gram数量较少的那个，得到相似度的比例。
1163：阿克曼(Ackmann)函数
呆萌很的博客
11-12 280
1163：阿克曼(Ackmann)函数
互联网产品设计与运营：第二课解析
"互联网产品设计与运营第2节课.ppt" 在互联网产品设计与运营的世界里，第二节课深入探讨了设计流程、岗位职责以及如何构建有效的职业规划。这堂课强调了理解并掌握工作流程的重要性，因为它是确保产品成功的关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值