力扣-字符串-字符的统计

387 字符串中的第一个唯一字符

387 字符串中的第一个唯一字符

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

示例：

s = “leetcode”
返回 0
s = “loveleetcode”
返回 2

提示：你可以假定该字符串只包含小写字母。

• 时间复杂度：O(n)，其中 n 是字符串 s 的长度。我们需要进行两次遍历。
• 空间复杂度：O(∣Σ∣)，其中 Σ 是字符集，在本题中 s 只包含小写字母，因此 ∣Σ∣≤26。我们需要 O(∣Σ∣) 的空间存储哈希映射。

和出现次数有关的，不要犹豫，hash

class Solution {
public:
    int firstUniqChar(string s) {
        int hash[26] = {0};
        for (int i = 0; i < s.size(); ++i) hash[s[i] - 'a']++;
        for (int i = 0; i < s.size(); ++i) if (hash[s[i] - 'a'] == 1) return i;
        return -1;
    }
};

class Solution {
public:
    int firstUniqChar(string s) {
        int hash[26] = {0};
        for (int i = 0; i < s.size(); ++i) hash[s[i] - 'a']++;
        for (int i = 0; i < s.size(); ++i) if (hash[s[i] - 'a'] == 1) return i;
        return -1;
    }
};

389 找不同

389 找不同

给定两个字符串 s 和 t，它们只包含小写字母。
字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。
请找出在 t 中被添加的字母。

示例 1：

输入：s = “abcd”, t = “abcde”
输出：“e”
解释：‘e’ 是那个被添加的字母。

示例 2：

输入：s = “”, t = “y”
输出：“y”

示例 3：

输入：s = “a”, t = “aa”
输出：“a”

示例 4：

输入：s = “ae”, t = “aea”
输出：“a”

提示：

0 <= s.length <= 1000
t.length == s.length + 1
s 和 t 只包含小写字母

1. 计数\哈希。数组的建立比哈希表快一些。

class Solution {
public:
    char findTheDifference(string s, string t) {
        vector<int> cnt(26, 0);
        for (char ch: s) cnt[ch - 'a']++;
        for (char ch: t) {
            cnt[ch - 'a']--;
            if (cnt[ch - 'a'] < 0) return ch;
        }
        return ' ';
    }
};

class Solution {
public:
    char findTheDifference(string s, string t) {
        int hash[26] = {0};
        for (int i = 0; i < s.size(); i++) hash[s[i] - 'a']++;
        for (int i = 0; i < t.size(); i++) {
            if (hash[t[i] - 'a']) {
                hash[t[i] - 'a']--;
                continue;
            }
            return t[i];
        }
        return ' ';
    }
};

• 时间复杂度：O(N)，其中 N 为字符串的长度。
• 空间复杂度：O(∣Σ∣)，其中 Σ 是字符集，这道题中字符串只包含小写字母，∣Σ∣=26。需要使用数组对每个字符计数。

2. ASCII码求和

class Solution {
public:
    char findTheDifference(string s, string t) {
        int as = 0, at = 0;
        for (char ch: s) as += ch;
        for (char ch: t) at += ch;
        return at - as;
    }
};

• 时间复杂度：O(N)。
• 空间复杂度：O(1)。

383 赎金信

383 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

示例 1：

输入：ransomNote = “a”, magazine = “b”
输出：false

示例 2：

输入：ransomNote = “aa”, magazine = “ab”
输出：false

示例 3：

输入：ransomNote = “aa”, magazine = “aab”
输出：true

提示：

你可以假设两个字符串均只含有小写字母。

和上题一样

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        vector<int> cnt(26, 0);
        for (char ch: magazine) cnt[ch - 'a']++;
        for (char ch: ransomNote) {
            cnt[ch - 'a']--;
            if (cnt[ch - 'a'] < 0) return false;
        }
        return true;
    }
};

242 有效的字母异位词

242 有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = “anagram”, t = “nagaram”
输出: true

示例 2:

输入: s = “rat”, t = “car”
输出: false

说明:

你可以假设字符串只包含小写字母。

进阶:

如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

1. 两个哈希表

class Solution {
public:
    bool isAnagram(string s, string t) {
        unordered_map<int, int> m1, m2;
        for (char c : s) m1[c - 'a']++;
        for (char c : t) m2[c - 'a']++;
        for (int i = 0; i < 26; i++) if (m1[i] != m2[i]) return false;
        return true;
    }
};

2. 一个哈希表

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size()) return false;
        vector<int> table(26, 0);
        for (char c : s) table[c - 'a']++;
        for (char c : t) {
            table[c - 'a']--;
            if (table[c - 'a'] < 0) return false;
        }
        return true;
    }
};

• 时间复杂度：O(n)，其中 n 为 s 的长度。
• 空间复杂度：O(S)，其中 S 为字符集大小，此处 S=26。

3. 排序

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size()) return false;
        sort(s.begin(), s.end());
        sort(t.begin(), t.end());
        return s == t;
    }
};

• 时间复杂度：O(nlogn)，其中 n 为 s 的长度。排序的时间复杂度为O(nlogn)，比较两个字符串是否相等时间复杂度为 O(n)，因此总体时间复杂度为O(nlogn+n)=O(nlogn)。
• 空间复杂度：O(logn)。排序需要 O(logn) 的空间复杂度。
  注意，在某些语言（比如 Java & JavaScript）中字符串是不可变的，因此我们需要额外的 O(n) 的空间来拷贝字符串。但是我们忽略这一复杂度分析，因为：1. 这依赖于语言的细节；2. 这取决于函数的设计方式，例如，可以将函数参数类型更改为 char[]。

49 字母异位词分组

49 字母异位词分组

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]
输出:
[
[“ate”,“eat”,“tea”],
[“nat”,“tan”],
[“bat”]
]

说明：

所有输入均为小写字母。
不考虑答案输出的顺序。

1. 排序
   字符串排序，将排序之后的字符串作为哈希表的键

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        vector<vector<string>> ans;
        unordered_map<string, vector<string>> mp;
        for (string& str : strs) {
            string key = str;
            sort(key.begin(), key.end());
            mp[key].emplace_back(str); //t为单词对应的质数乘积，mp[t]则为该单词的异位词构成的vector
        }
        for (auto it = mp.begin(); it != mp.end(); ++it) ans.emplace_back(it -> second);
        return ans;        
    }
};

• 时间复杂度：O(nklogk)，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的最大长度。需要遍历 n 个字符串，对于每个字符串，需要 O(klogk) 的时间进行排序以及 O(1) 的时间更新哈希表，因此总时间复杂度是 O(nklogk)。
• 空间复杂度：O(nk)，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的的最大长度。需要用哈希表存储全部字符串。

2. 每个字母出现的次数使用字符串表示，作为哈希表的键

计数
C++ Lambda表达式的基本使用

auto arrayHash = [fn = hash<int>{}] (const array<int, 26>& arr) -> size_t                                                                                                                      
{
    return accumulate(arr.begin(), arr.end(), 0u, 
        [&](size_t acc, int num)
        {   
            return (acc << 1) ^ fn(num);
        }); 
};

（看不懂了，以后再看）

3. 质数相乘。对26个字母分别赋予对应的质数值，因为不同的质数和必定为不同的数字结果，所以可以用来作为map的key值。
   上面的题也可以

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        vector<vector<string>> ans;
        unordered_map<double, vector<string>> mp;
        double a[26] = {2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101};
        for (string& str : strs) {
            double t = 1;
            string key = str;
            for (char c : str) t *= a[c - 'a'];
            mp[t].emplace_back(str);
        }
        for (auto it = mp.begin(); it != mp.end(); ++it) ans.emplace_back(it -> second); //for (auto& it : mp) ans.emplace_back(it.second);
        return ans;        
    }
};

emplace_back 与 push_back的区别

451 根据字符出现频率排序

451 根据字符出现频率排序
给定一个字符串，请将字符串里的字符按照出现的频率降序排列。

示例 1:

输入:
“tree”
输出:
“eert”
解释:
'e’出现两次，'r’和’t’都只出现一次。
因此’e’必须出现在’r’和’t’之前。此外，"eetr"也是一个有效的答案。

示例 2:

输入:
“cccaaa”
输出:
“cccaaa”
解释:
'c’和’a’都出现三次。此外，"aaaccc"也是有效的答案。
注意"cacaca"是不正确的，因为相同的字母必须放在一起。

示例 3:

输入:
“Aabb”
输出:
“bbAa”
解释:
此外，"bbaA"也是一个有效的答案，但"Aabb"是不正确的。
注意’A’和’a’被认为是两种不同的字符。

字符的统计 这部分 还有一些题没做

423
657
551
696
467
535

前面的题目私密转公开了，已发博客的做题顺序参考 网址

后面不学了。清空草稿箱。

else

五周年快乐