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

Leetcode 242.有效的字母异位词

初见想法：使用hashmap_map保存s, 再遍历t

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size()) return false;

        int dic[26] = {0};
        int s_sz = s.size(), t_sz = t.size();
        for (int i = 0; i < s_sz; i++)
        {
            // 直接计算相对值
            dic[s[i] - 'a']++;
        }

        for (int i = 0; i < t_sz; i++)
        {
            dic[t[i] - 'a']--;
        }

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

        return true;
        
    }
};

1. 不使用unordered_map,自己用数组构建一个hashmap

2. s[i] - 'a' 直接把char转成字母在字母表中的顺序

3. 使用数组来做hashmap的题目都限制了题目数据的大小

Leetcode 349. 两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        
        // 第一次见这种写法，应该是vector转unordered_set
        // 注意unordered_set里的每一个key都不会重复
        unordered_set<int> dic(nums1.begin(), nums1.end());

        // 存放结果，因为不重复，最后再unordered_set转vector
        unordered_set<int> result;

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

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

1. unordered_set里的数据是不重复的

2. 注意这里unordered_set和vector互相转换的手法

leetcode 202. 快乐数

初见想法：直接看了答案，这尼玛是简单题？

class Solution {
public:
    bool isHappy(int n) {
        unordered_set<int> dic;

        while (!dic.count(n) && n != 1)
        {
            dic.insert(n);
            n = getNext(n);
        }

        return n == 1;
    }

    int getNext(int n)
    {
        int sum = 0;
        while (n > 0)
        {
            int d = n % 10;
            n = n / 10;
            sum += d * d;
        }
        return sum;
    }
};

1. 快乐数不会循环，而不是快乐数的数会循环，使用hashset判断此数是否出现过

Leetcode 1. 两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ans;
        unordered_map<int, int> dic;
        
        int sz = nums.size();
        for (int i = 0; i < sz; i++)
        {
            int disre = target - nums[i];
            if (dic.find(disre) != dic.end())
            {
                ans.push_back(i);
                ans.push_back(dic[disre]);
                break;
            }

            dic[nums[i]] = i;
        }

        return ans;
    }
};

1. 感觉还可以啊