代码随想录算法训练营第六天| 242. 有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和

242. 有效的字母异位词

题目链接：https://leetcode.cn/problems/valid-anagram/description/

文章讲解：https://programmercarl.com/0242.%E6%9C%89%E6%95%88%E7%9A%84%E5%AD%97%E6%AF%8D%E5%BC%82%E4%BD%8D%E8%AF%8D.html

视频讲解：https://www.bilibili.com/video/BV1YG411p7BA/?vd_source=5287cb6df25410935566fc8f0d951a5a

class Solution {
public:
    bool isAnagram(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++)
        {
            hash[t[i] - 'a']--;
        }

        for(int i = 0;i < 26 ;i++)
        {
            if(hash[i] != 0)
            {
                return false;
            }
        }

        return true;
    }
};

349. 两个数组的交集

题目链接：https://leetcode.cn/problems/intersection-of-two-arrays/description/

文章讲解：https://programmercarl.com/0349.%E4%B8%A4%E4%B8%AA%E6%95%B0%E7%BB%84%E7%9A%84%E4%BA%A4%E9%9B%86.html

视频讲解：https://www.bilibili.com/video/BV1ba411S7wu/

当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

set实现

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        //用于存放结果
        unordered_set <int> result;

        unordered_set <int> num_find(nums1.begin(), nums1.end());

        for(int num : nums2)
        {
            if(num_find.find(num) != num_find.end())
            {
                result.insert(num);
            }
        }

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

    }
};

数组实现

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        //用于存放结果
        unordered_set <int> result;

        int hash[1001] = {0};

        for(int i = 0; i < nums1.size() ; i++)
        {
            hash[nums1[i]] = 1;
        }

        for(int i = 0; i < nums2.size() ; i++)
        {
            if(hash[nums2[i]] == 1)
            {
                result.insert(nums2[i]);
            }
        }        

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

    }
};

202. 快乐数

题目链接：https://leetcode.cn/problems/happy-number/description/

文章讲解：https://programmercarl.com/0202.%E5%BF%AB%E4%B9%90%E6%95%B0.html

视频讲解：

出现循环就考虑快慢指针，如果存在循环，快慢指针一定会相遇。如果相等证明存在循环，如果跳出循环之后，两个指针时因为等于1相遇，则就是快乐数。

无限循环一定是因为有重复数字出现。

class Solution {
public:
    int getsum(int n )
    {
        int sum = 0;
        while(n > 0)
        {
            sum += (n % 10) * (n % 10) ;

            n = n / 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        int slow = n,fast = n;
        do
        {
            slow = getsum(slow);
            fast = getsum(getsum(fast));
        }while(slow != fast);

        return slow == 1;
    }
};

class Solution {
public:
    int getsum(int n )
    {
        int sum = 0;
        while(n > 0)
        {
            sum += (n % 10) * (n % 10) ;

            n = n / 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set <int> result;
        while(1)
        {
            int sum = getsum(n);
            if(sum == 1)
            {
                return true;
            }
            if(result.find(sum) != result.end())
            {
                return false;
            }
            result.insert(sum);
            n = sum;
        }
        
    }
};

1. 两数之和

题目链接：https://leetcode.cn/problems/two-sum/

文章讲解：https://programmercarl.com/0001.%E4%B8%A4%E6%95%B0%E4%B9%8B%E5%92%8C.html

视频讲解：https://www.bilibili.com/video/BV1aT41177mK/?vd_source=5287cb6df25410935566fc8f0d951a5a

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