leetcode 动态规划类型题

1，Triangle

 int mininumTotal(vector<vector<int>>& triangle)  {
     for (int i = triangle.size() - ; i >= ; --i) {
         for (int j = ; j < i + ; ++j) {
             // 从下往上依次保存当前路径的最小值，上层只会用到下层的最小值
             triangle[i][j] += min(triangle[i + ][j], triangle[i + ][j + ]);
         }
     }
     return triangle[][];
 }

triangle

2，Maximum SubArray

 /*
  * 状态转移方程为：f[j] = max{ f[j-1] + S[j],S[j] },其中  1 <= j <= n
  *                 target = max{ f[j] },其中  1 <= j <= n
 */
 int maxArray(vector<int>& nums) {
     int n = nums.size();
     vector<int> dp(n + );
     dp[] = ;
     for (int i = ; i < n; ++i) {
         dp[i + ] = max(dp[i] + nums[i], nums[i]);
     }
     return *max_element(dp.begin(), dp.end());

maxArray

3，Palindromic Substrings

 /*
 * dp[i][j] 的值表示 s[i,j]这个字串是否为回文字符串
 */
 int countSubstrings(string& s) {
     int n = s.size();
     int res = ;
     vector<vector<bool>> dp(n, vector<bool>(n, false));
     for (int i = n - ; i >= ; i--) {
         for (int j = i; j < n; ++j) {
             dp[i][j] = (s[i] == s[j] && (j - i <=  || dp[i + ][j - ]));
             if (dp[i][j]) res++;
         }
     }
     return res;
 }

countSubstrings

4，Palindromic Substrings(II)

 /*
 * p[i][j]用来判断 s[i][j]这个字串是否是回文子串
 * dp[i] 用来记录[0,i]这个范围内的最小切割数
 * 所以只用求 dp[n-1] 的值就是答案
 */
 int minCut(string& s) {
     if (s.empty()) return ;
     int n = s.size();
     vector<vector<bool>> p(n, vector<bool>(n));
     vector<bool> dp(n);

     for (int i = ; i < n; ++i) {
         dp[i] = i;  // 对 dp[i]初始化为最大切割数
         for (int j = ; j <= i; ++j) {  // 对每一个子串s[i][j]进行遍历
             if (s[i] == s[j] && (i - j <=  || p[j + ][i - ])) {  // 如果s[j][i] 为回文子串
                 p[j][i] = true;
                 dp[i] = (j == ) ?  : min(dp[i], dp[j - ] + );
             }
         }
     }
     return dp[n - ];
 }

minCut

5,Longest Common Substring

 /*
  × 求解最长公共子串（一定是连续才称为子串）
  × 初始化：dp[0][j] = 0;dp[i][0] = 0; 第0行全为0,第0列全为0
  ×                           0 ; (i==0 || j==0)
  * 状态转移方程： dp[i][j] = dp[i-1][j-1] + 1;   (s1[i] == s2[j])
  *                           0 ; (s1[i] != s2[j])
  × 结果：每次保存字符串长度的最大值即为所求
  */
 int lcs(string s1,string s2) {
     int len1 = s1.length();
     int len2 = s2.length();
     int res = ;
     vector<vector<int>> dp(len1+,vector<int>(len2+,));

     for(int i=;i<=len1;++i) {
         for(int j=;j<=len2;++j) {
             if(s1[i] == s2[j]) dp[i][j] = dp[i-][j-] + ;
             res = max(res,dp[i][j]);
         }
     }
     return res;
 }

 /*
  * 求解最长子序列（不一定连续）
  × 初始化：dp[0][j] = 0;dp[i][0] = 0;
  *                                 0;             (i == 0 || j == 0)
  × 状态转移方程：dp[i][j] =   dp[i-1][j-1] + 1;   (s1[i] == s2[j])
  *                          max(dp[i-1][j],dp[i][j-1]);(s1[i] != s2[j])
  * 结果：最后保存的 dp[len1][len2] 即为所求
  */
 int lcs(string s1,string s2) {
     int len1 = s1.length();
     int len2 = s2.length();
     vector<vector<int>> dp(len1+,vector<int>(len2+,));

     for(int i=;i<=len1;++i) {
         for(int j=;j<=len2;++j) {
             if(s1[i] == s2[j]) dp[i][j] = dp[i-][j-] + ;
             else dp[i][j] = max(dp[i-][j],dp[i][j-]);
         }
     }
     return dp[len1][len2];
 }

lcs