leetcode字符串专题

151.翻转字符串里的单词

class Solution
{
public:
    string reverseWords(string s)
    {
        reverse(s.begin(), s.end());
        int size = (int)s.size();
        int start = 0; //每个单词开始
        int end = 0;   //每个单词末尾
        int index = 0; //要返回的字符串下标
        for (; start < size; start++)
        {
            if (s[start] == ' ')
                continue; //开头空格，跳过
            if (index != 0)
            {
                //第二个单词开始 开头需要插一个空格
                s[index++] = ' ';
            }
            end = start;
            //替换原来的s 一直到空格为止
            while (end < size && s[end] != ' ')
            {
                s[index++] = s[end++];
            }
            //index/end指向了单词末尾的 下一个字符
            //一个单词的长度
            int len = end - start;
            //index - len就是单词开始的地方
            //s.begin() + index - len 单词开始的位置
            //s.begin() + index 单词结束的位置
            reverse(s.begin() + index - len, s.begin() + index);
            //更新下一个单词的开始位置 start正好指向了空格的位置
            start = end;
            //这一轮循环结束 之后 start++
            //如果只有一个空格 start正好 指向了下一个单词的开始位置
            //如果有多个空格，则指向了下一个空格 下次循环开头会跳过
        }
        //去除末尾的空格和没有用的字符
        s.erase(s.begin() + index, s.end());
        return s;
    }
};

394.字符串解码

递归法

class Solution {
public:
    string analysis(string s, int& index) {
        string res;
        int num = 0;
        string temp;
        while (index < s.size()) {
            //遇到数字
            if (s[index] >= '0' && s[index] <= '9') {
                num = 10 * num + s[index] - '0';//处理数字超过1位的情况
            }
            //遇到[
            else if (s[index] == '[') {
                temp = analysis(s, ++index);//碰到'[',开始递归         
                while(num){
                    res += temp;
                    --num;//最后num=0(累加字符串num次)
                }      
            }
            //遇到]
            else if (s[index] == ']') break;//碰到']',结束递归
            //遇到字母
            else res += s[index];
            //下标+1
            index++;
        }
        return res;
    }
    string decodeString(string s) {
        int index = 0;
        return analysis(s, index);
    }
};

97.交替字符串

思路

class Solution {
public:
	bool isInterleave(string s1, string s2, string s3) {
		int n1 = s1.size();
		int n2 = s2.size();
		int n3 = s3.size();
		if (n1 + n2 != n3)
			return false;
		vector<vector<bool>>dp(n1 + 1, vector<bool>(n2 + 1,false));
		
		//边界条件设置
		dp[0][0] = true;
		for (int i = 1; i < n1 + 1; i++) {
			dp[i][0] = s3[i - 1] == s1[i - 1];
			if (!dp[i][0])
				break;
		}
		for (int i = 1; i < n2 + 1; i++) {
			dp[0][i] = s3[i - 1] == s2[i - 1];
			if (!dp[0][i])
				break;
		}

		for (int i = 1; i < n1 + 1; i++) {
			for (int j = 1; j < n2 + 1; j++) {
				//根据上一步以及当前字符是否相匹配来判断
				dp[i][j] = (dp[i - 1][j] && s3[i + j - 1] == s1[i - 1] || dp[i][j - 1] && s3[i + j - 1] == s2[j - 1]);
			}
		}
		return dp[n1][n2];
	}
};

459.重复的子字符串

思路:

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        return (s+s).find(s, 1) != s.size();//s+s中搜索s，从下标为1的字符开始搜索，返回匹配字符串的第一个字符下标
    }
};