2月9日学习总结

判断子序列

题目描述

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

进阶：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

致谢：

特别感谢 @pbrother 添加此问题并且创建所有测试用例。

示例 1：

输入：s = "abc", t = "ahbgdc"

输出：true

示例 2：

输入：s = "axc", t = "ahbgdc"

输出：false

提示：

• 0 <= s.length <= 100

• 0 <= t.length <= 10^4

• 两个字符串都只由小写字符组成。

思路1：

利用双指针分别指向俩字符串，相等就都往后走，不相等就只走主字符串的那个，最后判断j的位置即可，达到了n则说明遍历完了子序列

class Solution {
public:
    bool isSubsequence(string s, string t) 
    {
        int n=s.size();
        int m=t.size(),i=0,j=0;
        while(i<n&&j<m)
        {
            if(s[i]==t[j])
            {
                i++;
            }
            j++;
        }
        return i==n;
    }
};

思路2：

dp

第一步确定dp数组的含义dp[i][j]表示s[i-1]和t[i-1]的相同子序列的长度.

第二步找递推公式：

if(s[i-1]==t[j-1])dp[i][j]=dp[i-1][j-1]+1;

else dp[i][j]=dp[i][j-1];

第三步初始化，全部初始为0即可

class Solution {
public:
    bool isSubsequence(string s, string t) 
    {
        int n=s.size();
        int m=t.size();
        int dp[105][10005]={0};
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;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[n][m]==n;
    }
};

不同的子序列

题目描述

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

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

题目数据保证答案符合 32 位带符号整数范围。

示例 1：

输入：s = "rabbbit", t = "rabbit"输出：3
解释：
如下图所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
rabbbitrabbbitrabbbit

示例 2：

输入：s = "babgbag", t = "bag"
输出：5
解释：
如下图所示, 有 5 种可以从 s 中得到 "bag" 的方案。 
babgbagbabgbagbabgbagbabgbagbabgbag

提示：

• 0 <= s.length, t.length <= 1000

• s 和 t 由英文字母组成

思路：dp

第一步先确定dp数组的含义:dp[i][j]代表以i-1为结尾的s子序列中出现以j-1为结尾的t的个数。

第二步找状态转移方程:

if(s[i-1]==t[j-1])dp[i][j]=dp[i][j]+dp[i][j-1]

else dp[i][j]=dp[i][j-1];

第三步初始化：这里初始化要分析好dp[0][0]=1;空串的字序列也是空串所以为1

class Solution 
{
public:
    int numDistinct(string s, string t) 
    {
        int n=s.size();
        typedef unsigned long long ll;
        ll dp[1005][1005]={0};
        int m=t.size();
        for(int i=0;i<=n;i++) dp[0][i]=1;
        for(int i=0;i<=m;i++) dp[i][0]=0;
        dp[0][0]=1;
        for(int i=1;i<=m;i++)//s
        {
            for(int j=1;j<=n;j++)//t
            {
                if(s[j-1]==t[i-1])
                {
                    dp[i][j]=dp[i-1][j-1]+dp[i][j-1];
                } else dp[i][j]=dp[i][j-1];
            }
        }
        return dp[m][n];
    }
};

两个字符串的删除操作

给定两个单词 word1 和 word2 ，返回使得 word1 和 word2 相同所需的最小步数。

每步 可以删除任意一个字符串中的一个字符。

示例 1：

输入: word1 = "sea", word2 = "eat"

输出: 2

解释: 第一步将 "sea" 变为 "ea" ，第二步将 "eat "变为 "ea"

示例 2:

输入：word1 = "leetcode", word2 = "etco"

输出：4

提示：

• 1 <= word1.length, word2.length <= 500

• word1 和 word2 只包含小写英文字母

思路：dp

第一步我们确定dp数组的含义：dp[i][j]：以i-1为结尾的字符串word1，和以j-1位结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。

第二步我们找递推式:

if(word1[i-1]==word[j-1])dp[i][j]=dp[i-1][j-1];

else dp[i][j]=min(dp[i-1]+1;dp[i][j-1]+1);

第三步初始化：dp[i][0]=i;dp[0][j]=j;解释：将其中一个字符串转化为空字符串也就是这个字符串的长度作为操作次数

class Solution 
{
public:
    int minDistance(string word1, string word2) 
    {
        int n=word1.size();
        int m=word2.size();
        int dp[505][505]={0};
        for(int i=0;i<=n;i++)
        {
            dp[i][0]=i;
        }
        for(int j=0;j<=m;j++)
        {
            dp[0][j]=j;
        }
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(word1[i-1]==word2[j-1])
                {
                    dp[i][j]=dp[i-1][j-1];
                }
                else 
                {
                    dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1);
                }
            }
        }
        return dp[n][m];
    }
};