18.哀家要长脑子了！-CSDN博客

本文链接：https://blog.csdn.net/m0_73072282/article/details/138292744

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

用一个flag数组，s出现的加！ t出现的减！这样s和t中每个字符出现的次数相同的话，就会加多少减多少，flag数组的元素值都会是0

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

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

使用set

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> res;
        unordered_set<int> s(nums1.begin(), nums1.end());
        
        for(int num: nums2){
            if(s.find(num) != s.end()){
                res.insert(num);
            } 
        }
        return vector<int>(res.begin(), res.end());
    }
};

使用标记数组

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> res;
        int flag[1005] = {0};
        for(int num: nums1){
            flag[num] = 1;
        }
        for(int num : nums2){
            if(flag[num] != 0){
                res.insert(num);

            }
        }
        return vector<int>(res.begin(), res.end());
    }
};

哎呀，其实我觉得这两个没有本质的区别，只是表现方式换了而已

使用标记数组的话，先遍历一边nums1数组，把num1数组中有的元素标记为1，再遍历一遍nums2数组，nums2数组的元素作为flag数组的下标，如果此时元素值不为0，说明该元素（下标）在nums1中出现，可不就是交集吗

使用set的话，先把nums1数组中不同的的元素放到set里面，再遍历一遍nums2。

// 如果在s中没有找到num就会返回set中最后一个元素（end迭代器）

s.find(num) != s.end()

如果不等于说明找到了，也是交集啦

一天不写题，别人不知道，自己知道啊

3.202. 快乐数 - 力扣（LeetCode）

在这个循环判断的过程中，如果一个结果出现了两次说明它陷入了死循环，不是快乐数。需要判断一个数字是否出现过，就用set辣

至于为什么会陷入循环。。。

class Solution {
    int getSum(int n){
        int sum = 0;
        while(n){
            int x = n % 10;
            sum += x * x;
            n /= 10;
        }
        return sum;
    }
public:
    bool isHappy(int n) {
        unordered_set<int> s;
        while(1){
            int res = getSum(n); 
            if(res == 1){
                return true;
            }
            //如果找到了就不会返回集合末尾的迭代器
            if(s.find(res) != s.end()){
                return false;
            }
            else{
            s.insert(res);
            }
            n = res;
        }
    }
};

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

像我一想到的就是暴力双指针咯

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_set<int> s;
        vector<int> res;
        for(int i = 0; i < nums.size(); i++){
            // 怎么个顺序 j=i+1啊
            for(int j = i + 1; j < nums.size(); j++){
                if(target == nums[i] + nums[j]){
                   res.push_back(i);
                   res.push_back(j);
                }
            }
        }
        return res;
    }
};

哈希哈希：对每个元素nums[i] 寻找对应的能组成target的值，即在map中寻找target-nums[i]元素是否存在，如果找到了就不会返回末尾迭代器，iter->second是之前元素的索引，i是当前元素的索引，按顺序来。如果没找到就把这对元素与索引加入map，告知已经出出现过，并参加下一次的查找匹配。

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 iter = map.find(target - nums[i]);
            if(iter != map.end()){
                return { iter->second, i};
            }
            // 如果没找到
           map.insert(pair<int, int>(nums[i], i));
        }
        return {};
    }
};

5.454. 四数相加 II - 力扣（LeetCode）

两两分组，然后用哈希表查找对应相加为0的元素

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> umap;
        for(int a : nums1){
            for(int b : nums2){
                umap[a+b]++;
            }
        }
        int count = 0;
        for(int c : nums3){
            for(int d : nums4){
                // a+b = -(c+d)
                if(umap.find(0 - (c+d)) != umap.end()){
                // 如果找到了相应的-(c+d) 那么就有相应个a+b 就有这么多的组合
                    count += umap[0 - (c+d)];
                }
            }
        }
        return count;
    }
};