刷题第五天， 242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、 1. 两数之和

242.有效的字母异位词，判断元素是否出现在集合里较为快速的方法就是利用哈希表来实现，本题可以通过构建一个哈希表记录第一个字符串中不同字母的出现频率，然后遍历第二个字符串来更改哈希表中的数值，如果提前出现某一个字母的对应的值为零，则为false，否则即为真，代码如下，时间复杂度O(n)，空间复杂度O(1)

#include <iostream>
#include <unordered_map>
#include <string>

bool areAnagrams(const std::string& s,const std::string& t){
    if(s.size() != t.size()){
        return false;
    }
    std::unordered_map<char,int> counts;

    for(char i : s){
        counts[i]++;
    }
    for(char j : t){
        if(counts[j] == 0){//如果提前出现某个值为零，那么两者不是
            return false;
        }
        counts[j]--;
    }
    return true;
}

int main(){
    std::string s = "anagram";
    std::string t = "nagaram";

    if(areAnagrams(s,t) == true){
        std::cout << "yes"<< std::endl;
    }else{
        std::cout << "no" << std::endl;
    }
    return 0;
}

349. 两个数组的交集，注意：在本例子中，使用 unordered_set 而不是 unordered_map 是因为我们只需要存储元素的存在性，而不需要存储额外的数据或元素的计数。unordered_set 适用于这种情况，因为它提供了一个高效的方式来检查元素是否存在于集合中，这正是我们寻找两个数组交集所需要的功能。代码如下：

#include <iostream>
#include <vector>
#include <unordered_set>

std::vector<int> interSection(const std::vector<int> &nums1, const std::vector<int> &nums2)
{
    std::unordered_set<int> set1(nums1.begin(), nums1.end());
    std::unordered_set<int> result;

    for (int num : nums2)
    {
        if (set1.count(num))
        {
            result.insert(num); // 集合用插入
        }
    }

    return std::vector<int>(result.begin(), result.end()); // 这个地方直接初始化就行
}

int main()
{
    std::vector<int> nums1 = {1, 2, 2, 1};
    std::vector<int> nums2 = {2, 2};

    std::vector<int> res = interSection(nums1, nums2);
    std::cout << "Intersection of two array is:";
    for (int i : res)
    {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

202. 快乐数，注意一些基本函数的使用，如set.find()

#include <iostream>
#include <unordered_set>

int getSum(int num)
{
    int sum = 0;
    while (num)
    {
        int i = num % 10;
        sum += i * i;
        num = num / 10;
    }
    return sum;
}

bool isHappy(int num)
{
    int sum = 0;
    std::unordered_set<int> res;
    while (1)
    {
        sum = getSum(num);
        if (sum == 1)
        {
            return true;
        }
        if (res.find(sum) != res.end()) // 如果之前出现过，find返回指向该元素的迭代器，如果没找到返回end()
        {
            return false;
        }
        res.insert(sum);
        num = sum;
    }
}

int main()
{
    int n = 19;
    if (isHappy(n))
    {
        std::cout << "true" << std::endl;
    }
    else
    {
        std::cout << "false" << std::endl;
    }
}

1. 两数之和，利用哈希表降低时间复杂度，逻辑简单，查找补数是否在表中即可，代码如下：

#include <iostream>
#include <vector>
#include <unordered_map>

std::vector<int> twoSum(std::vector<int> &nums, int target)
{
    std::unordered_map<int, int> num_map; // 用来存储数字及其索引
    for (int i = 0; i < nums.size(); ++i)
    {
        int complement = target - nums[i]; // 计算补数
        // 检查补数是否已存在于哈希表中
        if (num_map.find(complement) != num_map.end())
        {
            // 如果存在，直接返回结果
            return {num_map[complement], i};
        }
        // 否则，将当前数字及其索引加入哈希表
        num_map[nums[i]] = i;
    }
    return {}; // 如果没有找到有效的结果，返回空数组
}

int main()
{
    std::vector<int> nums = {2, 7, 11, 15};
    int target = 9;
    std::vector<int> result = twoSum(nums, target);
    if (!result.empty())
    {
        std::cout << "Index1: " << result[0] << ", Index2: " << result[1] << std::endl;
    }
    else
    {
        std::cout << "No two sum solution found." << std::endl;
    }
    return 0;
}