《面试算法 LeetCode 刷题班》——10.复杂数据结构

最新推荐文章于 2024-05-27 23:15:28 发布
最新推荐文章于 2024-05-27 23:15:28 发布
阅读量213 收藏
点赞数
分类专栏： 高级程序设计 文章标签： 算法 leetcode
原文链接：https://blog.csdn.net/Chris_zhangrx/article/details/84575354
版权

本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！

9. 动态规划

文章目录

## LeetCode 70 爬楼梯 (E)

问题描述：

在爬楼梯时，每次可向上走 1 阶台阶或 2 阶台阶，问有 n 阶楼梯有多少种上楼方式。

问题分析：
由于每次最多爬 2 阶， 楼梯的第 i 阶，只可能从楼梯第 i-1 阶与第 i-2 阶到达。所有到达第 i 阶有多少种爬法，只与第 i-1、i-2 阶的爬法数量直接相关。

算法思路：

  1. 设置递推数组 dp[0…n]，dp[i]代表到达第 i 阶，有多少种走法，初始化数组为 0
  2. 设置到达第 1 阶台阶，有1种走法，到达第2阶台阶，有2种走法
  3. 利用i循环递推从第3阶至第n阶结果：
第 i 阶的爬法数量 = 第i-1阶的爬法数量 + 第 i-2 的爬法数量

解决代码：

class Solution {
public:
	int climbStairs(int n) {
		vector<int> dp(n + 3, 0);
		dp[1] = 1;
		dp[2] = 2;
		for (int i = 3; i <= n; i++)
		{
			dp[i] = dp[i-1] + dp[i-2];
		}
		return dp[n];
	}
};

动态规划原理：

1.确认原问题与子问题：

原问题为求 n 阶台阶所有走法的数量，子问题是求1阶台阶、2阶台阶、…、n-1阶台阶的走法。

2.确认状态

上题的动态规划状态单一，第i个状态即为i阶台阶的所有走法数量。

3.确认边界状态的值

边界状态为1阶台阶与2阶台阶的走法，即dp[1]=1，dp[2]=2

4.确认状态转移方程

将求第i个状态的值转移为求第i-1个状态值与第i-2个状态的值，动态规划转移方程， dp[i] = dp[i-1] + dp[i-2]；（i>=3）

LeetCode 198 打家劫舍 （E）

问题描述：

在一条直线上，有n个房屋，每个房屋中有数量不等的财宝，有一个盗贼希望从房屋中盗取财宝，由于房屋中有报警器，如果同时从相邻的两个房屋中盗取财报就会触发报警器。问在不触发报警器的前提下，最多可获取多少财宝。

Example :

Input: [2,7,9,3,1]
Output: 12
Explanation: Rob house 1 (money = 2), rob house 3 (money = 9) and rob house 5 (money = 1).
 			 Total amount you can rob = 2 + 9 + 1 = 12.

问题分析：

由于同时从相邻的两个房屋中盗窃就会触发报警器，故：

a. 若选择第 i 个房间盗取财报，就一定不能选择第 i-1 个房间盗取财报

b. 若不选择第 i-1 个房间盗取财报，则相当于只考虑前 i-1 个房间盗取财宝

算法思路：

1.确认原问题与子问题

  原问题为求n个房间的最优解，子问题为求前1个房间，前2个房间…前n个房间的最优解

2.确认状态

  第 i 个状态即为前 i 个房间的最优解

3.确认边界状态的值

  前1个房间的最优解，第1个房间的财宝

  前2个房间的最优解，第1、2个房间中较大的财宝

4.确认状态转移方程

  a.选择第 i 个房间 ： 第 i 个房间 + 前 i-2 个房间的最优解

  b.不选择第 i 个房间 ： 前 i-1 个房间的最优解

  动态规划转移方程：

dp[i] = max(dp[i-1] , dp[i-2] + nums[i]);(i>=3)

代码实现：

class Solution {
public:
	int rob(vector<int>& nums) {
		if (nums.size() == 0)
		{
			return 0;
		}
		if (nums.size() == 1)
		{
			return nums[0];
		}

		vector<int> dp(nums.size(), 0);
		dp[0] = nums[0];
		dp[1] = max(nums[0], nums[1]);
		for (int i = 2; i < nums.size(); i++)
		{
			dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
		}
		return dp[nums.size()-1];
	}
};

LeetCode 53 最大子段和（E）

问题描述：

给定一个数组，求这个数组的连续子数组中，最大的那一段的和

Example:

Input: [-2,1,-3,4,-1,2,1,-5,4],
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

算法思路：

将求 n 个数的数组的最大子段和，转换为分别求出以 第1个、第2个、…、第i个、…、第n个数字结尾的最大字段和，再找出这n个结果中最大的，即为结果。

可以得到如下关系：

若dp[i-1]>0：

 dp[i]=dp[i-1]+nums[i];

否则：

 dp[i]=nums[i];

代码实现：

class Solution {
public:
	int maxSubArray(vector<int>& nums) {
		vector<int> dp(nums.size(), 0);
		dp[0] = nums[0];
		int max_res = dp[0];
		for (int i = 1; i < nums.size(); i++)
		{
			dp[i] = max(dp[i - 1] + nums[i], nums[i]);
			if (dp[i]>max_res)
			{
				max_res = dp[i];
			}
		}
		return max_res;
	}
};

LeetCode 322 找零钱（M）

问题描述：

已知不同面值的钞票，求如何用最少数量的钞票组成某个金额，求可以使用的最少钞票数量。如果任意数量的已知面值钞票都无法组成该金额，则返回 -1。

Example 1:

Input: coins = [1, 2, 5], amount = 11
Output: 3 
Explanation: 11 = 5 + 5 + 1

Example 2:

Input: coins = [2], amount = 3
Output: -1

算法思路：

以 coins = [1,2,5,7,10]； 金额： 14 为例：
dp[i]，代表金额 i 的最优解，数组中存储金额1至金额n的最优解。
在计算 dp[i] 时，dp[0] … dp[i-1] 都是已知的：
  而金额 i 可由：
   金额i-1 与 金额1组合
   金额i-2 与 金额2组合
   金额i-5 与 金额5组合
   金额i-7 与 金额7组合
   金额i-10 与 金额10组合
即状态 i 可由状态 i-1、i-2、i-5、i-7、i-10，5 个状态所转移到， 故，

dp[i] = min(dp[i-1],dp[i-2],dp[i-5],dp[i-7],dp[i-10]) + 1;

代码实现：

class Solution {
public:
	int coinChange(vector<int>& coins, int amount) {
		vector<int> dp;
		for (int i = 0; i <= amount; i++)
		{
			dp.push_back(-1);
		}
		dp[0] = 0;
		for (int i = 1; i <= amount; i++)
		{
			for (int j = 0; j < coins.size(); j++) {
				if (i-coins[j]>=0 && dp[i-coins[j]] != -1)
				{
					if (dp[i] == -1 || dp[i] > dp[i-coins[j]]+1)
					{
						dp[i] = dp[i - coins[j]] + 1;
					}
				}
			}
		}
		return dp[amount];
	}
};

LeetCode 120 三角形（M）

问题描述：

给定一个二维数组，其保存了一个数字三角形，求从数字三角形顶端到底端各数字和最小的路径之和，每次可以向下走相邻的两个位置。

Example:

[
 	 [2],
	[3,4],
   [6,5,7],
  [4,1,8,3]
]
The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).

问题分析：

算法思路：

1.设置一个二维数组，最优值三角形dp[][]，并初始化数组元素为0。 dp[i][j]代表了从底向上递推时，走到三角形第 i 行第 j 列的最优解

2.从三角形的底面向三角形上方进行动态规划
  a.动态规划边界条件：底面上的最优值即为数字三角形的最后一层。
  b.利用i循环，从倒数第二层推至第一层：
    第i行，第j列的最优解 dp[i][j]，可到达（i,j）的两个位置的最优解 dp[i+1][j]、dp[i+1][j+1] ：
            dp[i][j] = min(dp[i+1][j],dp[i+1][j+1]) + triangle[i][j]

3.返回dp[0][0]

代码实现：

class Solution {
public:
	int minimumTotal(vector<vector<int>>& triangle) {
		if (triangle.size() == 0)
		{
			return 0;
		}
		vector<vector<int>> dp;
		for (int i = 0; i < triangle.size(); i++)
		{
			dp.push_back(vector<int>());
			for (int j = 0; j < triangle[i].size(); j++)
			{
				dp[i].push_back(0);
			}
		}

		for (int i = 0; i < dp.size(); i++)
		{
			dp[dp.size() - 1][i] = triangle[dp.size() - 1][i];
		}

		for (int i = dp.size()-2; i >= 0; i--)
		{
			for (int j = 0; j < dp[i].size(); j++)
			{
				dp[i][j] = min(dp[i + 1][j + 1], dp[i+1][j]) + triangle[i][j];
			}
		}
		return dp[0][0];
	}
};

LeetCode 300 最长上升子序列

问题描述：

已知一个未排序的数组，求这个数组最长上升子序列的长度。

Example:

Input: [10,9,2,5,3,7,101,18]
Output: 4 
Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.

代码实现：

class Solution {
public:
	int lengthOfLIS(vector<int>& nums) {
		if (nums.size() == 0)
		{
			return 0;
		}
		vector<int> dp(nums.size(),0);
		dp[0] = 1;
		int LIS = 1;
		for (int i = 1; i < dp.size(); i++)
		{
			dp[i] = 1;
			for (int j = 0; j < i; j++)
			{
				if (nums[i] > nums[j] && dp[i] < dp[j] + 1) {
					dp[i] = dp[j] + 1;
				}
			}
			if (LIS < dp[i]) {
				LIS = dp[i];
			}
		}
		return LIS;
	}
};

用栈实现：

class Solution {
public:
	int lengthOfLIS(vector<int>& nums) {
		if (nums.size() == 0)
		{
			return 0;
		}
		vector<int> stack;
		stack.push_back(nums[0]);
		for (int i = 1; i < nums.size(); i++)
		{
			if (nums[i] > stack.back()) {
				stack.push_back(nums[i]);
			}
			else
			{
				for (int j = 0; j < stack.size(); j++)
				{
					if (stack[j] >=nums[i]) {  //若栈中元素大于 nums[i]，替换，并跳出循环
						stack[j] = nums[i];
						break;
					}
				}
			}
		}
		return stack.size();
	}
};

LeetCode 64 最小路径和（M）

问题描述：

已知一个二维数组，其中存储了非负整数，找到从左上角到右下角的一条路径，使得路径上的和最小。（移动过程中只能向下或向右）

问题分析：

思考与 LeetCode 120 相似之处，dp[i][j] 与 dp[i-1][j]、dp[i][j-1]、grid[i][j]之间的关系

代码实现：

class Solution {
public:
	int minPathSum(vector<vector<int>>& grid) {
		if (grid.size() == 0)
		{
			return 0;
		}
		int row = grid.size();
		int column = grid[0].size();
		vector<vector<int>> dp(row,vector<int>(column,0));
		dp[0][0] = grid[0][0];
		for (int i = 1; i < column; i++)
		{
			dp[0][i] = dp[0][i-1] + grid[0][i];
		} // 处理边界情况 1

		for (int i = 1; i < row; i++) {
			dp[i][0] = dp[i-1][0] + grid[i][0]; // 处理边界情况 2
			for (int j = 1; j < column; j++) {
				dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
			}
		}
		return dp[row-1][column-1];
	}
};

LeetCode 174 地牢游戏（H）

问题描述：

已知一个二维数组，左上角代表骑士的位置，右下角代表公主的位置，二维数组存储整数，正数代表可以给骑士增加生命值，负数会减少骑士的生命值，问骑士初始时至少是有多少生命值，才可以保证骑士在行走的过程中至少保持生命值为1.（骑士只能向下或向右行走）

问题分析：

直接思考动态规划，我们应该从左上向右下递推，还是从右下向左上递推? 若用一个二伟数组代表每个格子的状态，dp[i][j] 具体代表什么？

若我们直接从左上角往右下角推，按照 LeetCode 64 的思路，

代码实现：

class Solution {
public:
	int calculateMinimumHP(vector<vector<int>>& dungeon) {
		if (dungeon.size() == 0)
		{
			return 0;
		}
		vector<vector<int> > dp(dungeon.size(), vector<int>(dungeon[0].size(), 0));
		int row = dungeon.size();
		int column = dungeon[0].size();
		dp[row - 1][column - 1] = max(1, 1 - dungeon[row - 1][column - 1]);
		for (int i = column - 2; i >= 0; i--) {
			dp[row - 1][i] = max(1, dp[row - 1][i + 1] - dungeon[row - 1][i]);
		}
		for (int i = row - 2; i >= 0; i--)
		{
			dp[i][column - 1] = max(1, dp[i + 1][column - 1] - dungeon[i][column - 1]);
		}
		for (int i = row-2; i >= 0; i--)
		{
			for (int j = column - 2; j >= 0; j--)
			{
				int dp_min = min(dp[i][j+1],dp[i+1][j]);
				dp[i][j] = max(1, dp_min-dungeon[i][j]);
			}
		}
		return dp[0][0];
	}
};
Dan Boneh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode刷题笔记——19. 删除链表的倒数第N个节点
12-21
难度：中等 一、题目描述： 二、解题分析： 1、解析   这道题本质上和《剑指Offer》刷题笔记——面试题22. 链表中倒数第k个节点是一样的。都可以用单指针两次遍历或者双指针一次遍历解决。 2、代码实现 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def removeNthFromEnd(self, head: ListNode
LeetCode刷题笔记——994. 腐烂的橘子
12-21
难度：简单 一、题目描述： 二、解题分析： 1、解析   观察到对于所有的腐烂橘子，其实它们在广度优先搜索上是等价于同一层的节点的。   假设这些腐烂橘子刚开始是新鲜的，而有一个腐烂橘子(我们令其为超级源点)会在下一秒把这些橘子都变腐烂，而这个腐烂橘子刚开始在的时间是 -1 ，那么按照广度优先搜索的算法，下一分钟也就是第 0分钟的时候，这个腐烂橘子会把它们都变成腐烂橘子，然后继续向外拓展，所以其实这些腐烂橘子是同一层的节点。那么在广度优先搜索的时候，我们将这些腐烂橘子都放进队列里进行广度优先搜索即可，最后每个新鲜橘子被腐烂的最短时间其实是以这个超级源点的腐烂橘子为起点的广度优先搜索得到的结果
LeetCode全部题目和详细解答 数据结构算法 程序员面试求职必备
02-11
LeetCode全部题目和详细解答 数据结构算法 程序员面试求职必备
leetcode刷题班题库
02-15
一共10节题库，包含大量经典题，而且有很详细的求解步骤
《面试算法 LeetCode 刷题班》——2. 栈、队列、堆
qq_44744450的博客
07-17 141
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 2. 栈、队列、堆 文章目录 2. 栈、队列、堆LeetCode 225 使用队列（Q）实现栈（S） (E)LeetCode 232 用栈实现队列（E）LeetCode 155 Min Stack（E）Poj 1363 合法的出栈序列（M）LeetCode 215 第K个最大的元素（E）LeetCode 295 寻找中位数（H）LeetCode 224 简单的计算器 （H） .
面试算法LeetCode刷题班
04-26
课程将程序员面试中常遇的算法与数据结构知识进行精简与归纳，细致入微地讲解笔试面试中的编程真题和相关知识点; 以leetcode.com、codeforces.com中的题目为例题，利用OJ刷题的方式提升学员的编码能力与解决算法面试题的能力
《面试算法 LeetCode 刷题班》——4. 递归，回溯，分治
qq_44744450的博客
07-17 189
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 4. 递归，回溯，分治 文章目录 4. 递归，回溯，分治LeetCode 78 求子级（M）LeetCode 90 求子集2（M）LeetCode 40 组合数之和2（M）LeetCode 22 生成括号（M）LeetCode 51 N 皇后（H）LeetCode 315 逆序数（H） LeetCode 78 求子级（M） 给定一个不含重复数的集合，求所有不重复.
《面试算法 LeetCode 刷题班》——7. 哈希表与字符串
qq_44744450的博客
07-17 193
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 7. 哈希表与字符串 文章目录 7. 哈希表与字符串LeetCode 409 最长回文串（E）LeetCode 290 词语模式（E）LeetCode 49 同字符词语分组（M）LeetCode 3 无重复字符的最长字串（M）LeetCode 187 重复的 DNA 序列（M）LeetCode 76 最小窗口子串（H） 哈希表： 也叫散列表，根据key直接进行访问得.
面试算法LeetCode刷题班—BAT面试官带你刷真题、过笔试
qq_44744450的博客
07-16 393
课程名称: 《面试算法LeetCode刷题班》 ——BAT面试官带你刷真题、过笔试 主讲老师: 林老师 BAT资深研发工程师(T7/P8级)，致力于搜索引擎及其子系统的研发、迭代与优化，数据分析与挖掘领域专家，多年担任校园招聘、社会招聘面试官，丰富的面试候选人经验。 课程简介: 掌握算法与数据结构是成为优秀程序员的必经之路，众多国内外知名互联网企业都将算法面试作为程序员招聘的重要和必需途径，只有高效应对各类题目，将知识储备转化为面试中的优秀表现，才能获得大公司的青睐。 本门课程将程序员面试中常遇的算法与数据
python基础刷题_数据结构与算法LeetCode刷题（Python）
weixin_39719472的博客
11-23 248
参考资料：一、链表1. 链表的必备知识要点(包括基础知识、刷题中使用的STL等知识)2. 链表逆序(LeetCode 92 ,206. Reverse Linked List 1,2)3. 求两个链表的交点(LeetCode 160. Intersection of Two Linked Lists)4. 链表的节点交换(LeetCode 24. Swap Nodes in Pairs)5...
LeetCode刷题笔记——63. 不同路径 II
12-21
难度：中等 一、题目描述： 二、解题分析： 1、解析   达到每一格的路径数量取决于它左边和上边的和。同时，如果这个点有障碍，那么这个点一定为0，因为到不了这个点。 2、代码实现 class Solution: ...
LeetCode刷题笔记——91. 解码方法
12-21
  这一题比《剑指Offer》刷题笔记——面试题46. 把数字翻译成字符串麻烦了些，因为这里，0是不能翻的。 2、代码实现 class Solution: def numDecodings(self, s: str) -> int: dp = [0] * len(s) # 考虑第一个...
LeetCode刷题笔记——56. 合并区间
01-20
难度：中等 一、题目描述： 二、解题分析： 1、解析   1）先对列表进行排序   2）判断两个相邻区间是否有交集 2、代码实现 class Solution: def merge(self, intervals: List[List[int]]) -> List[List[int]]:...
《面试算法 LeetCode 刷题班》—— 1. 链表
qq_44744450的博客
07-17 184
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 1.链表 文章目录 1.链表LeetCode 206 链表逆序 a （E）LeetCode 92 链表逆序 b（M）LeetCode 160 求两个链表的交点（E）LeetCode 141 & 142 链表求环（M） （快慢指针问题）LeetCode 86 链表划分（M）LeetCode 21 排序链表合并（2个）（E）LeetCode 23 排序链表合并（多个）（H）Le..
《面试算法 LeetCode 刷题班》——5.二叉树与图
Chris_zhangrx的博客
11-28 1175
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 5. 二叉树与图 文章目录5. 二叉树与图leetCode 113 路径之和2LeetCode 236 最近的公共祖先LeetCode 114 二叉树转链表LeetCode 199 侧面观察二叉树LeetCode 207 课程安排 leetCode 113 路径之和2 这里题目已经事先定义了...
leetcode刷题班java_leetcode刷题经验——编程语言：Java
weixin_40009099的博客
02-27 107
1、两数之和(难度：简单)(1)Java数组动态初始化：数据类型[] 数组名称=new 数据类型 [长度]键盘输入方法：方法一(不限制输入数组的长度)：Scanner sc = new Scanner(System.in);String str = sc.next().toString();String[] arr = str.split(",");int[] b = new int[arr.l...
《面试算法 LeetCode 刷题班》——6.二分查找与二叉查找树
Chris_zhangrx的博客
11-28 539
本文内容是基于小象学院——林沐 《面试算法 LeetCode 刷题班》，后期仍将对相关内容进行不定期更新！ 6.二叉查找与二叉查找树 文章目录6.二叉查找与二叉查找树LeetCode 35 插入位置LeetCode 34 查找区间LeetCode 33 旋转数组查找LeetCode 449LeetCode 315 逆序数 （解法2） 二分查找的递归实现 bool binary_search(v...
算法每日一题（python,2024.05.24) day.6
最新发布
L613Z的博客
05-27 544
数字比较型可以用双指针法寻找数字相同（或构成其他关系）的俩个数值（或其他类型），涉及到与数值有关的列表问题可以思考到sort()排序方法加以辅助。
数据结构leetcode刷题顺序
10-08
数据结构LeetCode刷题的顺序可以根据以下推荐进行： 1. 数组和字符串：这是最基础的数据结构，包括数组和字符串的操作和处理。 2. 链表：理解链表的特点和基本操作，如插入、删除、反转等。 3. 栈和队列：了解栈和队列的特点和应用，如使用栈实现队列、使用栈解决问题等。 4. 哈希表：掌握哈希表的原理和应用，如查找、插入、删除等。 5. 二叉树：了解二叉树的基本概念和遍历方式，如前序遍历、中序遍历、后序遍历等。 6. 堆：理解堆的性质和应用，如优先队列、堆排序等。 7. 图：了解图的表示方法和常见算法，如DFS、BFS等。 8. 动态规划：学习动态规划的思想和常见问题的解决方法。 9. 贪心算法：掌握贪心算法的思想和应用。 10. 回溯算法：了解回溯算法的原理和应用，如八皇后问题、0-1背包问题等。 这只是一个推荐顺序，具体可以根据个人情况和喜好进行调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值