LeetCode——字符串操作相关

已于 2022-06-27 16:07:15 修改
阅读量609 收藏
点赞数
分类专栏： LeetCode 互联网学习 文章标签： 算法 leetcode 学习 c++
于 2022-03-27 22:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XUfengge111/article/details/123557909
版权

一、最长公共子序列 / 子串

1、最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。

若这两个字符串没有公共子序列，则返回 0。

#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <algorithm>

using namespace std;

//最长公共子序列
//DP
//长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]
void longestCommonSubsequence(string& s1, string& s2, int &res) {
	vector<vector<int>> dp(s1.size() + 1, vector<int>(s2.size() + 1, 0));

	for (int i = 1; i <= s1.size(); i++) {
		for (int j = 1; j <= s2.size(); j++) {
			if (s1[i - 1] == s2[j - 1]) {
				dp[i][j] = dp[i - 1][j - 1] + 1; //增加长度
			}
			else {
				dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]); //其中一个字符串少一个字母的最大值
			}
		}
	}

	res = dp[s1.size()][s2.size()];

	//return dp[s1.size() - 1][s2.size() - 1];
}

int main(int argc, char* argv[]) {
	string s1 = "";
	string s2 = "";

	getline(cin, s1);
	getline(cin, s2);

	int res = 0;
	longestCommonSubsequence(s1, s2, res);
	cout << res << endl;

	return 0;
}

2、最长公共子串

查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
注：子串的定义：将一个字符串删去前缀和后缀（也可以不删）形成的字符串。请和“子序列”的概念分开！

#include <bits/stdc++.h>

using namespace std;

//dp
//dp[i][j]表示 到s1第i个,到s2第j个为止 的公共子串长度 (其中s1较短)
void longestCommonSubsequence(string s1, string s2, string& res) {
    vector<vector<int>> dp(s1.size() + 1, vector<int>(s2.size() + 1, 0));
    int maxLength = INT_MIN, end = 0; //end表示字符串的末位位置 (最大不超过s1的长度)
    
    for(int i = 1; i <= s1.size(); i++){
        for(int j = 1; j <= s2.size(); j++){
            if(s1[i - 1] == s2[j - 1]){
                dp[i][j] = dp[i - 1][j - 1] + 1; //则增加长度
            }
            else{
                dp[i][j] = 0; // //该位置为0
            }
            
            if(dp[i][j] > maxLength){ //更新最大长度
                maxLength = dp[i][j];
                end = i - 1; //
            }
        }
    }

    res = s1.substr(end - maxLength + 1, maxLength); //
}

int main(){
    string s1 = "";
	string s2 = "";

	getline(cin, s1);
	getline(cin, s2);
    
    if(s1.length() > s2.length()){
        swap(s1, s2); //使较小的字符串在前
    } 
            
	string res = "";
	longestCommonSubsequence(s1, s2, res);
	cout << res << endl;
    
    return 0;
}

二、KMP算法

求解一个字符串m在另一个字符串s中出现的首个索引位置使用kmp算法。详细注释见代码。

#include <iostream>
#include <vector>
#include <string>
#include <fstream>

using namespace std;

//返回数组的首地址  
//nextArray的第i个值是从0 -- i-1长的字符串中 的最长相等前后缀的长度
int* getNextArray(string m) {
	int* nextArray = new int[m.size()];

	if(m.size() == 1){
		nextArray[0] = -1;//人为规定为-1
		return nextArray;
	}
	
	nextArray[0] = -1;//人为规定为-1
	nextArray[1] = 0;//人为规定为0

	int cn = 0;//cn表示哪个字符在和i - 1 位置的字符进行比较（前缀的下一个位置）；也表示当前使用的信息的长度是多少 
	for (int i = 2; i < m.size();) {
		//根据nextArray[i-1]计算nextArray[i]
		if (m[i - 1] == m[cn]) {
			/*nextArray[i] = cn + 1;
			i++;
			cn++;*/
			nextArray[i++] = ++cn;
		}
		else if (cn > 0) { //m[i - 1] != m[cn]
			cn = nextArray[cn]; //cn往前跳
		}
		else { //cn不能再往前跳
			nextArray[i++] = 0; //没有相等的前后缀 nextArray[i] = 0
		}
	}
	
	return nextArray;
}

int kmpGetIndexOf(string &s, string &m) {
	if (s.size() == NULL || m.size() == NULL || m.size() < 1 || s.size() < m.size()) {
		return -1;
	}

	int i = 0, j = 0; 
	int *nextArray = getNextArray(m);//拿到next数组
	while (i < s.size() && j < m.size()) {
		if (s[i] == m[j]) {
			i++;
			j++; //只有匹配相等j才自加 如果越界则匹配成功
		}
		else if (nextArray[j] == -1) { //else if(j == 0) //j无法再向前跳
			i++; //s的下标加1
		}
		else {
			j = nextArray[j];//j跳回到next数组中对应的位置
		}
	}

	return j == m.size() ? i - j : -1; //匹配成功返回两个指针的差值
}

//返回m在s中出现的第一个索引位置
int main(int argc, char* argv[]) {

	string s = ""; string m = "";
	char s_c, s_m;
	getline(cin, s); 
	getline(cin, m);

	int res = 0;
	res = kmpGetIndexOf(s, m);

	cout << res << endl;

	return -1;
}

三、有关字符串句子的单词反转问题

先把句子中所有字符串取出放入字符串数组，再对数组中的字符串进行操作后重新连接即可，具体问题具体细节还需要按题目要求分析
而遍历句子取字符串的思路，就是遇到字符把它放入临时字符串，遇到空格或者标点(如果有标点)，就把临时字符串输出，并且清空。
以下代码中的res即为字符串数组，求解res的过程即是模板。

#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <algorithm>

using namespace std;

void reverseWords(string& s1, string& s2) {
	s1 += ' '; //补一个空格，避免最后一个单词无法取出
	string tmp = "";//存储单个单词的临时字符串
	vector<string> res;//存储每个单词的字符串数组

	for (char ch : s1) {
		if (ch == ' ') { //如果是空格
			if (!tmp.empty()) { //如果s1的前后有空格 要这行 否则不需要
				res.push_back(tmp);
				tmp.clear();
			}
		}	
		else {//如果不是空格
			tmp += ch;
		}
	}
	//到这里 res中存储的是每个单词
	reverse(res.begin(), res.end()); //反转

	for (auto str : res) {
		s2 += str + ' '; //重新拼接为反转后的字符串句子
	}
	s2.pop_back(); //将最后一个空格推出去

	//return s2;
}

int main(int argc, char* argv[]) {
	string s1 = "";
	string s2 = "";

	getline(cin, s1);

	reverseWords(s1, s2);
	cout << s2 << endl;

	return 0;
}

四、子序列判断问题

1、判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
示例 1： 输入：s = “abc”, t = “ahbgdc” 输出：true
示例 2： 输入：s = “axc”, t = “ahbgdc” 输出：false

class Solution {
public:
//动态规划
//dp[i][j]表示s中以下标i-1为结尾的字符串 和 t中以下标j-1为结尾的字符串 相等子序列的长度
    bool isSubsequence(string s, string t) {
        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] = dp[i - 1][j - 1] + 1;
                }
                else{
                    dp[i][j] = dp[i][j - 1];//相当于t要删除元素，t如果把当前元素t[j-1]删除，那么dp[i][j] 的数值就是 看s[i-1]与 t[j-2]的比较结果了
                }
            }
        }
        //如果dp[s.size()][t.size()] 与 字符串s的长度相同说明：s与t的最长相同子序列就是s，那么s 就是 t 的子序列
        if(dp[s.size()][t.size()] == s.size()) return true;

        return false;

    }
};

2、不同的子序列

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

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

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

//dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。
class Solution {
public:
    int numDistinct(string s, string t) {
        vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1));
        for (int i = 0; i < s.size(); i++) dp[i][0] = 1;
        for (int j = 1; j < t.size(); j++) dp[0][j] = 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] = dp[i - 1][j - 1] + dp[i - 1][j];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[s.size()][t.size()];
    }
};

五、两个字符串的删除操作

给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。

示例：

输入: “sea”, “eat”
输出: 2 解释: 第一步将"sea"变为"ea"，第二步将"eat"变为"ea"

//除了最长公共子序列之外的字符都是必须删除的，最后用两个字符串的总长度减去两个最长公共子序列的长度就是删除的最少步数。
class Solution {
public:
    int minDistance(string word1, string word2) {
        vector<vector<int>> dp(word1.size()+1, vector<int>(word2.size()+1, 0));
        for (int i=1; i<=word1.size(); i++){
            for (int j=1; j<=word2.size(); j++){
                if (word1[i-1] == word2[j-1]) dp[i][j] = dp[i-1][j-1] + 1;
                else dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
        return word1.size()+word2.size()-dp[word1.size()][word2.size()]*2;
    }
};

六、有关回文串的问题

1、验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

class Solution {
public:
    bool isPalindrome(string s) {
        string sgood; //存储转换好可以进行比较的字符串
        for (char ch: s) {
            if (isalnum(ch)) { //如果是字母或者数字（排除空格）
                sgood += tolower(ch);//大写字母转换为小写字母 //方便比较
            }
        }
        //双指针  挨个字母进行比较
        int n = sgood.size();
        int left = 0, right = n - 1;
        while (left < right) {
           if (sgood[left] != sgood[right]) {
                return false;
            }
            ++left;
            --right;
        }
        return true;
    }
};

2、回文子串

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

示例 1：

输入：“abc” 输出：3 解释：三个回文子串: “a”, “b”, “c”

示例 2：

输入：“aaa” 输出：6 解释：6个回文子串: “a”, “a”, “a”, “aa”, “aa”, “aaa”

提示：

输入的字符串长度不会超过 1000 。

//dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。
class Solution {
public:
    int countSubstrings(string s) {
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));//初始化全为false
        int result = 0;
        //一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的
        for (int i = s.size() - 1; i >= 0; i--) {
            for (int j = i; j < s.size(); j++) {//j>=i 只填充dp数组的右上半部分
                if (s[i] == s[j]) {
                    if (j - i <= 1) { //必是回文子串
                        result++;
                        dp[i][j] = true;
                    } else if (dp[i + 1][j - 1]) { //[i, j]区间长度大于1
                        result++;
                        dp[i][j] = true;
                    }
                }
            }
        }
        return result;
    }
};

3、最长回文子序列

给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。

示例 1: 输入: “bbbab” 输出: 4 一个可能的最长回文子序列为 “bbbb”。

示例 2: 输入:“cbbd” 输出: 2 一个可能的最长回文子序列为 “bb”。

提示：

1 <= s.length <= 1000
s 只包含小写英文字母

//dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。
class Solution {
public:
    int longestPalindromeSubseq(string s) {
        vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
        for (int i = 0; i < s.size(); i++) dp[i][i] = 1;//一个字符的回文子序列长度就是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; //最两边相等 长度加2
                } else {
                    dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);//最两边不相等，分别加其中一个，所构成的最长回文子序列长度的最大值
                }
            }
        }
        return dp[0][s.size() - 1];
    }
};

4、最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

class Solution {
public:
//dp[i][j]表示s中[i, j]区间是否是回文子串
    string longestPalindrome(string s) {
        if(s.size() < 2) return s;

        string res = "";
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));

        for(int i = 0; i < s.size(); i++) dp[i][i] = true;//对角线
        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 < 3) dp[i][j] = true; // //2个字符-则这两个字符必相等  1个字符-也是回文子串
                    else dp[i][j] = dp[i + 1][j - 1];//区间大于2个字符 由左下角的bool类型决定（收缩区间）
                }
                
                if(dp[i][j] && (j - i + 1) > res.size()){ //取最长回文子串
                    res = s.substr(i, j - i + 1);
                }
            }          
        }

        return res;
    }
};

5、最多删除一个字符得到回文

给定一个非空字符串 s，请判断如果 最多 从字符串中删除一个字符能否得到一个回文字符串。

class Solution {
public:
    bool check(const string& s, int low, int high){
        while(low < high){
            if(s[low] != s[high]){
                return false;
            }
            low++;
            high--;
        }

        return true;
    }

    bool validPalindrome(string s) {
        int low = 0, high = s.size() - 1;
        while(low < high){
            char l = s[low], h = s[high];
            if(l == h){
                low++;
                high--;
            }
            else{
                return check(s, low, high - 1) || check(s, low + 1, high); //
            }
        }

        return true;
    }
};

七、有关字符串匹配的问题

1、剑指 Offer 48. 最长不含重复字符的子字符串

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

class Solution {
public:
//滑动窗口
    int lengthOfLongestSubstring(string s) {
        int res = 0;
        unordered_set<char> st;
        int right = 0;
        for(int i = 0; i < s.size(); i++){ //i为左边界
            if(i != 0){
                st.erase(s[i - 1]);
            }

            while(right < s.size() && st.find(s[right]) == st.end()){
                st.insert(s[right]);
                right++;
            }
            res = max(res, right - i);
        }

        return res;
    }
};

2、滑动窗口模板

滑动窗口可用于解决一些列的字符匹配问题，典型的问题包括：在字符串s 中找到一个最短的子串，使得其能覆盖到目标字符串 t。对于目标字符串 t，我们可以在字符串 s 上滑动窗口，当窗口包含 t 中的全部字符后，我们再根据题意考虑能否收缩窗口。模板如下：

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

        //哈希表：记录还需要匹配到的 各个元素 的数目 (如果m[ch] < 0说明当前ch过多，不再需要了)
        unordered_map<char, int> m; 
        for(int i = 0; i < t.size(); i++){
            m[t[i]]++;
        }

        int need = t.size(); //记录还需要匹配到的字符总数【need=0表示匹配到了】
        int start = 0, end = -1; //记录目标子串s[start, end]的起始和结尾 (res) //end = -1 --> 当for循环不执行时返回空字符串
        int minLength = s.size() + 1; //符合题意的最短子串长度【初始化为一个不可能的较大值】
        int left = 0, right = 0; //滑动窗口的左右边界

        for(; right < s.size(); right++){
            char ch = s[right]; //窗口中新加入的字符 (右边界的字符)
            if(m.find(ch) != m.end()){
                if(m[ch] > 0){ //对当前字符ch还有需求
                    need -= 1; //此时新加入窗口中的ch对need有影响
                }
                m[ch]--; //
            }

            //窗口左边界持续右移
            while(need == 0){ //need=0，当前窗口完全覆盖了t
                if(right - left + 1 < minLength){
                    minLength = right - left + 1;
                    start = left; end = right;
                }

                char ch = s[left]; //窗口中要滑出的字符
                if(m.find(ch) != m.end()){
                    if(m[ch] >= 0){ //对当前字符ch还有需求，或刚好无需求(其实此时只有=0的情况)
                        need += 1; //此时滑出窗口中的ch对need有影响
                    }
                    m[ch]++; //
                }
                left++; //窗口左边界+1
            }
        }

        return s.substr(start, end - start + 1);
    }
};

『 一招吃遍七道 』滑动窗口的应用

wrdoct
关注
专栏目录
字符串处理专题--Leetcode
Lavender-csdn的博客
09-05 175
1、49. 字母异位词分组 思路：定义一个map，key值为每个排好序的字符串，value为字符串本身，key的类型为String，value的类型为ArrayList<String>。所以以上例子的map为 map={ "aet":{"ate","eat","tea"}, "abt":{bat}, "ant":{"nat","tan"} } 以下为java代码 class Solution { public L...
Leetcode——字符串的排列(全排列)
Yawn
07-30 553
1. 题目 2. 题解 class Solution { /** 类似于 全排列2，本题使用set来去除重复元素 除了使用set去重外，还可以对数组进行排序，使用visited数组进行剪枝！ */ Set<String> res = new HashSet(); public String[] permutation(String s) { backtrack(s.toCharArray(),ne
Leetcode-字符串操作
qq_49723651的博客
01-23 606
文章目录q6 Z字形变换q14 最长公共前缀q763 划分字母区间 q6 Z字形变换 题目传送门 题解 这道题一看就是一道模拟题，找到规律做的会比较快，我看到一位大佬比较简便的做法。做法是先开一个二维数组（字符串数组），然后把相同的一行存到二维数组中的同一行中，那怎么确定同一行的下标呢？ 我们以一个V型的字符串个数为一个周期n，n就等于2 * numRows - 2, 那么这个周期中每个字符在二维数组中的下标就是min(i%n, n - i%n)。如下图所示： 最后用strings.Join函数将
leetcode刷题之字符串处理
m0_37327467的博客
02-21 278
3. Longest Substring Without Repeating Characters Given a string, find the length of the longest substring without repeating characters. Example 1: Input: “abcabcbb” Output: 3 Explanation: The answer...
LeetCode-练习之字符串处理
xlz1786734790的博客
09-07 157
LeetCode字符处理相关练习
leetcode：字符串操作
huigui65的博客
11-09 481
字符串反转 解题思路 将字符串转化为数组，用双指针分别从头部和尾部进行遍历交换。 代码实现 测试地址 class Solution { public: void reverseString(vector<char>& s) { if( s.size() > 0 ) { vector<char>::...
leetcode——字符串相乘
zaishaoyi的专栏
01-17 432
题目：给定两个以字符串形式表示的非负整数num1和num2，返回num1和num2的乘积，它们的乘积也表示为字符串形式。 示例： 输入: num1 = "2", num2 = "3" 输出: "6" 方案一： class Solution { private: // 字符 乘 字符串 string charMultiStr(string num, char c) { if (c == '1') { return num; } else if (c =...
LeetCode——字符串相加（JS实现）
Always-Learning
07-17 513
题目描述 解题思路 由于本题不让使用BigInt等将字符串转换为整数形式，所以我们必须考虑使用其他的方法。所以本题考虑采用双指针的方法。 使用两个指针分别指向数字字符串的末尾位置。 使用变量carry记录进位。 当两个记录下标的位置大于等于0，或者进位不等于零的时候都进入循环。 在循环中当使用charAt这个API获取字符串对应下标的字符，两个字符相减会变成number类型。 每次循环结束都将两个指针左移一位。 解题代码 var addStrings = function(num1, num2)
饭后小甜点leetcode——字符串模式匹配与表达式解析
Sophie1797的博客
08-24 794
文章目录模式匹配正则表达式匹配通配符匹配表达式解析字符串转换整数 (atoi)基本计算器基本计算器 II基本计算器 III逆波兰表达式求值为运算表达式设计优先级给表达式添加运算符三元表达式解析器删除注释迷你语法分析器Lisp 语法解析原子的数量 模式匹配 正则表达式匹配 给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。 ‘.’ 匹配任意单个字符 ‘...
LeetCode——字符串转换整数（Java）
墨柔千城的博客
08-18 396
文章目录字符串转换整数一、题目及要求二、题目分析三、代码分析四、完整代码五、总结 字符串转换整数 一、题目及要求 请你来实现一个 atoi 函数，使其能将字符串转换成整数。 首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。接下来的转化规则如下： 如果第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字字符组合起来，形成一个有符号整数。 假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成一个整数。 该字符串在有效的整数部分之后也可能会存在
LeetCode(五)字符串处理专题
WMXNLFD的博客
05-29 404
LeetCode 38. Count and Say 报数序列是一个整数序列，按照其中的整数的顺序进行报数，得到下一个数。其前五项如下： 1. 1 2. 11 3. 21 4. 1211 5. 111221 1 被读作 “one 1” (“一个一”) , 即 11。 11 被读作 “two 1s” (“两个一”）, 即 21。 21 被读作 “one ...
LeetCode字符串相关操作
qq_40341502的博客
06-30 1866
字符串
LeetCode刷题——字符串
weixin_53598445的博客
04-21 781
344. 反转字符串   编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。 示例一： 输入：s = ["h","e","l","l","o"] 输出：["o","l","l","e","h"] 示例二： 输入：s = ["H","a","n","n","a","h"] 输出：["h","a","n","n","a","H"] 思路：双指针。 class Solution:
Leetcode 字符串处理问题两则
彩虹糖的博客
03-05 377
每次遇到字符串相关的问题，就会出项相当多次的提交错误。总是会因为读题，手残，逻辑漏洞忽略各种特殊情况，这样的问题难度一般不是很多，关键是要考虑周到，不要漏掉情况。 394. 字符串解码 给定一个经过编码的字符串，返回它解码后的字符串。 编码规则为:k[encoded_string]，表示其中方括号内部的encoded_string正好重复k次。注意k保证为正整数。 你可以认为...
Leetcode算法题解整理之字符串处理部分
weixin_43488529的博客
11-15 171
算法题解整理之字符串处理专题 38. 外观数列 【题目描述】：给定一个正整数 n ，输出外观数列的第 n 项。 「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。你可以将其视作是由递归公式定义的数字字符串序列： 【C++代码】： class Solution { public: string countAndSay(int n) { string s = "1"; for (int i = 0; i < n - 1; i++) { string ns;
c++ 输入字符串_每日LeetCode,字符串解码
weixin_39711867的博客
11-23 100
394. 字符串解码​leetcode-cn.com给定一个经过编码的字符串，返回它解码后的字符串。编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数...
LeetCode Day 4：字符串处理
weixin_47183145的博客
07-19 112
字符串处理
Leetcode刷题总结——字符串
weixin_47883447的博客
05-27 386
一、反转字符串 二、替换空格 替换空格以后，字符串所占的长度会比原字符串多，所以我们首先需要扩充数组到每个空格替换成“%20”之后的大小。然后从后向前替换空格，（双指针法） 一个指针指向新长度的末尾，一个指针指向旧长度的末尾 之所以选择从后向前，是因为从前向后填充是O（n^2）的算法，因为每次添加元素都要将添加元素之后的所有元素向后移动。 注：很多数组填充类的问题，都可以预先给数组扩容到填充后的大小，然后再从后向前进行操作。 1）不用申请新的数组。 2）从后向前填充元素，避免了从.
s2最少删除多少字符可以成为s1的子串
z1171127310的博客
11-13 527
给定两个字符串s1和s2，问s2最少删除多少字符可以成为s1的子串？比如 s1 = "abcde"，s2 = "axbc"返回1。s2删掉'x'就是s1的子串了。
c++ kmp算法字符匹配_LeetCode笔记：字符串匹配——KMP算法
最新发布
05-12
KMP算法是一种字符串匹配算法，用于在一个文本串S内查找一个模式串P的出现位置。它的时间复杂度为O(n+m)，其中n为文本串的长度，m为模式串的长度。 KMP算法的核心思想是利用已知信息来避免不必要的字符比较。具体来说，它维护一个next数组，其中next[i]表示当第i个字符匹配失败时，下一次匹配应该从模式串的第next[i]个字符开始。 我们可以通过一个简单的例子来理解KMP算法的思想。假设文本串为S="ababababca"，模式串为P="abababca"，我们想要在S中查找P的出现位置。 首先，我们可以将P的每个前缀和后缀进行比较，得到next数组： | i | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | | --- | - | - | - | - | - | - | - | - | | P | a | b | a | b | a | b | c | a | | next| 0 | 0 | 1 | 2 | 3 | 4 | 0 | 1 | 接下来，我们从S的第一个字符开始匹配P。当S的第七个字符和P的第七个字符匹配失败时，我们可以利用next[6]=4，将P向右移动4个字符，使得P的第五个字符与S的第七个字符对齐。此时，我们可以发现P的前五个字符和S的前五个字符已经匹配成功了。因此，我们可以继续从S的第六个字符开始匹配P。 当S的第十个字符和P的第八个字符匹配失败时，我们可以利用next[7]=1，将P向右移动一个字符，使得P的第一个字符和S的第十个字符对齐。此时，我们可以发现P的前一个字符和S的第十个字符已经匹配成功了。因此，我们可以继续从S的第十一个字符开始匹配P。 最终，我们可以发现P出现在S的第二个位置。 下面是KMP算法的C++代码实现：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wrdoct

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值