【leetcode_2018高频算法题汇总-字符串】（慢慢更新）_leetcode 字符串 高频题

• 验证回文串
• 分割回文串
• 单词拆分

---

验证回文串

https://leetcode-cn.com/explore/interview/card/top-interview-quesitons-in-2018/275/string/1136/

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
说明：本题中，我们将空字符串定义为有效的回文串。
示例 1:
输入: “A man, a plan, a canal: Panama”
输出: true

思路

很简单，头尾指针从两边进行比较，略过非字母和数字的，注意一下大小写即可

代码

class Solution {
public:
    bool isPalindrome(string s) {
        if (s.empty()) {
            return true;
        }
        else {
            for (int i = 0, j = s.length()-1; i < j;){
                while(i<s.length() && !(isdigit(s[i])||isalpha(s[i]))) {
                    i++;
                }
                while(j>=0 && !(isdigit(s[j])||isalpha(s[j]))) {
                    j--;
                }
                if (i == s.length()||j < 0) {
                    return true;
                }
                else if (toupper(s[i]) != toupper(s[j])) {
                    return false;
                }
                else {
                    i++;
                    j--;
                }
            }
        }
        
        return true;
    }
};
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
28
29
30

---

分割回文串

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。

返回 s 所有可能的分割方案。

示例:

输入: “aab”
输出: [ [“aa”,“b”], [“a”,“a”,“b”] ]

思路

题目要求找出所有满足条件的情况，那么在想不到有什么捷径的情况下，就是暴力地遍历。这边采用dfs，一步步，一段段地寻找、回溯。

代码

class Solution {
public:
    bool isPalindrome(string s) {
        if (s.empty()) {
            return true;
        }
        else {
            for (int i = 0, j = s.length()-1; i < j;){
                while(i<s.length() && !(isdigit(s[i])||isalpha(s[i]))) {
                    i++;
                }
                while(j>=0 && !(isdigit(s[j])||isalpha(s[j]))) {
                    j--;
                }
                if (i == s.length()||j < 0) {
                    return true;
                }
                else if (toupper(s[i]) != toupper(s[j])) {
                    return false;
                }
                else {
                    i++;
                    j--;
                }
            }
        }

        return true;
    }
    
    void dfs(vector<vector<string>>& ans,vector<string>& path,string s,int start){
        if(start==s.length()){
            ans.push_back(path);
            return;
        }
        for(int i=start;i<s.length();i++){
            if(isPalindrome(s.substr(start,i-start+1))){
                path.push_back(s.substr(start,i-start+1));
                dfs(ans,path,s,i+1);
                path.pop_back();
            }
        }
    }
    
    vector<vector<string>> partition(string s) {
        vector<vector<string>> ans;
        if (s.length() == 0) {
            return ans;
        }
        vector<string> path;
        dfs(ans,path,s,0);
        
        return ans;
    }
};
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

---

单词拆分

给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

说明：

拆分时可以重复使用字典中的单词。 你可以假设字典中没有重复的单词。 示例 1：

输入: s = “leetcode”, wordDict = [“leet”, “code”]
输出: true
解释: 返回 true
因为 “leetcode” 可以被拆分成 “leet code”。

思路

还是暴力搜索，若单词匹配，则找后面的。

代码

但是！ 超时！！

class Solution {
public:
    
    bool dfs(string s, int start, vector<string>& wordDict) {
        for (int i = 0; start + i < s.length(); i++) {
            vector<string>::iterator it;
            if ((it=find(wordDict.begin(),wordDict.end(),s.substr(start,i+1))) != wordDict.end()) {
                // 当前单词在dict中
                
                
                if (start+i == s.length()-1) {
                    // 如果到头，返回true
                    return true;                  
                }
                else {
                    // 否则继续找下去
                    if (dfs(s, start+i+1, wordDict) == true){
                        return true;
                    }
                }
            }
        }
        return false;
    }
    
    
    bool wordBreak(string s, vector<string>& wordDict) {
        // dfs
        return dfs(s, 0, wordDict);
        
    }
};
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
28
29
30
31
32

别人解答

https://blog.csdn.net/qq_38595487/article/details/82431046
用一个boolean类型的数组flags来记录 字符串某个位置前，是否可以由字典里的某些单词拼成。

初始flags[0]=true，再从下标1开始，判断下标1之前也就是 0-0 之间是否是由字典组成的， 判断下标2之前 也就是0-1是否是由字典组成的， 然后3 ， 判断下标3，4，5，6，7……

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        int len = s.length();
 
        boolean[] flags = new boolean[len+1];
        flags[0] = true;
 
        for (int i = 1; i <= len; i++) {
            for (int j = 0; j < i; j++) {
                if (flags[j] == true && wordDict.contains(s.substring(j,i))) {
                    flags[i] = true;
                    break;
                }
            }
        }
 
        return flags[len];
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

用c++重写了一下

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        int len = s.length();
        int *flags = (int *)malloc(sizeof(int) * (len+1));
        memset(flags, 0, sizeof(int) * (len + 1));
        flags[0] = 1;
        vector<string>::iterator it;
        for (int i = 1; i <= len; i++) {
            for (int j = 0; j < i; j++) {
                if (flags[j] == true && ((it=find(wordDict.begin(),wordDict.end(),s.substr(j,i-j))) != wordDict.end())) {
                    flags[i] = true;
                    break;
                }
            }
        }

        return flags[len];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20