day6 242、349、202、1

day6

Leetcode 242有效字母异位词

该题比较简单，由于数组可以算作一个特殊的哈希表，非常适合用来处理字符串相关的问题，

string t;
int arr[n];
for(char c:t)
{
	arr[c-'a']++;//c-'a'通过ascii码转换到0-26的下标索引
}

两个字符串进行比较，不需要定义两个arr分别遍历，在遍历第二个字符串时，通过递减操作，arr中有的元素不为0，说明字符串中存在不同的字母，如果最后都为0，说明两个字符串为异位

class Solution {
public:
    bool isAnagram(string s, string t) {
        int arr[26]={0};
        

        for(char c:s)
        {
            arr[c-'a']++;
        }
        for(char c:t)
        {
            arr[c-'a']--;
        }
        for(int num:arr)
        {
            if(num!=0)return false;
        }
        return true;
    }
};

Leetcode 349 两个数组的交集

该题需要绕一个弯，通过unordered_map统计完nums1中数字出现的次数，遍历nums2的过程中，如果有一个key的value不为零，push到ans中，在之后将num进行erase，避免遍历到相同元素保证唯一性。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int>ans;
        unordered_map<int,int>m;
        for(int num:nums1)
        {
            m[num]++;
        }
        for(int num:nums2)
        {
            if(m[num]!=0)
            {
                ans.push_back(num);
                m.erase(num);
                
            }
        }
        
        return ans;
    }
};

Leetcode 202 快乐数

该题主要就是计算每一位的平方和，计算的方式就是模10得到每一位，再通过num/10减少位数

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

采用unordered_set保存唯一性，在循环过程中如果出现重复非1的平方和，则陷入无限循环，出现第一次1就时快乐数。

bool isHappy(int n) {
       unordered_set<int>s;
       int temp=n;
        while(true)
        {
            temp=Sum(temp);
            if(temp==1)return true;
            auto it =s.find(temp);
            
            if(it==s.end())
            {
                s.insert(temp);
            }
            else 
            {
                return false;
            }
        }

Leetcode 1 两数之和

刚开始考虑使用一个unordered_map和set，set中记录数字出现与否，unordered_map记录数字出现次数，在unordered_map中查找target-num，但是这样对于nums=[3,3]的情况没法处理，看了代码随想录，只用了一个unordered_map，回来稍微思考以后想到可以通过unordered_map<int,vector>进行数据保存，分别考虑target-num=num和target-num！=num的情况

vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,vector<int>>m;
        
        vector<int>ans;
        for(int i=0;i<nums.size();i++)
        {
            m[nums[i]].push_back(i);
            
        }
        for(int num:nums)
        {
            if(target-num==num)
            {
                if(m[num].size()>=2)
                {
                    ans.push_back(m[num][0]);
                    ans.push_back(m[num][1]);
                    break;
                }
            }
            else
            {
                if(m[target-num].size()>0)
                {
                    ans.push_back(m[num][0]);
                    ans.push_back(m[target-num][0]);
                    break;
                }

            }
        }
        return ans;
    }