【LeetCode】字符串精选9题

已于 2024-01-31 22:07:23 修改
阅读量844 收藏 21
点赞数 22
分类专栏： LeetCode精选算法题 文章标签： 算法 leetcode
于 2024-01-19 14:06:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qiuhan_909/article/details/134863477
版权

目录

基础题：

1. 最长公共前缀（简单）

滑动窗口：

1. 无重复字符的最长子串（中等）

2. 找到字符串中所有字母异位词（中等）

3. 串联所有单词的子串（困难）

4. 最小覆盖子串（困难）

回文串：

1. 验证回文串（简单）

2. 验证回文串 II（简单）

3. 回文子串（中等）

4. 最长回文子串（中等）

基础题：

1. 最长公共前缀（简单）

方法一：横向扫描

依次遍历字符串数组中的每个字符串，对于每个遍历到的字符串，更新最长公共前缀，当遍历完所有的字符串以后，即可得到字符串数组中的最长公共前缀。

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        string ans = strs[0];
        for (int i = 1; i < strs.size(); i++)
        {
            ans = findCommon(ans, strs[i]);
        }
        return ans;
    }

private:
    string findCommon(string& s1, string& s2)
    {
        int i = 0;
        while (i < min(s1.size(), s2.size()) && s1[i] == s2[i])
        {
            i++;
        }
        return s1.substr(0, i);
    }
};

方法二：纵向扫描

纵向扫描时，从前往后遍历所有字符串的每一列，比较相同列上的字符是否相同，如果相同则继续对下一列进行比较，如果不相同则当前列不再属于公共前缀，当前列之前的部分为最长公共前缀。

class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        for (int j = 0; j < strs[0].size(); j++) // j表示列
        {
            char ch = strs[0][j];
            for (int i = 0; i < strs.size(); i++) // i表示行
            {
                if (j == strs[i].size() || strs[i][j] != ch)
                    return strs[0].substr(0, j);
            }
        }
        return strs[0];
    }
};

滑动窗口：

1. 无重复字符的最长子串（中等）

用滑动窗口定位子串，用哈希表记录子串中每个字符出现的次数。

进窗口后判断窗口中有没有重复字符，如果已经有重复字符了，要出窗口，直到没有重复字符。这时就找到了没有重复字符的子串，更新结果。

class Solution {
public:
    int lengthOfLongestSubstring(string s) {        
        int n = s.size();
        int ans = 0;
        int left = 0;
        int right = 0;
        vector<int> hash(256, 0); // 下标表示ASCII码值
        while (right < n)
        {
            // 进窗口
            hash[s[right]]++;
            // 判断窗口中有没有重复字符
            while (hash[s[right]] > 1 && left <= right)
            {
                // 出窗口
                hash[s[left]]--;
                left++;
            }
            // 更新结果
            ans = max(ans, right - left + 1);
            // 更新右边界
            right++;
        }
        return ans;
    }
};

2. 找到字符串中所有字母异位词（中等）

字母异位词：

  • 长度相等
  • 每个字母出现的次数相等（可以用哈希表记录字符串中每个字母出现的次数）

暴力解法

用固定的p.size()大小的窗口定位s的子串，逐个扫描子串中的字母，并把字母在哈希表中对应的值-1，如果子串是p的排列，哈希表中所有的值为0。

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int nS = s.size();
        int nP = p.size();
        if (nS < nP)
            return {};

        vector<int> ans;
        vector<int> hash(26, 0); // hash[0]存储'a'出现的次数，hash[1]存储'b'出现的次数……
        for (auto& ch : p)
        {
            hash[ch - 'a']++;
        }

        int left = 0;
        int right = nP - 1;
        while (right < nS)
        {
            vector<int> tmp(hash);
            for (int i = left; i <= right; i++)
            {
                tmp[s[i] - 'a']--;
            }
            if (areAllZero(tmp))
            {
                ans.push_back(left);
            }
            left++;
            right++;
        }
        return ans;
    }

private:
    bool areAllZero(vector<int>& v)
    {
        for (auto& i : v)
        {
            if (i)
                return false;
        }
        return true;
    }
};

优化

用hash1记录字符串p中每个字母出现的次数，hash2记录字符串s的窗口中每个字母出现的次数。

用count记录窗口中有效字母的个数。窗口中的某一字母，它在窗口中出现的次数不能比它在p中出现的次数多，这就是有效字母。

进窗口的同时要维护count，然后判断窗口的大小是否> p.size()，如果已经> p.size()了，要出窗口并维护count，直到窗口的大小== p.size()。这时只能说明窗口的大小是合法的，不能说明窗口定位的子串一定是p的异位词。所以，接下来要判断有效字母的个数是否== p.size()，如果相等，说明找到了字母异位词，更新结果。

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        int nS = s.size();
        int nP = p.size();
        if (nS < nP)
            return {};

        vector<int> ans;
        vector<int> hash1(26, 0); // 记录p中的字母出现的次数
        vector<int> hash2(26, 0); // 记录窗口中的字母出现的次数
        for (auto& ch : p)
        {
            hash1[ch - 'a']++;
        }

        int left = 0;
        int right = 0;
        int count = 0;
        while (right < nS)
        {
            // 进窗口+维护count
            char in = s[right];
            if (++hash2[in - 'a'] <= hash1[in - 'a']) // 判断有效字母
            {
                count++;
            }
            // 判断窗口大小是否>p.size()
            if (right - left + 1 > nP)
            {
                // 出窗口+维护count
                char out = s[left++];
                if (hash2[out - 'a']-- <= hash1[out - 'a']) // 判断有效字母
                {
                    count--;
                }
            }
            // 有效字母的个数==p.size()，说明找到了字母异位词，更新结果
            if (count == nP)
            {
                ans.push_back(left);
            }
            // 更新右边界
            right++;
        }
        return ans;
    }
};

3. 串联所有单词的子串（困难）

和“找到字符串中所有字母异位词”类似。区别在于：

  • 哈希表的key是字符串
  • 指针移动的步长是单词的长度len
  • 滑动窗口执行的次数是单词的长度len，见下图

暴力解法

用固定的words.size() * len大小的窗口定位s的子串，逐个扫描子串中的单词，并把单词在哈希表中对应的值-1，如果子串是words中的单词的排列，哈希表中所有的值为0。

暴力解法会超时，但是代码本身没有问题。

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        int nS = s.size(); // 字符串s的长度
        int nW = words.size(); // 数组words中单词的个数
        int len = words[0].size(); // 一个单词的长度
        if (nS < nW * len)
            return {};

        vector<int> ans;
        unordered_map<string, int> hash; // 记录words中单词出现的次数
        for (auto& s : words)
        {
            hash[s]++;
        }

        // 滑动窗口执行len次
        for (int i = 0; i < len; i++)
        {
            int left = i;
            int right = i + nW * len - 1;
            while (right < nS)
            {
                unordered_map<string, int> tmp(hash);
                for (int i = left; i <= right - len + 1; i += len)
                {
                    tmp[s.substr(i, len)]--;
                }
                if (areAllZero(tmp))
                {
                    ans.push_back(left);
                }
                left += len;
                right += len;
            }
        }
        return ans;
    }

private:
    bool areAllZero(unordered_map<string, int> ump)
    {
        for (auto& e : ump)
        {
            if (e.second)
                return false;
        }
        return true;
    }
};

优化

用hash1记录数组words中每个单词出现的次数，hash2记录字符串s的窗口中每个单词出现的次数。

用count记录窗口中有效单词的个数。窗口中的某一单词，它在窗口中出现的次数不能比它在words中出现的次数多，这就是有效单词。

进窗口的同时要维护count，然后判断窗口的大小是否> words.size() * len，如果已经> words.size() * len了，要出窗口并维护count，直到窗口的大小== words.size() * len。这时只能说明窗口的大小是合法的，不能说明窗口定位的子串一定是串联子串。所以，接下来要判断有效单词的个数是否== words.size()，如果相等，说明找到了串联子串，更新结果。

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        int nS = s.size(); // 字符串s的长度
        int nW = words.size(); // 数组words中单词的个数
        int len = words[0].size(); // 一个单词的长度
        if (nS < nW * len)
            return {};

        vector<int> ans;
        unordered_map<string, int> hash1; // 记录words中单词出现的次数
        for (auto& s : words)
        {
            hash1[s]++;
        }

        // 滑动窗口执行len次
        for (int i = 0; i < len; i++)
        {
            unordered_map<string, int> hash2; // 记录窗口中单词出现的次数
            int left = i;
            int right = i;
            int count = 0;
            while (right + len - 1 < nS)
            {
                // 进窗口+维护count
                string in = s.substr(right, len);
                hash2[in]++;
                if (hash1.count(in) && hash2[in] <= hash1[in]) // 判断有效单词
                {
                    count++;
                }
                // 判断窗口大小是否大于words.size()*len
                if (right + len - left > nW * len)
                {
                    // 出窗口+维护count
                    string out = s.substr(left, len);
                    if (hash1.count(out) && hash2[out] <= hash1[out]) // 判断有效单词
                    {
                        count--;
                    }
                    hash2[out]--;
                    left += len;
                }
                // 有效单词的个数==words.size()，说明找到了串联子串，更新结果
                if (count == nW)
                {
                    ans.push_back(left);
                }
                // 更新右边界
                right += len;
            }
        }
        return ans;
    }
};

4. 最小覆盖子串（困难）

暴力解法

用哈希表记录字符串t每个字符出现的次数。用滑动窗口定位s的子串，逐个扫描子串中的字符，并把字符在哈希表中对应的值-1。

如果哈希表中有值>0，说明子串没包含t的所有字符，则让右边界往右滑动，直到全部包含t的字符（哈希表中最终所有值都<=0）。

如果子串包含t的所有字符，则让左边界往右滑动，然后判断删除子串最左边的字符后是否仍然包含t的所有字符。

class Solution {
public:
    string minWindow(string s, string t) {
        int nS = s.size();
        int nT = t.size();
        if (nS < nT)
            return "";

        vector<int> hash(256, 0); // 下标表示ASCII码值
        for (auto& ch : t)
        {
            hash[ch]++;
        }

        int left = 0;
        int right = 0;
        int min = INT_MAX; // 最小子串长度
        int begin = -1; // 最小子串起始位置
        while (right < nS)
        {
            hash[s[right]]--;
            while (areAllNotMoreThanZero(hash)) // 子串包括t的所有字符
            {
                if (right - left + 1 < min)
                {
                    min = right - left + 1;
                    begin = left;
                }
                hash[s[left]]++;
                left++;
            }
            right++;
        }
        
        if (begin == -1)
            return "";
        else
            return s.substr(begin, min);
    }

private:
    bool areAllNotMoreThanZero(vector<int>& v)
    {
        for (auto& i : v)
        {
            if (i > 0)
                return false;
        }
        return true;
    }
};

优化

用hash1记录字符串t中每个字符出现的次数，hash2记录字符串s的窗口中每个字符出现的次数。

用kind记录t中的字符的种类。用count记录窗口中有效字符的种类。注意，是种类，和之前的题不一样！窗口中的某一字符，只有它在窗口中出现的次数 == 它在t中出现的次数时，才记录。

例如，

t = "ABCCC"，s = "ECDBACBCBD"

假设，红色表示的是左边界，蓝色表示的是右边界。现在正在进窗口：

ECDBACBCBD，E在窗口中出现1次，在t中出现0次

ECDBACBCBD，C在窗口中出现1次，在t中出现3次

ECDBACBCBD，D在窗口中出现1次，在t中出现0次。

ECDBACBCBD，B在窗口中出现1次，在t中出现1次，count++

ECDBACBCBD，A在窗口中出现1次，在t中出现1次，count++

ECDBACBCBD，C在窗口中出现2次，在t中出现3次

ECDBACBCBD，B在窗口中出现2次，在t中出现1次

ECDBACBCBD，C在窗口中出现3次，在t中出现3次，count++

此时窗口中有效字符的种类 == 字符串t中字符的种类，显然"ECDBACBC"涵盖了"ABCCC"的所有字符。

进窗口的同时要维护count，然后判断count是否== kind，如果相等，说明找到了覆盖子串，更新结果，然后出窗口并维护count，直到count < kind。

class Solution {
public:
    string minWindow(string s, string t) {
        int nS = s.size();
        int nT = t.size();
        if (nS < nT)
            return "";

        vector<int> hash1(256, 0); // 记录t中的字符出现的次数
        vector<int> hash2(256, 0); // 记录窗口中的字符出现的次数
        int kind = 0; // 记录t中的字符的种类
        for (auto& ch : t)
        {
            if (hash1[ch]++ == 0)
            {
                kind++;
            }
        }

        int left = 0;
        int right = 0;
        int count = 0;
        int min = INT_MAX; // 最小子串长度
        int begin = -1; // 最小子串起始位置
        while (right < nS)
        {
            // 进窗口+维护count
            char in = s[right];
            if (++hash2[in] == hash1[in])
            {
                count++;
            }
            // 判断count是否== kind
            while (count == kind)
            {
                // 找到了覆盖子串，更新结果
                if (right - left + 1 < min)
                {
                    min = right - left + 1;
                    begin = left;
                }
                // 出窗口+维护count
                char out = s[left++];
                if (hash2[out]-- == hash1[out])
                {
                    count--;
                }
            }
            right++;
        }
        
        if (begin == -1)
            return "";
        else
            return s.substr(begin, min);
    }
};

回文串：

1. 验证回文串（简单）

从两端向里逐个比较，跳过非字母数字字符，如果出现了不同的字符，则不是回文串。

class Solution {
public:
    bool isPalindrome(string s) {
        int left = 0; // 首指针
        int right = s.size() - 1; // 尾指针
        while (left < right)
        {
            while (!isalnum(s[left]) && left < right)
            {
                left++;
            }
            while (!isalnum(s[right]) && left < right)
            {
                right--;
            }
            int chLeft = tolower(s[left]);
            int chRight = tolower(s[right]);
            if (chLeft != chRight)
            {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
};

2. 验证回文串 II（简单）

从两端向里逐个比较，如果字符不相同，判断删除这两个字符的其中一个能否形成回文。

class Solution {
public:
    bool validPalindrome(string s) {
        int left = 0; // 首指针
        int right = s.size() - 1; // 尾指针
        while (left < right)
        {
            if (s[left] != s[right])
            {
                break;
            }
            left++;
            right--;
        }
        return left == s.size() / 2 || isPalindrome(s, left, right - 1) || isPalindrome(s, left + 1, right);
    }

private:
    bool isPalindrome(string s, int start, int end)
    {
        while (start < end)
        {
            if (s[start] != s[end])
            {
                return false;
            }
            start++;
            end--;
        }
        return true;
    }
};

3. 回文子串（中等）

枚举所有可能的回文中心，向两边拓展，形成回文子字符串。

回文长度是奇数，回文中心是一个字符；回文长度是偶数，回文中心是两个字符。

假设字符串长度为4，枚举所有可能的回文中心：

"abcd"

 0123

编号i回文中心左起始位置left回文中心右起始位置right
000
101
211
312
422
523
633

可以看出left = i/2，right = i/2 + i % 2，长度为n的字符串，一共有2n - 1个可能的回文中心。

class Solution {
public:
    int countSubstrings(string s) {        
        int n = s.size();
        int ans = 0;
        for (int i = 0; i < 2 * n - 1; i++)
        {
            int left = i / 2;
            int right = i / 2 + i % 2;
            while (left >= 0 && right < n && s[left] == s[right]) 
            {
                left--;
                right++;
                ans++;
            }
        }
        return ans;
    }
};

4. 最长回文子串（中等）

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        int pos = 0; // 最长回文子串的起始位置
        int len = 0; // 最长回文子串的长度
        for (int i = 0; i < 2 * n - 1; i++)
        {
            int left = i / 2;
            int right = i / 2 + i % 2;
            while (left >= 0 && right < n && s[left] == s[right]) 
            {
                left--;
                right++;
            }
            if (right - left - 1 > len)
            {
                pos = left + 1;
                len = right - left - 1;
            }
        }
        return s.substr(pos, len);
    }
};
秋秋晗晗
关注
  • 22
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode---常见字符串题型
sinat_40432588的博客
05-01 272
脑子秀逗的一道题 给定一个单词，你需要判断单词的大写使用是否正确。 我们定义，在以下情况时，单词的大写用法是正确的： 全部字母都是大写，比如"USA"。 单词中所有字母都不是大写，比如"leetcode"。 如果单词不只含有一个字母，只有首字母大写， 比如 “Google”。 否则，我们定义这个单词没有正确使用大写字母。 看着挺简单的一道题吧，然后我想到的是暴力求解-直接循环判断即可，啪啪啪写了大...
LeetCode 面试题 01.06. 字符串压缩
01-20
字符串压缩题目解题思路图解代码实现实现结果补充 面试题 01.06. 字符串压缩 题目来源：https://leetcode-cn.com/problems/compress-string-lcci 题目 字符串压缩。利用字符重复出现的次数，编写一种方法，实现...
LeetCode字符串经典题（一）
CodePanda@GPF的博客
06-04 223
LeetCode字符串题型
LeetCode：字符串（7道经典题目）
一起加油~
03-31 1906
LeetCode字符串的一些经典题目，编程语言用的是C++和Python。
leetcode 字符串题目集锦
xiangxianghehe的博客
08-26 4271
反转字符串leetcode 344 题目： 编写一个函数，其作用是将输入的字符串反转过来。 示例 1: 输入: &amp;amp;amp;quot;hello&amp;amp;amp;quot; 输出: &amp;amp;amp;quot;olleh&amp;amp;amp;quot; 示例 2: 输入: &amp;amp;amp;quot;A man, a plan, a canal: Panama&amp;amp;am
leetcode每日一题：字符串压缩
lirendada的博客
07-27 575
leetcode每日一题：字符串压缩
leetcode 字符串匹配
xiaomimi1993的博客
08-21 1435
792. Number of Matching Subsequences Given string S and a dictionary of words words, find the number of words[i] that is a subsequence of S. Example : Input: S = “abcde” words = [“a”, “bb”, “acd...
leetcode 字符串
qq_42987423的博客
02-21 7902
字符串 字符串，顾名思义就是由一些字符组成的序列，在这里数字对应的类型也是字符。 比较字符串的大小：通过字符编码的大小来进行比较 例如：存在str1，str2，从左往右比较每一个字符，只要有一个字符大，后面的字符就不需要进行遍历 str1 = ‘acd’ str2=‘abe’ str1>str2 在c++中使用string类需要包含头文件 1.string的初始值为空字符串‘\0’ 2.string的长度使用length() 3.字符串的串接可以直接使用‘+’ ...
LeetCode刷题笔记 字符串 字符串匹配
王清欢的博客
11-05 3788
28 实现 strStr() 判断一个字符串是不是另一个字符串的子字符串，并返回其位置。 输入一个母字符串和一个子字符串，输出一个整数，表示子字符串在母字符串的位置，若不存在则返回-1。 输入：haystack = “hello”, needle = “ll” 输出：2 解析： ​ 解决本题一种简单的思路是暴力匹配：首先将子串和母串左端对齐；然后逐个比较对应的字符，如果发现不匹配则将子串开始匹配位置相对于母串后移动一位，同时将比较指针回溯到子串头部；重复匹配过程，直到找到对应子串，不存在则返回 -1。
python leetcode 字符串相乘实例详解
09-20
主要介绍了python leetcode 字符串相乘的示例代码，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下
python 输入字符串生成所有有效的IP地址(LeetCode 93号题)
01-19
给定一个由数字组成的字符串，我们希望通过这个字符串得到所有有效ip地址的组合。对于一个有效的ip地址而言，它应该有4个数字组成，每一个数字的范围在0到255之间。 一个字符串可能可以转化成多个ip地址，我们需要...
Leetcode 同构字符串.php
02-21
LeetCode 205的题目是“同构字符串”（Isomorphic Strings），要求判断两个字符串是否是同构的。如果字符串s可以通过字符替换得到字符串t，那么这两个字符串是同构的。所有出现的字符都必须用另一个字符替换，同时...
牛客网刷题 | BC118 N个数之和
m0_64000959的博客
06-09 493
目前主要分为三个专栏，后续还会添加： 专栏如下： C语言刷题解析 C语言系列文章 我的成长经历感谢阅读！初来乍到，如有错误请指出，感谢！输入数字N，然后输入N个数，计算这N个数的和。第一行输入一个整数N(0≤N≤50)，第二行输入用空格分隔的N个整数。输出为一行，为第二行输入的“N个整数之和”的计算结果。使用数组的方式 先将用户输入的几个数字分别存起来定义一个变量将它数字的和加起来然后输出 代码 2 ： 输入n个数相加，应该想到循
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 404
【代码】力扣LCP 08.剧情触发时间。
LeetCode 算法：轮转数组c++
小金牛来了
06-09 683
LeetCode 算法：轮转数组c++
LSS 和 BEVDepth算法解读
最新发布
pytorch内部机制解读
06-13 931
当前BEV的研究大都基于深度学习的方法，从组织BEV特征信息的方式来看，主流方法分属两类：自底向上方法和自顶向下方法。自底向上方法比较早的代表工作是LSS，后来BEVDet、BEVDepth等也是基于LSS的框架来进行优化。自底向上方法核心是：Lift——对各相机的图像显性地估计像平面下采样后特征点的深度分布，得到包含图像特征的视锥（点云）；Splat——结合相机内外参把所有相机的视锥（点云）分配到BEV网格中，对每个栅格中的多个视锥点进行sum-pooling计算，形成BEV特征图；
(第31天)【leetcode题解】404、左叶子之和
m0_73755059的博客
06-10 312
给定二叉树的根节点 root ，返回所有左叶子之和。
312. 戳气球
qq_35085273的博客
06-09 1005
240609-1 每日一题
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 644
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
leetcode 字符串左移
01-01
例如，对于字符串"leetcode"，经过一次左移操作后，得到的字符串为"eetcodel"。这种操作可以通过多种方法来实现，其中最简单的方法是使用字符串切片和拼接的方式来实现。具体来说，可以先将字符串按照指定的左移位数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值