代码随想录算法训练营第七天|LeetCode 454.四数相加II、LeetCode 383. 赎金信、LeetCode 15. 三数之和 、LeetCode 18. 四数之和。

LeetCode 454.四数相加II

题目链接：LeetCode 454.四数相加II

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int>map;
        for(int n1: nums1)
        {
            for(int n2: nums2)
            {
                map[n1+n2]++;
            }
        }
        int count = 0;
        for(int n3: nums3)
        {
            for(int n4: nums4)
            {
                if(map.find(0-(n3+n4)) != map.end())
                count += map[0-(n3+n4)];
            }
        }
        return count;
    }
};

思路：因题目问的是组合为0的元组有几个，需要知道key（组合的值）与value（出现的次数），故使用map结构的哈希法。首先遍历nums1与nums2，将出现的所有相加组合存入map中，并记录同一和所出现的次数，之后再遍历nums3和nums4，用（0-n3-n4） 是否存入过map，若有将出现的次数计入count中，最后返回count即可。

小结：

1.这题之所以将四个数分成2+2两组遍历，而不是1+3两组的遍历，是因为可以减小其时间复杂度，从而达到优化算法。1+3或4次for循环均可，但其时间复杂度比2+2更高。

2.因要记录的哈希值较大且范围不可控，故使用map结构。

---

LeetCode 383. 赎金信

题目链接：LeetCode 383. 赎金信

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

思路：使用array结构的哈希法。先判断ransomNote的长度是否超过magazine；之后将magazine中出现的字母及次数进行统计（++），再将ransomNote中出现的字母及次数进行统计（--）；若最后出现小于0的值，即ransomNote中有不存在于magazine的词，则返回false，否则为true。

小结：

1.因magazine中每个字母只能使用一次（相同的字母出现一次记作可使用一次），故需要记录每个字母出现次数。

2.因题目中ransomNote中的字母需要从magazine中寻找获得，且26个字母均为小写字母（ransomNote 和 magazine 由小写英文字母组成），哈希值小且范围可控（连续），故使用array结构的哈希法。

---

LeetCode 15. 三数之和

题目链接：LeetCode 15. 三数之和

双指针法：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());
        for(int i = 0;i < nums.size();i++)
        {
            if(nums[i] > 0)
             {
                return result;
             }
             //判断初始值是否大于0
            if (i > 0 && nums[i] == nums[i - 1]) 
            {
                continue;
            }
            //进行对i的去重
            int left = i + 1;
            int right = nums.size() - 1;
            while(right > left)
            {
                if((nums[i] + nums[left] + nums[right]) > 0)
                right--;//移动right
                else if((nums[i] + nums[left] + nums[right]) < 0)
                left++;//移动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++;//对left和right去重
                right--;
                left++;
                //移动right和left
                }   
            }
        }
        return result;
    
    }
};

思路：先将数组进行排序，设定遍历指针i，i之后的第一个指针left与数组最后一个指针right。如果排序后的第一个数nums[i] > 0，则不可能得出三个数相加为0（之后的数均比nums[i]大） ，故返回结果。之后对nums[i]去重;判断三个数的值与0的关系，若比0大则移动right（减小nums[right]）,若比0小则移动left（增大nums[left]）。得出结果后对right和left去重，再移动left和right继续遍历，最终得到集合result。

小结：

1.因用哈希法在去重上比较麻烦，本题不建议用哈希法。

2.在对nums[i]的去重上，因left始终在i之后，且去重是对nums[i]去重，而不是nums[left] != nums[i]；故用（num[i] == nums[i+1]）去重会导致nums[left] == nums[i]的情况被忽略。

3.在while（right > left）中，如果取等则两个指针指向同一个数，为重复，故不能取等。

4.找到答案之后需对left和right进行去重。

---

LeetCode 18. 四数之和

题目链接：LeetCode 18. 四数之和

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

思路：整体思路与三数之和一致，外面再套了一层for循环进行第四个数的遍历。

小结：

1.在判断是否可以直接结束循环时，由于不清楚target的正负，故在排序之后只能判断当第一个数大于目标且均为正数时可以直接跳出循环。

2.每一个位置的数都要进行去重。

3.在判断l与j是否重复时需要加上l > j;否则会出现溢出。