代码随想录第六天：四数相加、赎金信、三数之和、四数之和

1.四数相加

题目链接：. - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

视频讲解：学透哈希表，map使用有技巧！LeetCode：454.四数相加II_哔哩哔哩_bilibili

本体暴力解法为四层循环，时间复杂度为O(n^4)。可以使用哈希法降为O(2*n^2)。 

本题哈希结构需要记录的是数组1和数组2元素之和的种类与数量，所以需要使用map。

为什么不再对数组3和数组4的和储存在另一个哈希结构中？因为时间复杂度没有变，而且最后多了一个对map遍历的操作，属于多余的操作。

遍历数组3和数组4时，就去查找map中是否有满足条件的和。

代码如下：

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

2.赎金信

题目链接：. - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

本体与有效的字母异位基本一致，不再赘述。

代码如下：

bool canConstruct(string ransomNote, string magazine) {
    vector<int> record(26, 0);
    if (ransomNote.size() > magazine.size()) {
        return false;
    }
    for (char ch : ransomNote){
        record[ch - 'a']++;
    }
    for (char ch : magazine){
        record[ch - 'a']--;
    }
    for (int i : record){
        if (i > 0)
            return false;
    }
    return true;
}

3.三数之和

题目链接：. - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

视频讲解：梦破碎的地方！| LeetCode：15.三数之和_哔哩哔哩_bilibili

本题与四数之和类似，要与四数相加题目区分开。要在同一个数组中寻找三个和为0的元组，且不能重复。使用哈希法可以做，但是去重部分有很多细节，比较麻烦。

本体使用双指针法，示意如下:

前指针在循环中遍历整个数组，左右指针负责寻找适合的元组。

有以下注意点：

1.数组需要排序

2.前指针遇到元素大于0时，应结束循环。

3.前指针遇到元素重复时，应跳过该元素。

4.三数之和小于0时，左指针右移，反之右指针左移。

5.左右指针的去重应当在找到正确的三元组后进行，跳过左右指针相邻的相同元素。

代码如下：

vector<vector<int>> threeSum(vector<int>& nums) {
    vector<vector<int>> result;
    //排序
    sort(nums.begin(), nums.end());
    for (int i = 0; i < nums.size() ; ++i) {
        // 如果当前元素已经大于0了，那么再与后面元素相加必然大于0
        if (nums[i] > 0)
            return result;
        // 排除重复的元素,第一次遇到的元素已经参与运算，省略掉后续重复元素。
        if (i > 0 && nums[i] == nums[i - 1])
            continue;
        // left越界的话下面while循环无法进入，所以不用额外设置条件
        int left = i + 1;
        int right = nums.size() - 1;
        while (left < right){
            if (nums[i] + nums[left] + nums[right] > 0)
                right--;
            else if (nums[i] + nums[left] + nums[right] < 0)
                left++;
            else{
                result.push_back(vector<int>{nums[i] , nums[left] , nums[right]});
                // 左指针去重
                while (left < right && nums[left] == nums[left + 1]){left++;}
                // 右指针去重
                while (left < right && nums[right] == nums[right - 1]){right--;}
                // 结束后左右指针收缩
                left++;
                right--;
            }
        }
    }
    return result;
}

时间复杂度为O(n^2)，暴力解法为O(n^3)。

4.四数之和

题目链接：. - 力扣（LeetCode）

讲解链接：代码随想录 (programmercarl.com)

视频讲解：难在去重和剪枝！| LeetCode：18. 四数之和_哔哩哔哩_bilibili

本题解法与三数之和类似，只是多加了一重循环。

另外提前结束方法需要改动：不能简单＞target来判断，因为如果target<0时，即使当前元素大于target，仍可能存在满足条件的元组。

第一层循环的去重条件基本不变。

第二层循环童谣需要提前结束和去重，而这时的判断条件为i和j对应的元素之和进行判断。去重也要修改对应的范围。

本体还有一个不同之处，即本题四个数之和可能超过int类型的最大数值，所以判断和大小时需要转换为long类型进行判断。

代码如下：

vector<vector<int>> fourSum(vector<int>& nums, int target) {
    vector<vector<int>> result;
    sort(nums.begin(), nums.end());
    for (int i = 0; i < nums.size(); ++i) {
        if (nums[i] > target && nums[i] >= 0 )
            break;
        if (i > 0 && nums[i] == nums[i - 1])
            continue;
        for (int j = i + 1; j < nums.size(); ++j) {
            if (nums[i] + nums[j] > target && nums[i] + nums[j] >= 0 )
                break;
            if (j > i + 1 && nums[j] == nums[j - 1])
                continue;
            int left = j + 1;
            int right = nums.size() - 1;
            while (left < right){
                if ((long)nums[i] + nums[j] + nums[left] + nums[right] > target)
                    right--;
                else if ((long)nums[i] + nums[j] + nums[left] + nums[right] < target)
                    left++;
                else{
                    result.push_back(vector<int>{nums[i] , nums[j], nums[left] , nums[right]});
                    // 左指针去重
                    while (left < right && nums[left] == nums[left + 1]){left++;}
                    // 右指针去重
                    while (left < right && nums[right] == nums[right - 1]){right--;}
                    // 结束后左右指针收缩
                    left++;
                    right--;
                }
            }
        }
    }
    return result;
}