[日记]LeetCode算法·二十二——动态规划⑦ 子序列系列_子序列 leetcode

子序列系列

子序列系列应该是整个动态规划里最长的系列，大概可以分为连续子序列、不连续子序列、编辑距离和回文子序列四个模块，因此也罕见地进行划分吧。

1 连续子序列

1.1 最大子序和

LeetCode:最大子序和
经典题目，可以用贪心、动态规划、分而治之等办法解决。
使用动态规划时，则是以nums[i]结尾的最大数组和，要么接入上一个，要么自己从头开始。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int max_val=nums[0];
        for(int i=1;i<nums.size();++i)
        {
            nums[i] = max(nums[i],nums[i-1]+nums[i]);
            max_val = max(max_val,nums[i]);
        }
        return max_val;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12

1.2 最长连续递增序列

LeetCode:最长连续递增序列
以i结尾，要么接入i-1，要么自己作为起点。

class Solution {
public:
    int findLengthOfLCIS(vector<int>& nums) {
        vector<int> dp(nums.size(),1);
        int max_length=1;
        for(int i=1;i<nums.size();++i)
        {
            if(nums[i]>nums[i-1])
                dp[i]=dp[i-1]+1;
            max_length=max(dp[i],max_length);
        }
        return max_length;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

1.3 最长重复子数组

LeetCode:最长重复子数组
因为涉及两个序列，因此应该使用二维dp数组进行状态递推。
dp[i][j]代表着【nums[i]】结尾与【nums2[j]】结尾的子数组的公共长度。
理论上额外添加一行一列可以轻松递推过程，否则就需要和下面代码一样，对第一行与第一列进行初始化。

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        //dp[i][j]代表着【nums[i]】结尾与【nums2[j]】结尾的子数组的公共长度
        //显然，nums[i]=nums[j]时，dp[i][j]=1+dp[i-1][j-1]
        vector<vector<int>> dp(nums1.size(),vector<int>(nums2.size(),0));
        //初始化dp[0][j]和dp[i][0]
        int i,j;
        int max_length=0;
        //初始化行
        for(j=0;j<nums2.size();++j)
        {
            if(nums2[j]==nums1[0])
            {
                dp[0][j]=1;
                max_length=1;
            }
        }
        //初始化列
        for(i=0;i<nums1.size();++i)
        {
            if(nums1[i]==nums2[0])
            {
                dp[i][0]=1;
                max_length=1;
            }
        }
        //动态规划
        for(i=1;i<nums1.size();++i)
        {
            for(j=1;j<nums2.size();++j)
            {
                if(nums1[i]==nums2[j])
                {
                    dp[i][j]=1+dp[i-1][j-1];
                    max_length=max(max_length,dp[i][j]);
                }
            }
        }
        return max_length;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

2 非连续子序列

2.1 最长公共子序列

LeetCode:最长公共子序列
依然是二维dp数组，不过区别在于因为可以删除，所以递推公式，在字符不相等时，只需要考虑dp[i-1][j]和dp[i][j-1]，即删除str1[i]或str2[j]。

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        vector<vector<int>> dp(text1.size(),vector<int>(text2.size(),0));
        int i,j;
        //初始化
        bool flag=false;
        for(j=0;j<text2.size();++j)
        {
            if(flag || text1[0]==text2[j])
            {
                dp[0][j]=1;
                flag=true;
            }
        }
        flag=false;
        for(i=0;i<text1.size();++i)
        {
            if(flag || text1[i]==text2[0])
            {
                dp[i][0]=1;
                flag=true;
            }
        }
        //动态规划
        for(i=1;i<text1.size();++i)
        {
            for(j=1;j<text2.size();++j)
            {
                if(text1[i]==text2[j])
                    dp[i][j]=1+dp[i-1][j-1];
                else
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp.back().back();
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

2.2 不相交的线

LeetCode:不相交的线
本质上与2.1完全一致的一道题，将这道题抽象为LCS即可。
在这里，我使用了[size1+1][size2+1]大小的dp数组，简化了初始化过程。

class Solution {
public:
    int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
        vector<vector<int>> dp(nums1.size()+1,vector<int>(nums2.size()+1,0));
        //dp[i][j]=1+dp[i-1][j-1] or dp[i][j]=max(dp[i-1][j],dp[i][j-1])
        for(int i=1;i<=nums1.size();++i)
        {
            for(int j=1;j<=nums2.size();++j)
            {
                if(nums1[i-1]==nums2[j-1])
                    dp[i][j]=1+dp[i-1][j-1];
                else
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp.back().back();
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2.3 最长递增子序列

LeetCode:最长递增子序列
dp[i]设定为以i结尾的最长严格递增子序列的长度，每次都从前i-1个子序列里找到比nums[i]小且最长的子序列。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(),1);
        int max_length=1;
        for(int i=1;i<nums.size();i++)
        {
            for(int j=0;j<i;++j)
            {
                if(nums[j]<nums[i])
                    dp[i] = max(dp[i],dp[j]+1);
            }
            max_length=max(max_length,dp[i]);
        }
        return max_length;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3 编辑距离

3.1 判断子序列

LeetCode:判断子序列
dp[i][j]指s[0-i]在t[0-i]的子序列中的最长公共部分，那么从定义出发dp[i][j]=dp[i][j-1]或dp[i][j]=1+dp[i-1][j-1]。

class Solution {
public:
    bool isSubsequence(string s, string t) {
        //dp[i][j]指s[0-i]在t[0-i]的子序列中的最长公共部分
        //dp[i][j]=dp[i][j-1] or dp[i][j]=1+dp[i-1][j-1]
        vector<vector<int>> dp(s.size()+1,vector<int>(t.size()+1,0));
        for(int i=1;i<=s.size();++i)
        {
            for(int j=1;j<=t.size();++j)
            {
                if(s[i-1]==t[j-1])
                    dp[i][j]=1+dp[i-1][j-1];
                else
                    dp[i][j]=dp[i][j-1];
            }
        }
        return dp[s.size()][t.size()]==s.size();
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.2 不同的子序列

LeetCode:不同的子序列
dp[i][j]代表字符串s从0~i-1的子序列中出现t[0:j-1]的次数。

• 在s[i-1]==t[j-1]的情况下，考虑两种情况。
• 使用s[i-1]，那么这种情况下，dp[i][j]与dp[i-1][j-1]就完全一致。
• 不使用s[i-1]，那么这种情况下，等效于删除s[i-1]，也是符合条件的，我们考虑dp[i-1][j]。
• 最终，dp[i][j]的可能性由这两部分一起组成，即dp[i][j] = dp[i-1][j-1] + dp[i-1][j]。

class Solution {
public:
    int numDistinct(string s, string t) {
        //dp[i][j]代表s到i-1处的子序列中出现t[0:j-1]的个数
        //对于dp[i][j]而言，如果s[i-1]==t[j-1]，那么存在两种情况
        //使用s[i-1]，那么dp[i][j] : dp[i-1][j-1]
        //不使用s[i-1]，那么dp[i][j] : dp[i-1][j]（即删除s[i-1]的话，到i-1的可能性就相当于i-2了）
        //初始化的情况下：dp[i][0]意味着s到i-1处，出现空字符的可能性，必然dp[i][0] = 1(只有一种办法，就是全部删除干净)
        //dp[0][j]代表空字符去匹配t[0:j-1]的可能性，必然为0
        //对于特殊点dp[0][0]，空字符==空字符,dp[0][0]=1

        //初始化行
        vector<vector<uint64_t>> dp(s.size()+1,vector<uint64_t>(t.size()+1,0));
        //初始化列
        for(int i=0;i<=s.size();i++)
            dp[i][0]=1;
        for(int i=1;i<=s.size();++i)
        {
            for(int j=1;j<=t.size();++j)
            {
                if(s[i-1]==t[j-1])
                    dp[i][j] = dp[i-1][j-1]+dp[i-1][j];
                else
                    dp[i][j] = dp[i-1][j];
            }
        }
        return dp[s.size()][t.size()];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

3.3 两个字符串的删除操作

LeetCode:两个字符串的删除操作
遇上一题的思路完全一致。

• 字符一样时，则不需要额外删除
• 字符不同时，选择其中一个字符删除，即选择操作数少的

class Solution {
public:
    int minDistance(string word1, string word2) {
        //Delete=L1+L2-2*L3，显然剩余部分L3最长时，Delete最小
        //dp[i][j]代表使得word1[0:i-1]和word2[0:j-1]所需的最小删除次数
        vector<vector<int>> dp(word1.size()+1,vector<int>(word2.size()+1,0));
        //初始化
        int i,j;
        //要和空字符串一致，则有多少个字符删多少个
        for(i=1;i<=word1.size();++i)dp[i][0]=i;
        for(j=1;j<=word2.size();++j)dp[0][j]=j;
        //动态规划
        for(i=1;i<=word1.size();++i)
        {
            for(j=1;j<=word2.size();++j)
            {
                //字符一样的话，就和前一位一致
                if(word1[i-1]==word2[j-1])
                    dp[i][j]=dp[i-1][j-1];
                //不一样的话，就考虑删word1或者删word2
                //不全删的原因在于，dp[i-1][j]或者dp[i][j-1]的计算过程中，已经考虑到了dp[i-1][j-1]
                else
                    dp[i][j]=1+min(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[word1.size()][word2.size()];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

3.4 编辑距离

LeetCode:编辑距离
和上一题没有本质区别，需要认识到两点。

• 删除与插入，在操作数上完全等效。
• 替换使得字符不同时，dp[i-1][j-1]到dp[i][j]的距离也仅有1（只有删除时则是2）。

class Solution {
public:
    int minDistance(string word1, string word2) {
        //dp[i][j]代表word1[0:i-1]到word2[0:j-1]的最少操作数
        //当word1[i-1]=word2[j-1]时，不需要额外操作，dp[i][j]=dp[i-1][j-1]
        //当不相等时，考虑操作替换/插入/删除
        int length1=word1.size();
        int length2=word2.size();
        int i,j;
        vector<vector<int>> dp(length1+1,vector<int>(length2+1,0));
        //初始化
        for(i=1;i<=length1;++i)
            dp[i][0]=i;
        for(j=1;j<=length2;++j)
            dp[0][j]=j;
        //递推
        for(i=1;i<=length1;++i)
        {
            for(j=1;j<=length2;++j)
            {
                if(word1[i-1]==word2[j-1])
                    dp[i][j]=dp[i-1][j-1];
                else
                    dp[i][j]=1 + min(dp[i-1][j-1] , min(dp[i-1][j], dp[i][j-1]));
            }
        }
        return dp[length1][length2];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

4 回文子序列

4.1 回文子串

LeetCode:回文子串
动态规划的思想很简单，dp[i][j]代表s[i]~s[j]是否是回文，需要注意两点：

• 遍历顺序应该是从下到上，从右到左
• j >= i应该始终保证，避免重复计算，因此只需要dp数组的上半部分（包括对角线）

另外也可以使用双指针解决，任何回文子串都可以由长度为1或长度为2的回文子串扩散得到。

思路一·动态规划

class Solution {
public:
    int countSubstrings(string s) {
        int size=s.size();
        //dp[i][j]代表s[i]~s[j]是否为回文子串，其中j>=i
        //一般情况下dp[i][j]=dp[i+1][j-1] && s[i]==s[j]，即依赖左下角的值，所以应该从下到上从左到右遍历
        vector<vector<bool>> dp(size,vector<bool>(size,false));
        int count=0;
        //从下到上
        for(int i=size-1;i>=0;--i)
        {
            //从左到右
            for(int j=i;j<size;++j)
            {
                //字符一样是大前提
                if(s[i]==s[j])
                {
                    //长度<=2
                    if(j<=i+1)
                        dp[i][j]=true;
                    //长度>=3
                    else
                        dp[i][j]=dp[i+1][j-1];
                }
                //如果回文
                if(dp[i][j])
                    ++count;
            }
        }
        return count;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

思路二·扩散+双指针

class Solution {
public:
    int diffuse(string& s,int left,int right)
    {
        int res=0;
        while(left>=0 && right<s.size() && s[left]==s[right])
        {
            ++res;
            --left;
            ++right;
        }
        return res;
    }
    int countSubstrings(string s) {
        int result=0;
        for(int i=0;i<s.size();++i)
        {
            result+=diffuse(s,i,i);
            result+=diffuse(s,i,i+1);
        }
        return result;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

4.2 最长回文子序列

LeetCode:最长回文子序列
dp[i][j]记录s[i~j]的回文子序列的最大长度。

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int size=s.size();
        int max_length=0;
        //dp[i][j]s[i~j]的回文子序列的最大长度
        vector<vector<int>> dp(size,vector<int>(size,0));
        for(int i=size-1;i>=0;i--)
        {
            for(int j=i;j<size;j++)
            {
                if(s[i]==s[j])
                {
                    //长度<=2
                    if(j-i<=1)
                        dp[i][j]=j-i+1;
                    else
                        dp[i][j]=dp[i+1][j-1]+2;
                }
                //不相等时
                else
                    dp[i][j] = max(dp[i+1][j],dp[i][j-1]);
                max_length=max(max_length,dp[i][j]);
            }
        }
        return max_length;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

5 总结

动态规划，完结撒花！另外leetcode的基础题也基本刷完一遍了，接下来要花更多的功夫学计算机基础相关知识，以及更难的一些数据结构（AVL、红黑数、B树、B+树、哈夫曼树、图等等）与算法（深入了解DFS和BFS）。
——2023.3.6