LeetCode | 242.有效的字符异位词 、349. 两个数组的交集 、 202. 快乐数、1. 两数之和

242. 有效的字母异位词 - 力扣（LeetCode）

方法1：

• 对字符串 s 和 t 进行排序，然后比较排序后的结果是否相同来判断是否为字母异位词

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

        sort(s.begin(),s.end());
        sort(t.begin(),t.end());

        return s==t;
    }
};

方法2：

• 统计字符串 s 和 t 中每个字符出现的次数，然后比较次数是否一致来判断是否为字母异位词

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

        for(int i=0;i<t.length();i++){
            count[t[i]-'a']--;
        }
        
        for(int i=0;i<26;i++){
            if(count[i]!=0){
                return false;
            }
        }

        return true;
    }
};

方法3：

• 暴力解法（会超时)，比较两个字符串每个字符出现的个数

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.length()!=t.length()){
            return false;
        }
        
        for(int i=0;i<s.size();i++){
            int countS=0;
            int countT=0;

            for(int j=0;j<s.size();j++){
                if(s[i]==s[j]){
                    countS++;
                }
            }

            for(int j=0;j<t.size();j++){
                if(s[i]==t[j]){
                    countT++;
                }
            }

            if(countS!=countT){
                return false;
            }
        }

        return true;
    }
};

---

349. 两个数组的交集 - 力扣（LeetCode）

unordered_set 是 C++标准库中的一个容器，它是基于哈希表实现的。它有如下特点：

• 无序集合，存储唯一的元素。
• 元素没有特定的顺序，不能按照插入顺序或者排序顺序进行迭代。
• 查找、插入和删除操作的平均时间复杂度为O(1)。
• 不支持重复的元素。

unordered_set 的 count() 函数返回元素在集合中的个数。所以，我们可以使用`count`函数来判断元素是否存在于集合中.

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2){
        unordered_set<int> set1(nums1.begin(),nums1.end());
        unordered_set<int> set2(nums2.begin(),nums2.end());
        vector<int> result;

        for(int num:set1){
            if(set2.count(num)){
                result.push_back(num);
            }
        }
        return result;
    }
};

---

202. 快乐数 - 力扣（LeetCode）

class Solution {
public:
    bool isHappy(int n) {
        unordered_set<int> set;
        
        set.insert(n);
        int num=0;
        while(true){
            while(n!=0){
                num+=pow(n%10,2);
                n/=10;
            }
            if(num==1){
                return true;
            }
            n=num;
            num=0;
            if(set.count(n)){
                return false;
            }
            set.insert(n);
        }
        
    }
};

---

1. 两数之和 - 力扣（LeetCode）

unordered_map 是 C++标准库中的一个容器，它是基于哈希表实现的。它有如下特点：

• 无序映射，存储键值对。
• 键（key）是唯一的，值（value）可以重复。
• 元素没有特定的顺序，不能按照插入顺序或者键的排序顺序进行迭代。
• 查找、插入和删除操作的平均时间复杂度为O(1)。
• 键和值之间是一对一的映射关系，通过键可以快速查找对应的值。

在C++中，auto是一种类型推断关键字，用于自动推断变量的类型。当使用auto声明变量时，编译器会根据变量初始化的值来推断其类型。

在使用unordered_map时，可以使用auto来推断迭代器的类型，以便更方便地遍历容器中的元素。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
       unordered_map<int,int> map;
       for(int i=0;i<nums.size();i++){
           auto it=map.find((target-nums[i]));
           if(it!=map.end()){
               return {it->second,i};
           }
           map.insert(pair<int,int>(nums[i],i));
       }
       return {};
    }
};