每日刷题——Leetcode 动态规划专场

最新推荐文章于 2023-03-12 21:54:24 发布

XJTU_WJGao

最新推荐文章于 2023-03-12 21:54:24 发布

阅读量256

点赞数

分类专栏： LeetCode 文章标签：动态规划 leetcode 算法

本文链接：https://blog.csdn.net/weixin_43333043/article/details/115428279

版权

LeetCode 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

周六在实验室呆了一天，好不容易有个能够自由支配的时间，刚好每日一题是一个动态规划类的题目，而动态规划又是极为常见的类型，索性一次性看了很多道动态规划题目，不过主要是easy和偏下难度的mid，一步一步来嘛。

动态规划

这里参考了

https://blog.csdn.net/zw6161080123/article/details/80639932

能采用动态规划求解的问题的一般要具有3个性质：
(1) 最优化原理：如果问题的最优解所包含的子问题的解也是最优的，就称该问题具有最优子结构，即满足最优化原理。
(2) 无后效性：即某阶段状态一旦确定，就不受这个状态以后决策的影响。也就是说，某状态以后的过程不会影响以前的状态，只与当前状态有关。
(3）有重叠子问题：即子问题之间是不独立的，一个子问题在下一阶段决策中可能被多次使用到。（该性质并不是动态规划适用的必要条件，但是如果没有这条性质，动态规划算法同其他算法相比就不具备优势）

构造动态规划主要是几步
1、创建一个一维数组或是二维数组，保存每个子问题的结果
2、设置边界值
3、找出状态转化方程
4、返回需要的值

下面就通过几道LeetCode的题目，来帮助理解动态规划

Leetcode53 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例 1：
输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

1、设置一个一维数组sum[i]，保存到第i个元素的最大连续子数组的和
2、sum[0]=num[0]
3、sum[i]=max(sum[i-1]+num[i],num[i])
4、最后一个元素为最终结果
当第i个元素的值仅和第i-1个元素值有关时，就可以使用一个变量代替辅助数组

class Solution {
    public int maxSubArray(int[] nums) {
    	int len = nums.length;
    	int max = nums[0];
    	int sum = nums[0];
    	for(int i=1; i<len; i++){
    		sum = Math.max(sum+nums[i], nums[i]);
    		if(sum>=max){
    			max=sum;
			}
		}
    	return max;
    }
}

Leetcode70 爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。

这题也是一道easy，设置一个辅助数组num[n]，对于第i层，可以从i-1层爬一个台阶，也可以从i-2层爬两个台阶，因此得到状态转化方程。边界值，num[1]=1,num[0]=1。

class Solution {
    public int climbStairs(int n) {
    	if(n==1){
    		return 1;
		}
    	int prepre = 1;
    	int pre = 1;
    	int ans = 1;
    	for(int i=2; i<=n; i++){
    		ans = prepre + pre;
    		prepre = pre;
    		pre = ans;
		}
    	return ans;
    }
}

Leetcode5 最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：
输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。

这是一道mid题目，回文子串的特点就是从左向右序列和从右向左序列相同。如果暴力算法的话，测试所有的i和j，判断i和j中间是否为回文子串，时间复杂度为O(n^3)，这样的话肯定就超时了。
这时候就可以想到，如果i到j为回文子串，那么如果s[i-1]=s[j+1]，那么i-1到j+1也是回文子串，从而找到状态转化方程。
边界条件的话，考虑到回文子串长度可能为奇数或偶数，那么初值则设置长度为1和为2的子串。

class Solution {
    public String longestPalindrome(String s) {
		int n = s.length();
		boolean[][] dp = new boolean[n][n];
		String ans = "";
		for (int l = 0; l < n; ++l) {
			for (int i = 0; i + l < n; ++i) {
				int j = i + l;
				if (l == 0) {
					dp[i][j] = true;
				} else if (l == 1) {
					dp[i][j] = (s.charAt(i) == s.charAt(j));
				} else {
					dp[i][j] = (s.charAt(i) == s.charAt(j) && dp[i + 1][j - 1]);
				}
				if (dp[i][j] && l + 1 > ans.length()) {
					ans = s.substring(i, i + l + 1);
				}
			}
		}
		return ans;

    }
}

Leetcode62 不同路径

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为 “Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。
问总共有多少条不同的路径？

这也是一道mid题，不过这题思路要比上一题简单。很容易想到构造辅助数组num[m][n]，表示到达每个点的路径数。因为机器人只能向下或向右，因此num[i][j] = num[i-1][j]+num[i][j-1]。边界条件则是第一行第一列均为1。

class Solution {
    public int uniquePaths(int m, int n) {
    	int[][] dp = new int[m][n];
    	for(int i = 0; i < m; i++){
    		dp[i][0] = 1;
		}
    	for(int j = 1; j < n; j++){
    		dp[0][j] = 1;
		}
    	for(int i = 1; i < m; i++){
    		for(int j = 1; j < n; j++){
    			dp[i][j] = dp[i-1][j] + dp[i][j-1];
			}
		}
    	return dp[m-1][n-1];
    }
}

Leetcode63 不同路径Ⅱ

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

有障碍物的唯一区别就是，设置该点处的路径数为0。

class Solution {
    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
    	int m = obstacleGrid.length;
    	int n = obstacleGrid[0].length;
    	int[][] dp = new int[m][n];
    	if(obstacleGrid[0][0]==1 || obstacleGrid[m-1][n-1]==1){
    		return 0;
		}
    	dp[0][0] = 1;
    	for(int i = 1; i < m; i++){
    		if(obstacleGrid[i][0] == 1){
    			dp[i][0] = 0;
			}else{
    			dp[i][0] = dp[i-1][0];
			}
		}
    	for(int j = 1; j < n; j++){
    		if(obstacleGrid[0][j] == 1){
    			dp[0][j] = 0;
			}else{
    			dp[0][j] = dp[0][j-1];
			}
		}
    	for(int i = 1; i < m; i++){
    		for(int j = 1; j < n; j++){
    			if(obstacleGrid[i][j] == 1){
    				dp[i][j] = 0;
				}else {
    				dp[i][j] = dp[i-1][j] + dp[i][j-1];
				}
			}
		}
    	return dp[m-1][n-1];
    }
}

Leetcode152 乘积最大子序列

给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积

示例 1:
输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

这一题类似于长度最大子序列，第一想法就是存储每个位置的最大乘积，然后判断max(num[i],num[i]*max[i-1])。但是这一题的关键在于负数的存在，这里我想到了用两个辅助数组保存，但是还是差了一点。
考虑当前位置如果是一个负数的话，那么我们希望以它前一个位置结尾的某个段的积也是个负数，这样就可以负负得正，并且我们希望这个积尽可能「负得更多」，即尽可能小。如果当前位置是一个正数的话，我们更希望以它前一个位置结尾的某个段的积也是个正数，并且希望它尽可能地大。于是这里我们可以再维护一个 fmin(i)f_{\min}(i)f min (i)，它表示以第 iii 个元素结尾的乘积最小子数组的乘积，那么我们可以得到这样的动态规划转移方程
在这里插入图片描述

class Solution {
    public int maxProduct(int[] nums) {
        int length = nums.length;
        int[] maxF = new int[length];
        int[] minF = new int[length];
        System.arraycopy(nums, 0, maxF, 0, length);
        System.arraycopy(nums, 0, minF, 0, length);
        for (int i = 1; i < length; ++i) {
            maxF[i] = Math.max(maxF[i - 1] * nums[i], Math.max(nums[i], minF[i - 1] * nums[i]));
            minF[i] = Math.min(minF[i - 1] * nums[i], Math.min(nums[i], maxF[i - 1] * nums[i]));
        }
        int ans = maxF[0];
        for (int i = 1; i < length; ++i) {
            ans = Math.max(ans, maxF[i]);
        }
        return ans;
    }
}

Leetcode1143 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回 0 。
一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。
两个字符串的公共子序列是这两个字符串所共同拥有的子序列。

示例 1：
输入：text1 = “abcde”, text2 = “ace”
输出：3
解释：最长公共子序列是 “ace” ，它的长度为 3 。

这是今天的每日一题，也是一道mid题目。最初因为没有整数规划的概念，所以没有第一时间想到用整数规划去做。当时因为前两天每日一题有回溯方法，想的是使用一个回溯的方法，以text1为基准，text2的每个元素都尝试取或不取，这样做时间复杂度已经达到了O(m*2^n)，实在过于惊人，不可避免地超时了，这里也分享下代码


class Solution {
	int maxlength = 0;
    public int longestCommonSubsequence(String text1, String text2) {
    	int len1 = text1.length();
    	int len2 = text2.length();
    	backtrace(0, 0, text1, text2, len1, len2, 0);
    	return maxlength;
    }
    public void backtrace(int i, int j, String x, String y, int len1, int len2, int ans){
    	if(i>=len1 || j>=len2){
    		return;
		}
    	if(x.charAt(i) == y.charAt(j)){
			if(ans+1 > maxlength){
				maxlength = ans + 1;
			}
			backtrace(i+1, j+1, x, y, len1, len2, ans+1);
			return;
		}
    	backtrace(i, j+1, x, y, len1, len2, ans);
    	while(i < len1 && y.charAt(j) != x.charAt(i)){
    		i++;
		}
    	if(i==len1){
    		return;
		}else{
    		if(ans+1 > maxlength){
    			maxlength = ans + 1;
			}
    		backtrace(i+1, j+1, x, y, len1, len2, ans+1);
		}
	}
}

回过神来，如果考虑用动态规划的方法，用dp[m][n]表示text1前m个字符和前n个字符的最大公共子序列长度。状态转移方程，则为
在这里插入图片描述
从而可以得到

class Solution {
	int maxlength = 0;
    public int longestCommonSubsequence(String text1, String text2) {
    	int len1 = text1.length();
    	int len2 = text2.length();
    	int[][] dp = new int[len1+1][len2+1];
    	for(int i = 0; i <= len1; i++){
    		for(int j = 0; j <= len2; j++){
    			if(i==0 || j==0){
    				dp[i][j] = 0;
				}else{
    				if(text1.charAt(i-1)==text2.charAt(j-1)){
						dp[i][j] = max3(dp[i-1][j-1]+1, dp[i][j-1], dp[i-1][j]);
					}else{
    					dp[i][j] = Math.max(dp[i][j-1], dp[i-1][j]);
					}

				}
			}
		}
    	return dp[len1][len2];
    }
    int max3(int a, int b, int c){
    	if(b>a){
    		a=c;
		}
		if(c>a){
			a=c;
		}
		return a;
	}
}

总结

连着做了这么多道动态规划的题目，也算是小有所得。主要难点在于知道何时使用动态规划，以及状态转移方程的寻找。希望以后再遇到类似题目，可以想到使用动态规划吧

XJTU_WJGao

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
每日刷题——Leetcode 动态规划专场

周六在实验室呆了一天，好不容易有个能够自由支配的时间，刚好每日一题是一个动态规划类的题目，而动态规划又是极为常见的类型，索性一次性看了很多道动态规划题目，不过主要是easy和偏下难度的mid，一步一步来嘛。动态规划这里参考了https://blog.csdn.net/zw6161080123/article/details/80639932能采用动态规划求解的问题的一般要具有3个性质：(1) 最优化原理：如果问题的最优解所包含的子问题的解也是最优的，就称该问题具有最优子结构，即满足最优化原理
复制链接

扫一扫