DAY6 有效的字母异位词 两个数组的交集 快乐数 两数之和

好吧，day5算休息日，直接开始day6

进入哈希表章节了，之前没怎么用过哈希表，所以不太熟练

有效的字母异位词：

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1: 输入: s = "anagram", t = "nagaram" 输出: true

示例 2: 输入: s = "rat", t = "car" 输出: false

说明: 你可以假设字符串只包含小写字母。

对应力扣242题

这题有点意思，使用哈希数组就行了，只需要建一个大小为26的数组，然后将对应小写字母a-z映射到数组里就行，分别遍历两个数组，遍历第一个数组时，只需要在相应的位置做+1操作，遍历第二个数组时，做减一操作即可，最后看数组里面有没有不是0的数，有的话就说明这两个字符串字母出现的字数不一样。

class Solution {
public:
    bool isAnagram(string s, string t) {
         int res[26]={0};
         for(int i=0;i<s.size();i++)
         {
             res[s[i]-'a']++;
         }
          for(int j=0;j<t.size();j++)
         {
             res[t[j]-'a']--;
         }
         for(int i=0;i<26;i++)
        {if(res[i]!=0)return 0;
         }
         return 1;
    }
};

两个数组的交集：

题意：给定两个数组，编写一个函数来计算它们的交集。

说明： 输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。

对应力扣349题

这题既可以用数组来做，也可以用SET来做，因为题目中规定数组的大小小于1000。

用SET：

用SET的思路很简单，把一个数组遍历进SET1里面，之后用find来看SET里面有没有第二个数组的数，有的话就添加到SET2里面,最后return SET2即可。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
            unordered_set<int> res(nums1.begin(),nums1.end());
            unordered_set<int> result;
             for(int i=0;i<nums2.size();i++)
             { if(res.find(nums2[i])!=res.end())
                {
                    result.insert(nums2[i]);
                }

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

用数组：

建一个大小为1001的数组res,遍历第一个数组的时候，res相应位置变成1，遍历第二个数组的时候，如果res相应位置是1，就将其变成2，表示两个数组里面都出现了，最后把2的加入到一个vector数组即可。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
            int res[1001]={0};
            vector<int> result;
            for(int i=0;i<nums1.size();i++)
            {    int n=nums1[i]%1001;
                 if(res[n]!=1)
                 res[n]++;
            }
            for(int i=0;i<nums2.size();i++)
            {     int n=nums2[i]%1001;
                 if(res[n]==1)
                 res[n]++;
            }   
             for(int i=0;i<1001;i++)
            {
                 if(res[i]==2)
                 result.push_back(i);
            }
            return result;
    }
};

快乐数：

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为  1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

对应力扣202题

这题有个很大的前提，就是如果该数不是快乐数，那么他会无限“循环”，理解循环二字很关键，我们可以把已经出现过的平方和加入到一个SET里面，如果下一次还出现了这个数，说明是循环的，说明不是快乐数。

class Solution {
public:
    int getsum(int n){
        int sum=0;
        while(n)
        { sum+=(n%10)*(n%10);
            n=n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
         unordered_set<int> res;
         int a=getsum(n);
         res.insert(a);
         while(a!=1)
         {   a=getsum(a);
             if(res.find(a)==res.end())
              res.insert(a);
              else if(res.find(a)!=res.end())
              return 0;
              
         }
         return 1;
    }
};

两数之和:

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

对应力扣第1题

这题暴力解法时间复杂度O(n^2),双层for循环结束战斗。

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);
                 }
            }
        }
        return res;
    }
};

另一个方法是用map来做，我们可以使用find(target-num[i])来判断这个元素之前有没有出现过

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

结束！