算法日志4：哈基表

前言

本文记录了哈希表相关题目的刷题

---

有效的字母异位词

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

两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        unordered_set<int> nums1_set(nums1.begin(), nums1.end());
        for(int num:nums2){
            if(nums1_set.find(num)!= nums1_set.end()) result_set.insert(num);
        }
        return vector<int> (result_set.begin(), result_set.end());
    }
};

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        nums1_dict = {}
        res_set = set()
        for num in nums1:
            nums1_dict[num] = nums1_dict.get(num,0)+1
        for num in nums2:
            if nums1_dict.get(num,0) : # if num in nums1_dict:
                res_set.add(num)     
        return list(res_set)

快乐数

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

class Solution:
    def next_num(self, n:int) -> int:
        cnt = 0
        while(n):
            cnt+=(n % 10)**2
            n//=10
        return cnt

    def isHappy(self, n: int) -> bool:
        n_set = set()
        n_set.add(n)
        while 1:
            n = self.next_num(n)
            if n == 1:
                return True
            if n in n_set:
                return False
            else:
                n_set.add(n)  


        

两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> nums_map;
        int nums_len = nums.size();
        for(int i = 0; i < nums_len; i++){
            // auto iter = nums_map.find(target - nums[i]);
            // if(iter!= nums_map.end()){
            //     return {iter->second, i};
            // }
            //上面的方法也可
            if(nums_map.find(target - nums[i]) != nums_map.end()){
                return {nums_map[target-nums[i]], i };
            }
            else{
                nums_map.insert(pair<int, int>(nums[i], i));
            }    
            }
         return {};
        }
    
};

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        nums_set = {}
        for i,num in enumerate(nums):
            if(target - num) in nums_set:
                return [nums_set[target - num], i]
            else:
                nums_set[num] = i
        
        

四数之和（简单）

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> ab_set;
        for(int num1: nums1){
            for(int num2:nums2){
                ab_set[num1+num2]++;
            }
        }
        int count = 0;
        for(int num3:nums3){
            for(int num4:nums4){
                if(ab_set.find(0-num3-num4) != ab_set.end()){
                    count += ab_set[0-num3-num4];
                }
            }
        }
        return count;

    }
};

赎金信

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        vector<int> note_arr(26);
        vector<int> magz_arr(26);
        for(char l:ransomNote){
            note_arr[l-'a']++;
        }
        for(char l:magazine){
            magz_arr[l-'a']++;
        }
        for(int i = 0; i<26;i++){
            if(note_arr[i]>magz_arr[i]) return 0;
        }
        return 1;
    }
};

三数之和

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        // i<j<k
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());
        int len = nums.size();
        int l,r;
        for(int i= 0 ; i<len-2;i++){
            
            if(i>0 && nums[i] == nums[i-1]) continue;
            // 错误去重a方法，将会漏掉-1,-1,2 这种情况
            /*
            if (nums[i] == nums[i + 1]) {
                continue;
            }*/


            l = i+1;
            r = len-1;
            while(l < r){
                if(nums[l]+nums[r] > -nums[i]){
                    r--;
                }
                else if(nums[l]+nums[r]<-nums[i]){
                    l++;
                }
                else{
                    res.push_back(vector<int>{nums[i], nums[l], nums[r]});
                    while(r>l&&nums[l] == nums[l+1]) l++;
                    while(r>l&&nums[r] == nums[r-1]) r--;
                    l++;
                    r--;
                }
            }

        }
        return res;
    }
};

四数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());
        int l,r,tmp;
        int len = nums.size();
        for(int i=0;i<len-3;i++){
            if (i>0&&nums[i]==nums[i-1]) continue;
            for(int j = i+1; j<len-2;j++){
                if(j>i+1 && nums[j] == nums[j-1]) continue;
                l = j+1;
                r = len-1;
                while(r>l){
                    long tmp = (long)nums[l] + nums[r] + nums[i] + nums[j];
                    if(tmp>target){
                        r--;
                    }
                    else if(tmp<target){
                        l++;
                    }
                    else{
                        res.push_back(vector<int>{nums[i],nums[j],nums[l],nums[r]});
                        while(r>l && nums[r]==nums[r-1]) r--;
                        while(r>l  && nums[l]==nums[l+1])l++;
                        l++;
                        r--;
                    }
                }
            }
        }
        return res;
    }
};