【代码随想录】哈希表——其他题目

202. 快乐数

//求和（另外定义一个函数求和）的过程中，如果sum重复出现（用哈希结构unordered_set快速判断一个元素是否重复）

//表明陷入了无限循环，直接return false;

//如果sum==1，直接返回true

//如果既不是1也没有在哈希表中出现过，将其存进哈希表（set.insert(sum)）

具体细节见注释 

class Solution {
    //求和的过程中，如果sum会重复出现（用哈希结构unordered_set快速判断一个元素是否重复）
    //表明陷入了无限循环，直接return false;
public:
    int getSum(int n){//用于计算
        int sum=0;
        while(n){//之前怎么会写成while(1),这不死循环了吗
            sum+=(n%10)*(n%10);//平方求和
            n=n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> set;
        while(1){
            int sum=getSum(n);
            if(sum==1){
                return true;//如果最终求得的和为1.直接返回true
            }
            if(set.find(sum)!=set.end()){//sum在哈希表中出现过，也就是会重复陷入循环
                return false;//直接返回false
            }
            else{
                set.insert(sum);
            }
            n=sum;//将n替换成sum
        }
    }
};

1. 两数之和

 哈希表解决，unordered_map<int,int> map;//第一个值代表元素num，第二个值代表位置。不用set结构是因为set结构会去重。

不用vector<int>，直接返回{}，快很多

auto it=map.find(target-nums[i]);//用it指向哈希表中的值target-nums[i]的位置。用it临时存起来是为了方便后面it->second

//没找到，就将这个数以及对应的位置存进哈希表，map.insert(pair<int,int>(nums[i],i));

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //vector<int> res;
        unordered_map<int,int> map;//第一个值代表元素num，第二个值代表位置
        for(int i=0;i<nums.size();i++){
            auto it=map.find(target-nums[i]);//用it指向哈希表中的值target-nums[i]的位置。用it临时存起来是为了方便后面it->second
            if(it!=map.end()){//表明能找到
                return {i,it->second};
                //res.push_back(it->second);
            }
            //没找到，就将这个数以及对应的位置存进哈希表
            map.insert(pair<int,int>(nums[i],i));
        }
        return {};
    }
};

454. 四数相加 II

哈希表，用上结构unordered_map<int,int> map;//第一个值代表和a+b，第二个值代表和a+b出现的次数

// 在遍历数组3、4时，如果 0-(c+d) 在map中出现过的话，就把map中key对应的value，也就是出现次数加起来

//用指针auto  it=map.find(0-(c+d));后面count+=it->second比count+=map[0-(c+d)]更快一点

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> map;//第一个元素：a+b之和；第二个元素：出现a+b之和的次数
        int count=0;//记录a+b+c+d=0的次数
        for(int a:nums1){
            for(int b:nums2){//遍历数组1、2，统计和为a+b的次数。存进哈希表中
                map[a+b]++;
            }
        }
        for(int c:nums3){
            for(int d:nums4){// 在遍历数组3、4，如果 0-(c+d) 在map中出现过的话，就把map中key对应的value，也就是出现次数加起来。
                auto it=map.find(0-(c+d));
                if(it!=map.end()){//在哈希表中能找到0-（c+d）
                    count+=it->second;//将和是0-（c+d）的次数赋值给count
                }
                //没有找到就不用加
            }
        }
        return count;
    }
};

15. 三数之和

//首先将数组排序，

//外层for循环，i从下标0的地方开始，先判断首元素是否大于0，如果大于0，表明不可能构成和为0的三元组，同时预先去重（去的i处的重，后面还要去left,right处的重），定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。依然还是在数组中找到 abc 使得a + b +c =0，我们这里相当于 a = nums[i] b = nums[left] c = nums[right]。

//内循环，左右指针的移动逻辑。接下来如何移动left 和right呢， 如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些。除此之外，将对应的数据放进res中，并去重（left，right都得判断是否有重复），找到三元组以及去重完毕之后，left，right指针收缩。直到left与right相遇为止。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> res;
        int n=nums.size();
        if(n<3) return res;
        sort(nums.begin(),nums.end());//先排序
        for(int i=0;i<n;i++){
            if(nums[i]>0) return res;//如果第一个元素就大于0，表明肯定无法凑成和为0的三元组
            //提前判断，提前去重
            if(i>0 && nums[i]==nums[i-1]) continue;

            int left=i+1,right=n-1;//左指针left定义在i+1的位置上，右right定义在数组结尾的位置上
            while(left<right){
                int sum=nums[i]+nums[left]+nums[right];
                if(sum<0) left++;
                else if(sum>0) right--;
                else{
                    res.push_back(vector<int>{nums[i],nums[left],nums[right]});//因为返回的是[[1,2,-3],[0,1,-1]]这种形式
                    //找到一个三元组之后，需要去重（上面是提前判断i处的去重，这里是根据left,right指针对应的元素去重）
                    //比如：-2,0,0,2,2这种情况
                    while(left<right && nums[right]==nums[right-1]) right--;
                    while(left<right && nums[left]==nums[left+1]) left++;

                    //找到三元组且去重之后，双指针收缩
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
};

18. 四数之和 

15题中三数之和的双指针解法是外for循环num[i]为确定值，然后内循环有left和right下标作为双指针，找到nums[i] + nums[left] + nums[right] == 0。

四数之和的双指针解法是两层for循环nums[j] + nums[i]为确定值（两层for循环都得提前去重判断if(i>0 && nums[i]==nums[i-1]) continue;//提前去重；if(j>i+1 && nums[j]==nums[j-1]) continue;//提前去重.j>i+1），依然是循环内有left和right下标作为双指针，找出nums[j] + nums[i] + nums[left] + nums[right] == target的情况，直到left与right相遇。

注意数值过大溢出的情况：int sum=nums[i]+nums[j]+nums[left]+nums[right];这样写会有溢出

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        sort(nums.begin(),nums.end());//先排序
        int n=nums.size();
        if(n<4) return res;

        for(int i=0;i<n;i++){
            //if(nums[i]>target) return res;错误的判断，target是任意值，nums[i]>targt,后面可能有小于target的
            if(i>0 && nums[i]==nums[i-1]) continue;//提前去重
            for(int j=i+1;j<n;j++){
                if(j>i+1 && nums[j]==nums[j-1]) continue;//提前去重.j>i+1
                int left=j+1,right=n-1;
                while(left<right){
                    //int sum=nums[i]+nums[j]+nums[left]+nums[right];这样写会有溢出
                    if(nums[i]+nums[j]<target-(nums[left]+nums[right])) left++;
                    else if(nums[i]+nums[j]>target-(nums[left]+nums[right])) right--;
                    else{
                        res.push_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});

                        //left,right指针指向的元素去重
                        while(left<right && nums[right]==nums[right-1]) right--;
                        while(left<right && nums[left]==nums[left+1]) left++;

                        //之后指针收缩
                        left++;
                        right--;
                    }
                }
            }
        }
        return res;
    }
};