刷题笔记（6）---哈希表

哈希表

二级目录

三级目录

242. 有效的字母异位词（×）

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

        for(int i=0; i<26; ++i) 
        { 
            if(record[i] != 0) { return false; }
        }

        return true;
    }
};

383. 赎金信

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int record[26] = {0};
        for(int i=0; i<magazine.size(); ++i)
        {
            record[magazine[i] - 'a']++;
        }

        for(int j=0; j<ransomNote.size(); ++j)
        {
            record[ransomNote[j]-'a']--;

            if(record[ransomNote[j]-'a'] < 0) { return false; }
        }

        return true;
    }
};

349. 两个数组的交集（×）

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(auto it : nums2)
        {
            if(nums1_set.find(it) != nums1_set.end())
            {
                result_set.insert(it);
            }
        }

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

202. 快乐数（×）

class Solution {
public:

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

    bool isHappy(int n) {
        unordered_set<int> set;
        while(true)
        {
            int sum = getSum(n);
            if(sum == 1) { return true; }

            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            if(set.find(sum) != set.end()) { return false; }
            else { set.insert(sum); }
            n = sum;
        }
    } 
};

1. 两数之和（√）

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

            NumToIndex.insert(pair<int, int>(nums[i], i));
            //NumToIndex[nums[i]] = i;
        }
        return {};
    }
};

第454题.四数相加II

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> umap;	//key:a+b的数值，value:a+b数值出现的次数
		// 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中
        for(int a : nums1)
        {
            for(int b : nums2)
            {
                umap[a+b]++;
            }
        }
		// 统计a+b+c+d = 0 出现的次数
        int count = 0;
// 在遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就把map中key对应的value也就是出现次数统计出来。
        for(int c : nums3)
        {
            for(int d : nums4)
            {
                if(umap.find(0-(c+d)) != umap.end())
                {
                    count += umap[0-(c+d)];
                }
            }
        }

        return count;
    }
};

双指针解法

15. 三数之和（×）

去重逻辑很重要，需要仔细揣摩。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        // 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]

        for(int i=0; i<nums.size(); ++i)
        {
            // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if(nums[i] > 0) { return result; }

            // 错误去重方法，将会漏掉-1,-1,2 这种情况
          	if (nums[i] == nums[i - 1]) { continue; }
            // 正确去重方法
            if (i > 0 && nums[i] == nums[i - 1]) { continue; }

            int left = i + 1;
            int right = nums.size() - 1;

            while(left < right)
            {
                // 去重复逻辑如果放在这里，0，0，0 的情况，可能直接导致 right<=left 了，从而漏掉了 0,0,0 这种三元组
                if(nums[i] + nums[left] + nums[right] > 0) { right--; }
                else if(nums[i] + nums[left] + nums[right] < 0) { left++; }
                
                else 
                {
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    
                    // 去重逻辑应该放在找到一个三元组之后

                    while (right > left && nums[right] == nums[right - 1]) { right--; }
                    while (right > left && nums[left] == nums[left + 1]) { left++; }

                    // 找到答案时，双指针同时收缩
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
};

18. 四数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;

        sort(nums.begin(), nums.end());
        for(int k=0; k<nums.size(); ++k)
        {
            if(k > 0 && nums[k] == nums[k-1]) { continue; }

            for(int i=k+1; i<nums.size(); ++i)
            {
                if(i > k+1 && nums[i] == nums[i-1]) { continue; }

                int left = i + 1;
                int right = nums.size() - 1;

                while(left < right)
                {
                    if((long long)nums[k] + nums[i] + nums[left] + nums[right] > target) { right--; }
                    else if((long long)nums[k] + nums[i] + nums[left] + nums[right] < target) { left++; }
                    else
                    {
                        result.push_back(vector<int> {nums[k], nums[i], nums[left], nums[right]});

                        while(left < right && nums[right] == nums[right-1]) { right--; }
                        while(left < right && nums[left] == nums[left+1]) { left++; }

                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
};