1

Author: Ainevsia

notes/src/SUMMARY.md

@@ -173,4 +173,13 @@
   - [1143.最长公共子序列](./day53/lc1143.md)
   - [1035.不相交的线](./day53/lc1035.md)
   - [53. 最大子序和](./day53/lc53.md)
+- [day 55](./day55.md)
+  - [392.判断子序列](./day55/lc392.md)
+  - [115.不同的子序列](./day55/lc115.md)
+- [day 56](./day56.md)
+  - [583. 两个字符串的删除操作](./day55/lc583.md)
+  - [72. 编辑距离](./day56/lc72.md)
+- [day 57](./day57.md)
+  - [647. 回文子串](./day56/lc647.md)
+  - [516.最长回文子序列](./day56/lc516.md)
 - [remains](./remains.md)

notes/src/day53.md

@@ -1 +1,25 @@
-1143.最长公共子序列
+第九章 动态规划part14
+● 1143.最长公共子序列 
+● 1035.不相交的线   
+● 53. 最大子序和  动态规划 
+
+ 详细布置 
+
+ 1143.最长公共子序列 
+
+体会一下本题和 718. 最长重复子数组 的区别  
+视频讲解：https://www.bilibili.com/video/BV1ye4y1L7CQ
+https://programmercarl.com/1143.%E6%9C%80%E9%95%BF%E5%85%AC%E5%85%B1%E5%AD%90%E5%BA%8F%E5%88%97.html
+
+ 1035.不相交的线 
+
+其实本题和 1143.最长公共子序列 是一模一样的，大家尝试自己做一做。
+视频讲解：https://www.bilibili.com/video/BV1h84y1x7MP
+https://programmercarl.com/1035.%E4%B8%8D%E7%9B%B8%E4%BA%A4%E7%9A%84%E7%BA%BF.html
+
+ 53. 最大子序和 
+
+这道题我们用贪心做过，这次 再用dp来做一遍 
+视频讲解：https://www.bilibili.com/video/BV19V4y1F7b5
+https://programmercarl.com/0053.%E6%9C%80%E5%A4%A7%E5%AD%90%E5%BA%8F%E5%92%8C%EF%BC%88%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%EF%BC%89.html
+

notes/src/day55.md

@@ -0,0 +1,17 @@
+# 第九章 动态规划part15
+
+
+ 详细布置 
+
+## 392.判断子序列 
+
+这道题目算是 编辑距离问题 的入门题目（毕竟这里只是涉及到减法），慢慢的，后面就要来解决真正的 编辑距离问题了
+
+https://programmercarl.com/0392.%E5%88%A4%E6%96%AD%E5%AD%90%E5%BA%8F%E5%88%97.html
+
+## 115.不同的子序列 
+
+但相对于刚讲过 392.判断子序列，本题 就有难度了 ，感受一下本题和  392.判断子序列 的区别。 
+
+https://programmercarl.com/0115.%E4%B8%8D%E5%90%8C%E7%9A%84%E5%AD%90%E5%BA%8F%E5%88%97.html
+

notes/src/day55/lc115.md

@@ -0,0 +1,30 @@
+# 115.不同的子序列
+
+扇贝力扣
+
+最后一个测试案例答案是-1
+
+递推公式想不清楚啊 啊嗷嗷啊
+
+```cpp
+class Solution {
+public:
+    int numDistinct(string s, string t) {
+        // dp[i][j] = s[0:i-1]的子序列中t[0:j-1]出现的次数
+        vector<vector<unsigned long long>>dp(s.size()+1,vector<unsigned long long>(t.size()+1,0));
+        dp[0][0]=1;
+        // for(int i=1;i<t.size()+1;i++)dp[0][i]=1;
+        for(int j=1;j<s.size()+1;j++)dp[j][0]=1;
+        // dp[i][j]+=dp[i][j-1]
+        // if(s[i-1]==t[j-1])dp[i][j]+=dp[i-1][j-1]
+        for(int i=1;i<s.size()+1;i++)
+        for(int j=1;j<t.size()+1;j++){
+            if(s[i-1]==t[j-1])
+            dp[i][j]=dp[i-1][j]+dp[i-1][j-1];
+            else
+            dp[i][j]=dp[i-1][j];
+        }
+        return int(dp[s.size()][t.size()]);
+    }
+};
+```

notes/src/day55/lc392.md

@@ -0,0 +1,22 @@
+# 392.判断子序列
+
+抄了随想录
+
+```cpp
+class Solution {
+public:
+    bool isSubsequence(string s, string t) {
+        // dp[i][j] 表示以下标i-1为结尾的字符串s，
+        // 和以下标j-1为结尾的字符串t，
+        // 相同子序列的长度为dp[i][j]
+        vector<vector<int>>dp(s.size()+1,vector<int>(t.size()+1,0));
+        for(int i=1;i<s.size()+1;i++){
+            for(int j=i;j<t.size()+1;j++){
+                if(s[i-1]==t[j-1])dp[i][j]=dp[i-1][j-1]+1;
+                else dp[i][j]=dp[i][j-1];
+            }
+        }
+        return dp[s.size()][t.size()]==s.size();
+    }
+};
+```

notes/src/day55/lc583.md

@@ -0,0 +1,26 @@
+# 583. 两个字符串的删除操作
+
+自己做的喜喜
+
+```cpp
+class Solution {
+public:
+    int minDistance(string s, string t) {
+        // dp[i][j]：s[0:i-1] vs t[0:j-1]
+        // 想要达到相等，所需要删除元素的最少次数
+        vector<vector<int>>dp(s.size()+1,vector<int>(t.size()+1,0));
+        for(int j=1;j<t.size()+1;j++)dp[0][j]=j;
+        for(int j=1;j<s.size()+1;j++)dp[j][0]=j;
+        for(int i=1;i<s.size()+1;i++)
+        for(int j=1;j<t.size()+1;j++)
+        {
+            if(s[i-1]==t[j-1]){
+                dp[i][j]=dp[i-1][j-1];
+            }else{
+                dp[i][j]=min(dp[i-1][j],dp[i][j-1])+1;
+            }
+        }
+        return dp[s.size()][t.size()];
+    }
+};
+```

notes/src/day56.md

@@ -0,0 +1,19 @@
+# 第九章 动态规划part16
+
+
+ 详细布置 
+
+## 583. 两个字符串的删除操作 
+
+本题和动态规划：115.不同的子序列 相比，其实就是两个字符串都可以删除了，情况虽说复杂一些，但整体思路是不变的。
+https://programmercarl.com/0583.%E4%B8%A4%E4%B8%AA%E5%AD%97%E7%AC%A6%E4%B8%B2%E7%9A%84%E5%88%A0%E9%99%A4%E6%93%8D%E4%BD%9C.html
+
+## 72. 编辑距离 
+
+最终我们迎来了编辑距离这道题目，之前安排题目都是为了 编辑距离做铺垫。 
+
+https://programmercarl.com/0072.%E7%BC%96%E8%BE%91%E8%B7%9D%E7%A6%BB.html  
+
+## 编辑距离总结篇 
+做一个总结吧
+https://programmercarl.com/%E4%B8%BA%E4%BA%86%E7%BB%9D%E6%9D%80%E7%BC%96%E8%BE%91%E8%B7%9D%E7%A6%BB%EF%BC%8C%E5%8D%A1%E5%B0%94%E5%81%9A%E4%BA%86%E4%B8%89%E6%AD%A5%E9%93%BA%E5%9E%AB.html  

notes/src/day56/lc516.md

@@ -0,0 +1,22 @@
+# 516.最长回文子序列
+
+```cpp
+class Solution {
+public:
+    int longestPalindromeSubseq(string s) {
+        // dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]
+        vector<vector<int>>dp(s.size(),vector<int>(s.size(),0));
+        for (int i = 0; i < s.size(); i++) dp[i][i] = 1;
+        for (int i = s.size() - 1; i >= 0; i--) {
+            for (int j = i + 1; j < s.size(); j++) {
+                if (s[i] == s[j]) {
+                    dp[i][j] = dp[i + 1][j - 1] + 2;
+                } else {
+                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
+                }
+            }
+        }
+        return dp[0][s.size() - 1];
+    }
+};
+```

notes/src/day56/lc647.md

@@ -0,0 +1,28 @@
+# 647. 回文子串
+
+抄了随想录
+
+```cpp
+class Solution {
+public:
+    int countSubstrings(string s) {
+        // 布尔类型的dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。
+        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));
+        int result = 0;
+        for (int i = s.size() - 1; i >= 0; i--) {  // 注意遍历顺序
+            for (int j = i; j < s.size(); j++) {
+                if (s[i] == s[j]) {
+                    if (j - i <= 1) { // 情况一 和 情况二
+                        result++;
+                        dp[i][j] = true;
+                    } else if (dp[i + 1][j - 1]) { // 情况三
+                        result++;
+                        dp[i][j] = true;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+};
+```

notes/src/day56/lc72.md

@@ -0,0 +1,24 @@
+# 72. 编辑距离
+
+```cpp
+class Solution {
+public:
+    int minDistance(string s, string t) {
+        // s[0:i-1] vs t[0:j-1] 最近编辑距离为dp[i][j]
+        vector<vector<int>>dp(s.size()+1,vector<int>(t.size()+1,0));
+        for(int j=1;j<t.size()+1;j++)dp[0][j]=j;
+        for(int j=1;j<s.size()+1;j++)dp[j][0]=j;
+
+        for(int i=1;i<s.size()+1;i++)
+        for(int j=1;j<t.size()+1;j++)
+        {
+            if(s[i-1]==t[j-1]){
+                dp[i][j]=dp[i-1][j-1];
+            } else {
+                dp[i][j]=min(min(dp[i-1][j],dp[i][j-1]),dp[i-1][j-1])+1;
+            }
+        }
+        return dp[s.size()][t.size()];
+    }
+};
+```