242. 有效的字母异位词

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

注意： 若 s 和 t **中每个字符出现的次数都相同，则称 s 和 t **互为字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

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

349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

  示例 1：

输入： nums1 = [1,2,2,1], nums2 = [2,2]
输出： [2]

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end()); // 把nums1存到
        for (int num : nums2) {
            //若find没有找到，则find返回尾后迭代器.end()
            if (nums_set.find(num) != nums_set.end()) { 
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

202.快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

输入： n = 19
输出： true
解释： 12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

其实就是提前一个整数的每一位

class Solution {
public:

    // 一次每个位置上的数字的平方和
    int getnSum(int nin) {
        int nyu = 0, nout = 0;
        while (nin) {
            nyu = nin % 10;
            nout += (nyu * nyu);
            nin = nin / 10;
        }
        return nout;
    }

    bool isHappy(int n) {
        unordered_set<int> recodesum;
        int nsum = n;
        while (nsum != 1) {
            nsum = getnSum(nsum);
            if (recodesum.find(nsum) == recodesum.end()) recodesum.insert(nsum);
            else return false ;
        }
        return true;
    }
};

454. 四数相加 II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1：

输入： nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出： 2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int outnum = 0, tempsum = 0;
        // int i1, i2, i3, i4;
        unordered_map<int, int> num_12;
        for (int i1 : nums1){
            for (int i2 : nums2) {
                num_12[i1 + i2]++;
            }
        }
        // nums1 + nums2 + nums3 + nums4 = 0
        // nums1 + nums2 = 0 - (nums3 + nums4)
        for (int i3 : nums3){
            for (int i4 : nums4) {
                if (num_12.find(0 - (i3 + i4)) != num_12.end()) {
                    outnum += num_12[0 - (i3 + i4)];
                }
            }
        }
        return outnum;

    }
};

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：

输入： ransomNote = "a", magazine = "b"
输出： false

示例 2：

输入： ransomNote = "aa", magazine = "aab"
输出： true

class Solution { // 通过了 方法1
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char, int> allmagazine; // 错误1：得是char，不能是string，因为magazine[i]的返回值是char，就是'a'，'b'这种，并不是"a"，"b"这种
        for (int i = 0; i < magazine.size(); i++) {
            allmagazine[magazine[i]]++;
        }
        for (int i = 0; i < ransomNote.size(); i++) {
            allmagazine[ransomNote[i]]--;
            if (allmagazine[ransomNote[i]] < 0) {
                return false;
            }
        }
        return true;
    }
};

// 注意：magazine 中的每个字符只能在 ransomNote 中使用一次。
class Solution { // 通过了 方法2
public:
    bool canConstruct(string ransomNote, string magazine) {
        vector<int> recode_az(26, 0);
        for (int i = 0; i < magazine.size(); i++) {
            // 为什么recode_az[magazine[i] - "a"]++;会报错呢
            recode_az[magazine[i] - 'a']++;
        }
        for (int i = 0; i < ransomNote.size(); i++) {
            recode_az[ransomNote[i] - 'a']--;
            if (recode_az[ransomNote[i] - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }
};

15. 三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

注意： 答案中不可以包含重复的三元组。

示例 1：

输入： nums = [-1,0,1,2,-1,-4]
输出： [[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

这个难在要输出不重复的值，默写的一边，重点复习

class Solution { // 这个不重复的三元组好难
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        // 排序后的三指针法 这个方法蛮清晰
        vector<vector<int>> outall;
        sort(nums.begin(), nums.end());
        vector<int> recodeiilr;

        for (int i = 0; i < nums.size() - 1; i++) {
            if (nums[i] > 0) return outall;
            // while ((nums[i] == nums[i + 1]) && (i < nums.size() - 1)) i++;
            // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1]) continue; //现在和未来的一样，直接到未来 但是现在的-1,-1,2就漏掉了
            */
            // 正确去重a方法 这样不会漏掉-1,-1,2 真聪明
            if (i > 0 && nums[i] == nums[i - 1]) continue;//现在和过去的一样，直接到未来
            
            int left = i + 1, right = nums.size() - 1;

            while (left < right) {
                if (nums[i] + nums[left] + nums[right] < 0) left++;
                else if (nums[i] + nums[left] + nums[right] > 0) right--;
                else {
                    outall.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    // if (nums[i] == nums[i + 1]) { //记录重复的位置
                    // //这样也不行，不能创建一个recodeiilr，记录重复位置
                    // }
                    while (left < right && nums[left] == nums[left + 1] ) left++;
                    while (left < right && nums[right] == nums[right - 1]) right--;
                    left++;
                    right--;
                }
                
            }
            
        }
        
        return outall;
    }
};

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n
• a、b、c 和 d 互不相同
• nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

  示例 1：

输入： nums = [1,0,-1,0,-2,2], target = 0
输出： [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

这个相当于三数之和plus，注意范围，int范围不够的话要换为int，就是纯对着答案写了一边，重点复习

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> outall;
        sort(nums.begin(), nums.end());

        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] > target && nums[i] >= 0) return outall;
            if (i > 0 && nums[i] == nums[i - 1]) continue;

            for (int j = i + 1; j < nums.size(); j++) {
                if (nums[i] + nums[j] > target && nums[i] + nums[j] >= 0) break;
                if (j > i + 1 && nums[j] == nums[j - 1]) continue;
                
                int left = j + 1, right = nums.size() - 1;

                while (left < right) {
                    // [0,0,0,1000000000,1000000000,1000000000,1000000000] 超出范围 需要加long
                    // int是4字节，范围是-2147483648~2147483647
                    if ((long) nums[i] + nums[j] + nums[left] + nums[right] < target) left++;
                    else if ((long) nums[i] + nums[j] + nums[left] + nums[right] > target) right--;
                    else {
                        outall.push_back(vector<int> {nums[i], nums[j], nums[left], nums[right]});
                        while (left < right && nums[left] == nums[left + 1] ) left++;
                        while (left < right && nums[right] == nums[right - 1]) right--;
                        left++;
                        right--;
                    }
                }
            }
        }
        return outall;
    }
};