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

242题思路就是分别遍历两个单词，统计字母数量看看是否一致。

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

349题的代码基本全部看不懂，贴一下原文代码吧

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());
        for (int num : nums2) {
            // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};
//这段代码是一个C++函数，属于一个名为 Solution 的类，其目的是找出两个整数数组 nums1 和 nums2 的交集。下面我将逐行解释这段代码：

//unordered_set<int> nums_set(nums1.begin(), nums1.end());
//这行代码创建了一个名为 nums_set 的 unordered_set（无序集合）对象，它包含 nums1 数组中的所有元素。unordered_set 是一种容器，类似于 vector，但它不允许重复的元素，并且元素的迭代顺序是不确定的。nums1.begin() 和 nums1.end() 是迭代器，分别指向 nums1 数组的第一个元素和数组之后的位置（不包括数组的最后一个元素）。

//for (int num : nums2) {
//这是一个基于范围的for循环（range-based for loop），是C++11引入的新特性。这种循环的语法糖使得遍历容器变得非常简洁。这里的意思是，对于 nums2 中的每个元素 num，执行花括号 {} 内的代码块。

//if (nums_set.find(num) != nums_set.end()) {
//这行代码检查当前遍历到的元素 num 是否存在于 nums_set 中。nums_set.find(num) 会返回一个迭代器，指向 nums_set 中与 num 相等的元素。如果 num 不在 nums_set 中，find 函数将返回 nums_set.end()，这是一个指向 nums_set 结束之后的迭代器。

//result_set.insert(num);
//如果 num 在 nums_set 中找到了，这行代码将 num 插入到另一个 unordered_set 对象 result_set 中。由于 unordered_set 不允许重复元素，如果 num 已经被插入，它不会被再次插入。

//return vector<int>(result_set.begin(), result_set.end());
//这行代码将 result_set 转换成一个 vector（向量），并返回这个向量。vector<int>(result_set.begin(), result_set.end()) 是一种初始化 vector 的方式，它包含了 result_set 中的所有元素。

//总的来说，这段代码的目的是找出两个数组的交集，并将结果存储在一个 vector 中返回。它使用了 unordered_set 来快速检查元素是否存在，并利用基于范围的for循环来简化代码。

//只能算默写了一遍 完全是新学的规范
//确实 没有限制单个元素数值的大小 不能用常规的数组来处理
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> ans;
        unordered_set<int> tmp(nums1.begin(),nums1.end());
        for (int num : nums2) {
            if (tmp.find(num) != tmp.end()) {
                ans.insert(num);
            }
        }
        vector<int> res(ans.begin(),ans.end());
        return res;
    }
};

202题我是常规求余数相加

class Solution {
public:
    bool isHappy(int n) {
        unordered_set<int> tmp;
        int sum = 0;
        int num = n;
        int div;
        int remainder;
        while (num) {
            while (num != 0) {
                div = num/10;
                remainder = num%10;
                sum += remainder*remainder;
                num = div;
            }
            if (sum == 1) {
                return true;
            }
            if (tmp.find(sum) == tmp.end()) {
                tmp.insert(sum);
            } 
            else {
                return false;;
            }
            num = sum;
            sum = 0;
        }  
    return false;
    }
};

但是看题解有很有意思的快速求各位平方和的做法，还挺有趣的。

int calculateNum(int n){
        string str = to_string(n);
        int res = 0;
        for (char i:str){
            int num = i - '0';
            res = res + num*num;
        }
        return res;
    }

1题上来当然是暴力解法快速带走啊。

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

好吧，步入正题，想想怎么用哈希表的知识解决。

//排序后 从小到大排序 然后左右开始遍历相加 这样时间复杂度是O(n) 排序的时间复杂度是O(logn) 相加也是比O(n^2)小的
//但是这样的话，下标会乱，我需要一个东西，可以把下标和对应的数值存进去 就是你了underorder_map 甚至不需要排序 直接做减法 看看里面有没有对应的数值即可

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int>ret(2);
        unordered_map<int,int> map;
        for (int i = 0; i < nums.size(); i++) {
            if (map.find(target - nums[i]) != map.end()) {
                ret[0] = i;
                ret[1] = map[target - nums[i]];
                return ret;
            }
            map[nums[i]] = i;
        }
        return ret;
    }
};