周六在实验室呆了一天,好不容易有个能够自由支配的时间,刚好每日一题是一个动态规划类的题目,而动态规划又是极为常见的类型,索性一次性看了很多道动态规划题目,不过主要是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;
}
}
总结
连着做了这么多道动态规划的题目,也算是小有所得。主要难点在于知道何时使用动态规划,以及状态转移方程的寻找。希望以后再遇到类似题目,可以想到使用动态规划吧