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

Leetcode 242.有效的字母异位词
思路分析：
本人直观的思路是用unordered_map统计字符串s/t中每个字符出现的次数，然后看s和t中每个字符出现的次数是否相等（方法1）。
参考《代码随想录》可以发现用数组即可完成，而且十分简洁（方法2）。
代码实现：
方法1：使用unordered_map

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size())
            return false;
        bool result = false;
        int same_times = 0;
        unordered_map<char,int> u_map_s;
        unordered_map<char,int> u_map_t;
        for (int i=0;i<s.size();i++) {
            if (u_map_s.count(s[i])) {
                u_map_s[s[i]]++;
            } else {
                u_map_s[s[i]] = 1;   
            }

            if (u_map_t.count(t[i])) {
                u_map_t[t[i]]++;
            } else {
                u_map_t[t[i]] = 1;   
            }
        }

        for (auto ch:s) {
            if (u_map_s[ch] == u_map_t[ch]) {
                same_times++;
            }
        }
        if (same_times == s.size()) {
            return true;
        } else {
            return false;
        }
    }
};

方法2：使用数组

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']++;
        }
        for (int i = 0; i < t.size(); i++) {
            record[t[i] - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
            if (record[i] != 0) {
                return false;
            }
        }
        return true;
    }
};

Leetcode 349. 两个数组的交集
思路分析：
可先用unordered_set保存num1的值，然后很方便的看num2中的各元素是否在num1的unordered_set出现。同时需要注意输出结果中的每个元素一定是 唯一 的，因此另另一个unordered_set来看输出结果中的元素是否重复，把同时存在于num1且不重复的元素输出到结果数组result中。
代码实现：

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

Leetcode 202. 快乐数
思路分析：
各个位置的数字的平方和可以想到用取余的乘积形式，如果和等于1，则说明该数为快乐数。其中一个重点是如何判断该过程是无限循环的，参考《代码随想录》，可以看sum是否之前出现过。用unordered_set保存sum的值，可以较快判断是否sum是否重复。

代码实现：

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> u_set;
        int sum = 0;
        while (true) {
            sum = getSum(n);
            if (sum == 1) {
                return true;
            }
            if (u_set.count(sum)) {
                return false;
            } else {
                u_set.insert(sum);
            }
            n = sum;
        }
    }
};

Leetcode 1. 两数之和
思路分析：
直观解法用两层for循环遍历，直到找到和为target的两个数（方法1）。
参考《代码随想录》，可用unordered_map来保存已遍历过的元素及其下标，然后在unordered_map中查找target - nums[i]是否存在，若存在，则找到和为target的两个数，否则把该元素及其下标存放到unordered_map中（方法2）。

代码实现：
方法1：暴力法

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res;
        for (int i=0;i<nums.size();i++) {
            for (int j=i+1;j<nums.size();j++) {
                if (nums[i] + nums[j] == target) {
                    res.push_back(i);
                    res.push_back(j);
                    break;
                }
            }
        }
        return res;
    }
};

方法2：哈希表

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