刷题||454.四数相加II 、383. 赎金信 、15. 三数之和 、● 18. 四数之和

因为上周在弄中兴的一个比赛，将力扣刷题进度拖累了，现在趁着五一抓紧补回来

今天还是哈希表这一块的内容

http://L454、四数相加||https://leetcode.cn/problems/4sum-ii/

本题感觉可以采用四层for循环来进行操作，但是可能会会变得复杂化，本题中采用两次for循环，先将前两个数组各元素之和放入一个map中，统计其出现的次数，再到后面统计(0-(i+j))是否能在map中找到，若能找到，将当前result的value值加起来就好了，因为每一个value值都表示每一个下标都不一样，

！！！只是没想到result[i+j]++，就可以让key:i+j ，的value进行加1

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) 
    {
        unordered_map<int, int>result;
        for (auto i : nums1)
        {
            for (auto j : nums2)
            {
                result[i + j]++;
            }
        }
        int count = 0;
        for (auto i : nums3)
        {
            for (auto j : nums4)
            {
                if(result.find(0-(i+j))!=result.end())
                    count += result[0 - (i + j)];
            }
        }
        return count;
    }
};

http://L383赎金信https://leetcode.cn/problems/ransom-note/submissions/

本题跟之前的那个有效字母异位词很类似，但是得需要加一段判断是否当前要减去的数组是否为0，也就是怕第二个的可用字符比第一个的多，而且第一个也没有第二个出现的字符，这是要注意的点

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
            int result[26]={0};
            for(int i=0;i<ransomNote.size();i++)
            {
                result[ransomNote[i]-'a']++;//对当前每个字母进行一个统计，因为本题已经说明magazine 中的每个字符只能在 ransomNote 中使用一次。
            }
            for(int j=0;j<magazine.size();j++)
            {
                if(result[magazine[j]-'a']!=0)
                {
                    result[magazine[j]-'a']--;
                }
            }
            for(int i=0;i<26;i++)
            {
                if(result[i]!=0)
                {
                    return false;
                }
            }
            return true;
    }
};

http://L15三数之和https://leetcode.cn/problems/3sum/

感觉本题还是采用双指针的方式比较好，保证一个i不动，然后用一个队头指针和一个队尾指针来进行一个遍历，这样不断更新比较好

class Solution {
public:
    //数组中的数组，vector中的vector
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>>result;
        sort(nums.begin(), nums.end());
        int length = nums.size();
        if(nums.empty()||length<3)return result;
        for (int i = 0; i < nums.size() - 2; i++)
        {
            if (i > 0 && nums[i] == nums[i - 1])continue;
            int j = i + 1;
            int k = length - 1;
            //若存在i连续相等，则让i+1；
            while (j < k)
            { 
                int ans = nums[i] + nums[j] + nums[k];
                if (ans == 0)
                {
                    result.push_back({nums[i],nums[j],nums[k]});
                     j++;
                    while (j < k && nums[j] == nums[j-1])j++;
                     k--;
                    while (j < k && nums[k] == nums[k+1])k--;
                }
                else if (ans > 0)k--;//若当前值比0大，那么就直接让其K--。
                else j++;//同上理
            }
        }
        return result;
    }
};

http://L18. 四数之和https://leetcode.cn/problems/4sum/

本题跟三数之和差不多，只是需要固定两个指针，理解了三数之和，四数之和也就简单

在本题中，还对算法进行了优化，剪枝是对其进行优化

1、对数组进行排序之后，判断其元素个数是否下于4，若小于则没有必要判断了

2、判断一开始的队头四个元素之和是否大于目标值，若大于也没有必要了

3、判断队头元素与数组最后三元素之和是否小于目标值，那就直接让其进行下一轮循环

4、同理对j这一块也是一样的判断，

本体中为什么要对求和的数进行一个long转化，是怕int进行一个溢出，将其转化为long型，这样才会避免这种情况

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> quadruplets;
        if (nums.size() < 4) {
            return quadruplets;
        }
        sort(nums.begin(), nums.end());
        int length = nums.size();
        for (int i = 0; i < length - 3; i++) {
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            if ((long) nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) {
                break;
            }
            if ((long) nums[i] + nums[length - 3] + nums[length - 2] + nums[length - 1] < target) {
                continue;
            }
            for (int j = i + 1; j < length - 2; j++) {
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }
                if ((long) nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) {
                    break;
                }
                if ((long) nums[i] + nums[j] + nums[length - 2] + nums[length - 1] < target) {
                    continue;
                }
                int left = j + 1, right = length - 1;
                while (left < right) {
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum == target) {
                        quadruplets.push_back({nums[i], nums[j], nums[left], nums[right]});
                        while (left < right && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        left++;
                        while (left < right && nums[right] == nums[right - 1]) {
                            right--;
                        }
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        right--;
                    }
                }
            }
        }
        return quadruplets;
    }
};

总结：常见的哈希表：1.数组、2.set、3.map 虽然从某一定程度来说，可以无脑使用map，但有时系统会限制内存空间，这时候map可能会不适合，

使用数组做哈希表存在一下弊端：

• 数组的大小是有限的，受到系统栈空间（不是数据结构的栈）的限制。
• 如果数组空间够大，但哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。

至于什么时候使用什么类型的哈希表，得视情况而定，并且map中的key值可以对其进行排序，但是key值不能重复，一般会自动进行排序，若不行，就自己进行写操作符重载，来进行map的一个排序