代码随想录Day06| LeetCode 242.有效的字母异位词 、 349. 两个数组的交集 、 202. 快乐数、1. 两数之和

有效的字母异位词

力扣题目链接

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

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

示例 1:

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

示例 2:

输入: s = "rat", t = "car"
输出: false

提示:

• 1 <= s.length, t.length <= 5 * 104
• s 和 t 仅包含小写字母

思路

哈希法

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

首先，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。这道题中，我们要判断s中的元素是不是在t中出现，所以考虑哈希法。哈希法一般采用三种结构，分别是数组、set和map。这道题因为题目限制了数值的大小，所以采用数组。数组存储的是字母出现的次数，'a'映射到数组下标0的位置，'z'映射到数组下标25的位置。根据题意，异位词肯定长度相同，所以我们首先判断长度如果不同，那么直接返回false即可。遍历字符串，因为长度相同，所以两个字符串一起遍历，如果是异位词，那么最终他们都会抵消（也就是数组中的元素重新归0）所以只需要检查最终数组中有没有0即可判断两个字符串是否是异位词。

sort排序

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

因为两个字符串只是字母的顺序不同，个数是一样的，所以如果是异位词的话，排序后他们是一样的，否则就是不一样的。

两个数组的交集

力扣题目链接

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

示例 1：

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

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

提示：

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 1000

思路

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

这道题在力扣改了数据之后，其实可以用数组来做，假如没有"1 <= nums1.length, nums2.length <= 1000"这个限制，那么就应该用set，因为长度可能会很长。 首先，我们要将nums1放入unordered_set集合中，这样还可以去重。然后遍历nums2，判断其中的元素在不在集合中，在的话就是交集，然后将其放入结果中。

关于在这个代码中的第一次见的，总结如下：

• unordered_set可以在创建的时候利用begin和end将一个另一个容器放入其中
• 这个题中的find是unordered_set的成员函数，并不是std::find，这个成员函数如果找到了目标值，返回指向匹配的第一个元素的迭代器。std::find的语法是find（start,end,value）
  start搜寻的起点，end搜寻的终点，要寻找的value值; 如果没有找到，则返回end。函数的返回值为迭代器或指针，就是位置信息。
• insert函数也是成员函数，作用是向容器中添加新元素。
• return vector<int>(result_set.begin(), result_set.end());这行代码是用来将unordered_set容器转化为vector容器。这种方法适用于所有标准库容器，将一个容器中的元素复制到另一个容器中时。这种情况下，可以使用迭代器的范围构造函数来构造新的容器，从而实现元素的复制。

快乐数

力扣题目链接

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

「快乐数」 定义为：

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

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

示例 1：

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

示例 2：

输入：n = 2
输出：false

思路

哈希法

class Solution {
public:
    int getSum(int n){
        int sum = 0;
        while(n){
            int tmp = n % 10;
            sum += tmp * tmp;
            n /= 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> set;
        while(1){
            int sum = getSum(n);
            if(sum == 1){
                return true;
            }
            //先判断在不在集合，在的话说明循环了，就返回false，不在的话就放入，继续循环
            if(set.find(sum) != set.end()){
                return false;
            }
            else {
                set.insert(sum);
            }
            n = sum;
        }

    }
};

首先，判断一个数是不是快乐数，是无法确定循环多少轮的，尤其还可能无限循环。在循环内只有两种情况，一种是和最终变成了1，另一种是陷入了无限循环，也就是sum重复出现了，1好判断，一个if就可以，那么循环如何判断呢？循环，就说明sum变成了之前的运算过的数，比如sum = 123，但是经过若干轮又变回了123。所以，我们可以采用哈希法，将每一轮的sum存入set集合，判断新的sum是否在集合中出现过就可以了。 第一轮的时候，set 中没有任何值，因此 set.find(sum) 操作实际上会返回 set.end()。

快慢指针法

class Solution {
public:
    int getSum(int n){
        int sum = 0;
        while(n){
            int tmp = n % 10;
            sum += tmp * tmp;
            n /= 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        int slow = n;
        int fast = n;
        do{
            slow = getSum(slow);
            fast = getSum(fast);
            fast = getSum(fast);
        }while(slow != fast);
        return fast == 1;
    }
};

快慢指针从n开始，快指针一次走两步，慢指针一次走一步。快指针向前走，假如有循环的话，那么快指针就会一直在循环内，然后慢指针会追上来，也进入循环，然后快指针比慢指针速度快一步，就相当于以一步的速度去追慢指针，一定可以相遇。如果循环到最后是1的话，那么快慢指针最终也会相等。最后返回值是判断快指针（或者慢指针）是否 == 1，等于就是快乐数，不等于就不是。

两数之和

力扣题目链接

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

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

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

思路

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

暴力解法在这里不做讨论。我们来看优化的哈希表解法，首先，为什么会想到用哈希表？因为我们需要在一个集合内找到与当前遍历的元素匹配的（也就是加起来 == target）。集合内存储我们遍历过的元素，然后遍历当前元素时，查找 target - nums[i]是否在map中。为什么用map不用set呢？因为这个题涉及下标以及对应下标的元素，所以用键值对也就是map存储比较好，同时因为unordered_map查询效率比较好，所以用 unordered_map ，同时因为我们查找的是值是否匹配，而非下标，所以值用来做key，下标做value。至于在题目中为什么用second，在std::unordered_map中，每个元素都是一个键值对，所以当你使用std::unordered_map时，实际上是在使用std::pair的对象作为元素的类型。因此，当你访问std::unordered_map中的元素时，你可以使用iter->first来获取键，使用iter->second来获取值，其中iter是指向std::unordered_map中的元素的迭代器。