● 454.四数相加II

public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        std::unordered_map<int, int> map;
        for(int a:nums1){
            for(int b:nums2){
                map[a + b]++;
            }
        }
        int count=0;
        for(int c :nums3){
            for(int d:nums4){
                if(map.find(0-(c+d)) != map.end()){
                    count +=  map[0-(c+d)];
                }
            }
        }
        return count;
    }
};

思路步骤

1、定义一个unordered_map，遍历nums1，nums2 2、在map中key记录a + b的值，value记录次数 3、定义count，a + b+c+d=0记录次数 4、遍历nums3，nums4，记录c+d，在map中查找，用count记录 5、最后返回count

收获

两个for循环是遍历二维数组的所有数； map.find(0-(c+d)) = map.end()是代表在map中找不到这个值

15. 三数之和 (使用数组而不是map)

思路

如果是用map，那么去重是会很麻烦，很容易照顾不全所有的情况。 这题用数组不需要返回下标，所以排序可以（下标乱了也没关系）

去重逻辑的思考

a的去重

说道去重，其实主要考虑三个数的去重。 a, b ,c, 对应的就是 nums[i]，nums[left]，nums[right]

a 如果重复了怎么办，a是nums里遍历的元素，那么应该直接跳过去。

但这里有一个问题，是判断 nums[i] 与 nums[i + 1]是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同。

有同学可能想，这不都一样吗。

其实不一样！

都是和 nums[i]进行比较，是比较它的前一个，还是比较他的后一个。

如果我们的写法是 这样：

if (nums[i] == nums[i + 1]) { // 去重操作
    continue;
}

那就我们就把 三元组中出现重复元素的情况直接pass掉了。 例如{-1, -1 ,2} 这组数据，当遍历到第一个-1 的时候，判断 下一个也是-1，那这组数据就pass了。

我们要做的是 不能有重复的三元组，但三元组内的元素是可以重复的！

所以这里是有两个重复的维度。

那么应该这么写：

if (i > 0 && nums[i] == nums[i - 1]) {
    continue;
}

这么写就是当前使用 nums[i]，我们判断前一位是不是一样的元素，在看 {-1, -1 ,2} 这组数据，当遍历到 第一个 -1 的时候，只要前一位没有-1，那么 {-1, -1 ,2} 这组数据一样可以收录到 结果集里。

这是一个非常细节的思考过程。

解答

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){
                continue;
            }
            //去重
            if(i > 0 && nums[i] == nums[i-1]){
                continue;
            }
           int left = i+1;
           int right = nums.size()-1;
           while(right > left){
               if(nums[i] + nums[right] + nums[left] >0)right--;
               else if(nums[i] + nums[right] + nums[left] < 0)left++;
               else{
                   result.push_back(vector<int>{nums[i], nums[right], nums[left]});
               
                   while(right > left && nums[right] == nums[right - 1]) right--;
                   while(right > left && nums[left] == nums[left + 1]) left++;

                   left++;
                   right--;
               }

           }
        }
    return result;
    }
};

补充：vector中push_back与insert在插入一个元素时区别

在c++中，两者都表示添加，其中push_back()表示在vector的末尾元素添加一个元素，而insert可以在某个位置添加一个元素

	v.push_back(2);
	for (int i = 0; i < v.size(); i++)
	{
		cout << v[i] << ",";  //用，隔开，学习这个用法
	}
        cout<<endl;
	//在位置2处添加10,原来位置上的值往后顺延
	v.insert(v.begin() + 2, 10);
	for (int j = 0; j < v.size(); j++)
	{
		cout << v[j] << ",";
	}

结果如下：

4，5，6，2
4，5，10，6，2

18. 四数之和

思路

两层循环：

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(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 left = i+1;
                int right = nums.size() - 1;
                while(right > left){
                    if((long)nums[k] + nums[i] + nums[left] + nums[right] > target)right--;
                    else if((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(right > left && nums[right] == nums[right-1])right--;
                    while(right > left && nums[left] == nums[left+1])left++;
                    left++;
                    right--;
                    }
                }
            }
        }
    return result;
    }
};