LeetCode算法打卡--动态规划

最新推荐文章于 2021-03-14 22:20:13 发布

qi_700

最新推荐文章于 2021-03-14 22:20:13 发布

阅读量174

点赞数

本文链接：https://blog.csdn.net/qi_700/article/details/100101851

版权

62. 不同路径

一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

问总共有多少条不同的路径？

链接：https://leetcode-cn.com/problems/unique-paths


/*
  基本思想：基本动态规划思想
*/
class Solution {
public:
    int uniquePaths(int m, int n) {
        
       int dp[m][n];
        int i,j;
        for(i=0;i<m;i++)
            dp[i][0] = 1;
        for(i=0;i<n;i++)
            dp[0][i] = 1;
        for(i=1;i<m;i++)
        {
            for(j=1;j<n;j++)
            {
                dp[i][j] = dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

139. 单词拆分

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

拆分时可以重复使用字典中的单词。
你可以假设字典中没有重复的单词。

链接：https://leetcode-cn.com/problems/word-break

//word为每次循环截取剩下的一部分，如果是dict中的单词，则检测前面的串是否是单词，只要是就返回true
class Solution {
public:
    bool wordBreak(string s, unordered_set<string> &dict) {
        int i;
        bool flag;
        if (dict.size()==0)
            flag= false;
        if(dict.count(s))
            flag= true;
        
        for(i=1;i<s.size();i++)
        {
            string word = s.substr(i);
            if(dict.count(word))
            {
                string current_s = s.substr(0,i);
                flag = wordBreak(current_s,dict);
                if(flag == true)
                    return true;
            }
        }
        return flag;
    }
};

120. 三角形最小路径和

给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。

链接：https://leetcode-cn.com/problems/triangle/

//从底向上累加，每个数只能累加相邻的两个数，在相邻的两个数中找最小，累加得到新的三角形的一行的数据，累加到头，即最小
class Solution {
public:
    int minimumTotal(vector<vector<int> > &triangle) {
        int i,j;
        int len =triangle.size();
        for(i=len-2;i>=0;i--)
        {
            for(j=0;j<triangle[i].size();j++)
            {
               
                triangle[i][j] = min(triangle[i+1][j],triangle[i+1][j+1]) + triangle[i][j];
            }
        }
        return triangle[0][0];
    }
};

131. 分割回文串

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

链接：https://leetcode-cn.com/problems/palindrome-partitioning/

//深度优先搜索，一直向下分割判断递归调用，之后返回上一次继续
class Solution {
public:
    bool check(string s)
    {
       return s==string(s.rbegin(),s.rend());
       
    }
    void split(string s,vector<string> &cur, vector<vector<string>> &result)
    {
        if(s.length()==0)
            result.push_back(cur);
        
        int len=s.length();
        int i;
        for(i=1;i<=len;i++)
        {
            string cur_s = s.substr(0,i);
            if(check(cur_s))
            {
                cur.push_back(cur_s);
                string rest_s = s.substr(i);
                split(rest_s,cur,result);
                cur.pop_back();
            }
        }
    }
    vector<vector<string>> partition(string s) {
        vector<vector<string>>  result;
        vector<string> cur;
        split(s,cur,result);
        return result;
        
    }
};

115. 不同的子序列

给定一个字符串 S 和一个字符串 T，计算在 S 的子序列中 T 出现的个数。

一个字符串的一个子序列是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，而 "AEC" 不是）

链接：https://leetcode-cn.com/problems/distinct-subsequences


/*

我们需要一个二维数组dp(i)(j)来记录长度为i的字串在长度为j的母串中出现的次数，这里长度都是从头算起的，而且遍历时，保持子串长度相同，先递增母串长度，母串最长时再增加一点子串长度重头开始计算母串。
首先我们先要初始化矩阵，当子串长度为0时，所有次数都是1，
当母串长度为0时，所有次数都是0.当母串子串都是0长度时，次数是1（因为都是空，相等）。
接着，如果子串的最后一个字母和母串的最后一个字母不同，说明新加的母串字母没有产生新的可能性，可以沿用该子串在较短母串的出现次数，所以dp(i)(j) = dp(i)(j-1)
如果子串的最后一个字母和母串的最后一个字母相同，说明新加的母串字母带来了新的可能性，我们不仅算上dp(i)(j-1)，也要算上新的可能性。
那么如何计算新的可能性呢，其实就是在既没有最后这个母串字母也没有最后这个子串字母时，子串出现的次数，我们相当于为所有这些可能性都添加一个新的可能。
所以，这时dp(i)(j) = dp(i)(j-1) + dp(i-1)(j-1)

*/
class Solution {
public:
    int numDistinct(string S, string T) {
     
        int n=T.size();  //子串的长度
        int m=S.size();  //母串的长度
        long dp[n+1][m+1]; //不同的n，对于m的母串的匹配个数
        int i,j;
        for(i=0;i<=n;i++)
            dp[i][0] = 0;  //母串为0时匹配个数均为0
         for(i=0;i<=m;i++)
            dp[0][i] =  1;  //字串为0时匹配个数均为1
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=m;j++)
            {
                if(T[i-1] == S[j-1])
                {
                    dp[i][j] = dp[i-1][j-1]+dp[i][j-1]; 
                }
                else
                    dp[i][j] = dp[i][j-1];
            }
        }
        
        return dp[n][m];
    }
};

64. 最小路径和

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

链接：https://leetcode-cn.com/problems/minimum-path-sum/

/* dp[m][n]的值应该是dp[m-1][n]下移或dp[m][n-1]右移得到的，所以相当于找那两个值最小的加上本来grid[m][n]
的值即可
*/
class Solution {
public:
    int minPathSum(vector<vector<int> > &grid) {
        int m = grid.size();
        int n = grid[0].size();
        int dp[m][n];
        int i,j;
        dp[0][0] = grid[0][0];
         for(i=1;i<n;i++)
        {
            dp[0][i] = grid[0][i]+dp[0][i-1];
         }
         for(i=1;i<m;i++)
        {
            dp[i][0] = grid[i][0]+dp[i-1][0];
         }
        for(i=1;i<m;i++)
        {
            for(j=1;j<n;j++)
            {
                dp[i][j] = min(dp[i-1][j],dp[i][j-1]) +  grid[i][j];
            }
        }
        return dp[m-1][n-1];
    }
};

5. 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

链接：https://leetcode-cn.com/problems/longest-palindromic-substring/

/*基本思想：动态规划
定义：
    dp[i][j] := 子串 s[i..j] 是否是回文子串
初始化
    dp[i][j] = 1     s[i]=s[j]
             = 0     other
递推公式：
    j-i=1情况下：
      dp[i][j] = 1        s[i]==s[j] 
               = 0         other
    j-i>1情况下         
      dp[i][j] = 1        s[i]==s[j]&&dp[i+1][j-1]=1
               = 0          other
               
  对于是ij是回文的情况判断长度如果大于最大长度，就记录其实位置和长度，最后截取输出即可
*/
class Solution {
public:
    string longestPalindrome(string s) {
        
        int len = s.size();
        if(len==0)
            return s;
        vector<vector<int>> dp(len, vector<int>(len, 0));     
        int i=0,j;
        int maxstart=0;
       
        int maxlen=1;
        for(i=0;i<len;i++)
        {
            dp[i][i]=1;
        }
        for(j=1;j<len;j++)   //从下往上填,结束的位置
        {
            for(i=j-1;i>=0;i--)  //开始的位置
            {
                if(j-i<2)
                {
                    if(s[i]==s[j])
                    {
                        dp[i][j]=1;
                    }
                    else
                        dp[i][j]=0;
                }
                    
                else{
                if(s[i]==s[j] && dp[i+1][j-1] == 1)
                {
                    dp[i][j]=1;
                    
                }
                else
                    dp[i][j]=0;
                }
               
                if(dp[i][j]==1 && j-i+1> maxlen)
                    {
                        maxlen = j-i+1;
                        maxstart = i;
                      
                    }
            }
            
        }
        return s.substr(maxstart,maxlen);
    }
};

343. 整数拆分

给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。返回你可以获得的最大乘积。

链接：https://leetcode-cn.com/problems/integer-break/

/*基本思路：动态规划递推式 dp记录每一个数当前拆分的最大值，当前数的拆分会依据前面的数
         dp[i] = max(dp[i],max(j*(i-j),j*dp[i-j])) (j从1到1/2)
    或者dp[i] = max(dp[i],dp[j]*dp[i-j]) (其中2，3特殊处理，唯二的dp[x]小于x的情况，其他都是dp[x]>=x)
*/
class Solution {
public:
    int integerBreak(int n) {
        int dp[n+1];
        if(n==0)
          return 0;
        if(n==1 || n==2)
          return 1;
        dp[0]=0;
        dp[1]=1;
        dp[2]=1;
        for(int i=3;i<=n;i++)
          dp[i]=0;
        for(int i=3;i<=n;i++)
        {
            for(int j=1;j<=i/2;j++)
            {
                dp[i] = max(dp[i],max(j*(i-j),j*dp[i-j])) ;
            }
           // cout<<dp[i]<<endl;

        }
        return dp[n];
    }
};

357. 计算各个位数不同的数字个数

给定一个非负整数 n，计算各位数字都不同的数字 x 的个数，其中 0 ≤ x < 10n 。

链接：https://leetcode-cn.com/problems/count-numbers-with-unique-digits/

/*基本思想: 数学思想，对于dp就是每个n的没有重复位数的数字，初始化0为1，1为10个数
           对于 dp[i]= dp[i-1] + (dp[i-1]-dp[i-2])*(10-(i-1))
           dp[i-1]没什么可说的，加上之前的数字
           (dp[i-1]-dp[i-2])*(10-(i-1)) 假如n=3 就在n=2的基础上(注意dp[2]包含了只有一位的数，所以减去dp[1])添加一位数组成数字，但是添加的数字只能是之前2位数中没有的(10-(i-1)), 
*/
class Solution {
public:
    int countNumbersWithUniqueDigits(int n) {
        int dp[n+1];
        if(n==0)
           return 1;
        dp[0] = 1;
        dp[1] = 10;
        for(int i=2;i<=n;i++)
        {
            dp[i]= dp[i-1] + (dp[i-1]-dp[i-2])*(10-(i-1));
        }
      
        return dp[n]; 

    }
};

53. 最大子序和

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

链接：https://leetcode-cn.com/problems/maximum-subarray/

/*基本思想：当前和<0 ,就断开不继续累加，否则继续累加 注意每次都要更新最大值结果
*/
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
      int  max_value = nums[0];
      int cur = nums[0];
      for(int i=1;i<nums.size();i++)
      {   
        if(cur<0)
             {    
                 cur = nums[i];
             }
        else
            cur+=nums[i];
         max_value = max(max_value,cur);    
      }
      return max_value;
    }
};
分治方法
/*基本思想：采用分治的方法，就是判断左边连续的，右边连续的和中间连续的三个的最大值，中间需要从中间找向左最大和向右最大的和
*/
class Solution {
public:

  
    int sub(vector<int> nums, int left, int right)
    {
        int l=INT_MIN,r=INT_MIN;
        int leftMaxSum = INT_MIN;
        int rightMaxSum = INT_MIN;
        if(left == right)
            return nums[left];
        int mid = (left+right)/2;
         l = sub(nums,left,mid);
         r = sub(nums,mid+1,right);
        int leftSum = 0;
        for(int i = mid; i >= left; i--)
         {
              leftSum += nums[i];
              leftMaxSum = max(leftMaxSum,leftSum);
        }
        int rightSum =0;
        for(int i=mid+1;i<=right;i++)
        {
                rightSum += nums[i];
                rightMaxSum = max(rightMaxSum,rightSum);
        }
           
        
        return max(max(l,r),leftMaxSum+rightMaxSum);
    }
    int maxSubArray(vector<int>& nums) {
        
        int res = sub(nums,0,nums.size()-1);
        return res;
    }
};

152. 乘积最大子数组

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

链接：https://leetcode-cn.com/problems/maximum-product-subarray/

/*基本思想：遍历数组乘积会出现当前元素是正和负两种，如果是正的，那上一个累计的乘积也为正，乘积变大，如果是负，那上一个累积为负也最大
          所以要得到乘以当前元素以后的最大乘积，需要记录最大乘积，也要记录最小乘积，因为最小值可能翻身变最大值。对于当前元素是负的情况就需要乘之前的最小值比较
            
*/
class Solution {
public:
    int maxProduct(vector<int>& nums) {
       int max_value = INT_MIN;
       int cur_max = 1;
       int cur_min = 1;
       for(int i=0;i<nums.size();i++)
       {
           if(nums[i]<0)
             swap(cur_max, cur_min);
           cur_max = max(cur_max*nums[i],nums[i]);
           cur_min = min(cur_min*nums[i], nums[i]);
           max_value = max(max_value,cur_max);
         
       }
       return max_value;
    }
};

qi_700

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode算法打卡--动态规划

62. 不同路径一个机器人位于一个 m x n 网格的左上角（起始点在下图中标记为“Start” ）。机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。问总共有多少条不同的路径？链接：https://leetcode-cn.com/problems/unique-paths/* 基本思想：基本动态规划思想*/c...
复制链接

扫一扫