前言

        欢迎大家积极在评论区留言发表自己的看法，知无不言，言无不尽，养成每天刷题的习惯，也可以自己发布优质的解题报告，供社区一同鉴赏，吸引一波自己的核心粉丝。
        今天是七月集训第二天：字符串🔥

一、练习题目

        2315. 统计星号
        459. 重复的子字符串
        1790. 仅执行一次字符串交换能否使两个字符串相等
        1961. 检查字符串是否为数组前缀

二、算法思路

• 1、2315. 统计星号：🔥简单遍历，加条件判断。
• 2、459. 重复的子字符串：🔥这题一般会用KMP去做，但我不是很会，我想了一下题解根据题解的思路来的。
• 3、1790. 仅执行一次字符串交换能否使两个字符串相等：🔥遍历加条件判断。
• 4、1961. 检查字符串是否为数组前缀：🔥遍历加条件判断。

三、源码剖析

// 2315. 统计星号
class Solution {
public:
    int countAsterisks(string s) {
        int n = s.length();
        int ans = 0, cnt = 0;
        for(int i = 0; i < n; ++i) {
            if(s[i] == '|') { //(1)
                cnt++;
            }
            if(cnt % 2 == 0 && s[i] == '*') { //(2)
                ans++;
            }
        }
        return ans;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 1、统计|出现的个数；
• 2、|出现偶数次了说明凑成了一对了已经，去遍历*的个数即可。

// 459. 重复的子字符串
class Solution {
    bool isSpilt(const string& s, int len) {
        int n = s.size();
        int cnt = n / len;
        for(int i = 0; i < cnt; ++i) { //(2)
            for(int j = 0; j < len; ++j) {
                if(s[i*len + j] != s[j]) {
                    return false;
                }
            }
        }
        return true;
    }
public:
    bool repeatedSubstringPattern(string s) {
        int n = s.size();
        for(int i = 1; i < n; ++i) {
            if(n % i == 0) { //(1)
                if(isSpilt(s, i)) {
                    return true;
                }
            }
        }
        return false;
    }
};
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

• 1、枚举字符串长度的因子，比如4的因子有1, 2，将字符串分割成因子段数去判断；
• 2、举个例子abab，先分成1个，遍历到b的时候就会发现a != b显然不能这么分，当分成2个一组的时候，再去遍历就发现是可以满足的，也就是说abab可以由ab组成。

// 1790. 仅执行一次字符串交换能否使两个字符串相等
class Solution {
public:
    bool areAlmostEqual(string s1, string s2) {
        if(s1.length() != s2.length()) {
            return false;
        } //(1)
        vector<int> pos;
        for(int i = 0; i < s1.size(); ++i) {
            if(s1[i] != s2[i]) {
                pos.push_back(i); //(2)
            }
        }
        if(pos.size() == 0) {
            return true;
        }
        if(pos.size() == 2) {
            swap(s1[pos[0]], s1[pos[1]]);
            return s1 == s2;
        }
        return false; //(3)
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• 1、分情况讨论，第一个情况是不是长度相等；
• 2、第二个情况，长度相等了，统计字符不相同的位置个数，如果没有说明就是同一个字符串当然是true；如果不同的个数是两个，我们再继续，因为题目要求最多一次交换，只能最多有两个地方的字符不同才能满足，我们交换一下s1字符串的这个两位置后看看s1是否等于s2。
• 3、其他情况返回false。

// 1961. 检查字符串是否为数组前缀
class Solution {
public:
    bool isPrefixString(string s, vector<string>& words) {
        int n = s.size(), i = 0;
        for(const string word : words) {
            for(const char ch : word) {
                if(i < n && s[i] == ch) {/(1)
                    ++i;
                } else {
                    return false;
                }
            }
            if(i == n) { //(2)
                return true;
            }
        }
        return false;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

• 1、在words逐个字符串的每个字符和s去匹配，如果i没有超过s的长度，同时s中的字符和words中字符串的字符相等则i++;否则的话就是i都超过了s长度了你还没匹配成功或者s中的字符和words中字符串字符根本不相同没法匹配，返回false；
• 2、如果i和s长度相同说明s可以由words中字符串的某一段组成。