数字之和系列

1. 两数之和

题目
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9， 所以返回 [0, 1]

很简单的哈希表即可。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n=nums.size();
        vector<int> ans;
        map<int,int> mp;
        for(int i=0;i<n;i++){
            if(mp.count(target-nums[i])){
                ans.push_back(mp[target-nums[i]]);
                ans.push_back(i);
                return ans;
            }
            mp[nums[i]]=i;
        }
        return ans;
    }
};

15. 三数之和

题目
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

1. 首先先排序。判断几个数字的和，为了进行遍历，所以要先排序。
2. 固定一个数a，然后将b、c两头进行缩进（b++，c–）
3. 注意剪枝和去重。剪枝：如果一个数大于0，那一定不可能和后面的数相加=0；

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) break;
            if(i>0 && nums[i]==nums[i-1]) continue;

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

18. 四数之和

题目
给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：

给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。

满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]

这道题和上面的三数之和的思路其实是完全一致的，只是这道题因为是四个数，所以要先通过去重和剪枝确定前面两个数，再通过三数之和中的方法缩进后面两个数。
剪枝的方法是和targer做判断，这里要注意break和continue的使用。只有在最小的四个数之和都大于target时，才要break；其余都要continue。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        int n=nums.size();
        if(n<4){
            return res;
        }
        
        sort(nums.begin(),nums.end());
        for(int i=0;i<n-3;i++){
            // 去重
            if(i>0 && nums[i]==nums[i-1]) continue;
            // 剪枝
            if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target){
                break;
            }
            if(nums[i]+nums[n-1]+nums[n-2]+nums[n-3]<target){
                continue;
            }

            for(int j=i+1;j<n-2;j++){
                if(j>i+1 && nums[j]==nums[j-1]) continue;
                if(nums[i]+nums[j]+nums[j+1]+nums[j+2]>target){
                    continue;
                }
                if(nums[i]+nums[j]+nums[n-1]+nums[n-2]<target){
                    continue;
                }

                int l=j+1,h=n-1;
                while(l<h){
                    int sum=nums[i]+nums[j]+nums[l]+nums[h];
                    if(sum==target){
                        vector<int> ans{nums[i],nums[j],nums[l],nums[h]};
                        res.push_back(ans);
                        while(l<h && nums[l]==nums[l+1]) l++;
                        while(l<h && nums[h]==nums[h-1]) h--;
                        l++;h--;
                    }else if(sum<target){
                        l++;
                    }else if(sum>target){
                        h--;
                    }
                }
            }
        }
        return res;
    }
};

454. 四数相加 II

题目
给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。

例如:

输入: A = [ 1, 2] B = [-2,-1] C = [-1, 2] D = [ 0, 2]

输出: 2

解释: 两个元组如下:

1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

这道题开始沿用上面的思路，做了好久，结果超时了o(╥﹏╥)o
实际这道题直接哈希表就可以了
但是只超过5%的代码，不知道到底是用的那些好方法啊

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        map<int,int> cnt;
        int n=A.size();
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                cnt[A[i]+B[j]]++;
            }
        }

        int res=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                res+=cnt[-(C[i]+D[j])];
            }
        }
        return res;
    }
};