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

383. 赎金信

力扣题目链接

解析：

一般这种小字符集的问题，用一个小数组来解决反而是最方便的。

这个问题只需要先遍历一遍magazine字符串，把其中出现的字符个数记录一遍，再遍历一遍ransom，在对应记录中把其中出现的再减掉，一旦发现<0了，则返回false。总体时间复杂福为O(m+n)，空间复杂度O(26 ~ 1)。

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

第15题. 三数之和

力扣题目链接

解析：

这道题稍微有些抽象，主要是因为题目给了一个要求：去重；而本题是三数之和，那么就意味着，对于 sum = a + b + c，a\b\c三个数字都要考虑去重的问题。如果用暴力枚举法，则是O(n^3)的时间复杂度，时间上是无法接受的，因此这里继续引入了双指针法，具体算法步骤如下：

1. 先将无序的向量排序 - O(nlogn)
2. 判断一下 最高位跟最低位 是否小于0 或大于0，是则返空
3. 建立一层for循环，确定最小的元素位置pos，再设立一lo 一hi两个指针，构成三数之和
4. 判断nums[pos]的正负，如果为正，作为最小的这个数，已经不会有其他的数能凑成0了，因而可以直接返回
5. 判断三数之和的正负【pos位置始终不动，lo\hi移动模拟枚举，但是对每一个pos都只有线性复杂度】：

• 若为正，表示超过的0，此时需要缩小，则高位指针向左移动
• 若为负，则此时需要增大，则低位右移
• 若为0，则满足题意，将其压入result中

但是在这里要非常注意去重的问题：

设有一个有序向量：-1，-1，-1，0，0，0，1，1，1，2，我们应该在何时去重？

我想聪明的你应该不难看出，对于b\c，我们只要在找到符合sum==0的【pos,lo,hi】时，判断一下hi-1/lo+1是否与hi\lo相同即可，相同则向后或向前移动一位，就能略过下一轮的相同的三数组合，但是对于a我们怎么处理呢？

不妨以第一个-1【0号位置】与第二个-1【1号】为例：0号位置的后缀包含了1的所有后缀，也就是 对于a\b\c式，当a是0号位置的-1时，已经全部能包含a是1号位置的-1的全部结果，而我们恰巧也是从最左端开始循环的。

因此，我们对于a去重的时刻，便是每次刚进入循环，去判断一下nums[i]与nums[i-1]是否相等，如何相等直接略过即可，因为对于nums[i-1]这轮的循环与枚举，已经囊括了接下来对nums[i]去枚举的所有三数排列组合。

因此最后我们便能得到一个时间复杂度为O(n^2 + nlogn) = O(n^2)，空间复杂度为O(1)的算法。

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        if(nums.size() < 3) return result; //不足3则直接返空
        sort(nums.begin(), nums.end());
        int lo = 0; 
        int hi = nums.size() - 1;
        if(nums[hi] < 0 || nums[lo] > 0) return result; //全小于0 或全大于0 直接返空
        for(int i = 0; i < nums.size() - 2; i++){
            if (nums[i] > 0) return result; //不可能再相加为0
            if(i > 0 && nums[i] == nums[i-1]) continue; //去重a
            lo = i + 1;
            hi = nums.size() - 1;
            while(lo < hi){
                int sum = nums[i] + nums[lo] +nums[hi];
                if(sum < 0) lo++; //和小于0 则左指针右移
                else if(sum > 0) hi--; //和大于0 则右指针左移
                else{
                    result.push_back(vector<int>{nums[i], nums[lo], nums[hi]});
                    while(lo < hi && nums[hi] == nums[hi - 1]) hi--; //去重 c
                    while(lo < hi && nums[lo] == nums[lo + 1]) lo++; //去重 b
                    hi--;
                    lo++; 
                }
            }
        }
        return result; 
    }
};

第454题.四数相加II

力扣题目链接

解析：

这道题是经典的哈希思想的题目，暴力求解法的下时间复杂度必定O(n^4)，这个时候往往需要一些空间换时间的办法。

我们先遍历A,B数组，并将其和作为map的key, 出现的次数作为value；然后如法炮制的去遍历C，D，将map里能与 c+d 凑成 0 的key的value加到sum里，最后就能得出一共有多少种解法。

最后时间复杂度O(n^2)，空间复杂度O(n^2)。

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

第18题. 四数之和

力扣题目链接

解析：

该道题跟三数之和很像，外面嵌套一层循环即可。

class Solution {
public:
    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(i > 0 && nums[i] == nums[i - 1]) continue;
            for(int j = i + 1; j < nums.size(); j++){
                if( j > i + 1 && nums[j] == nums[j-1]) continue;
                int lo = j + 1;
                int hi = nums.size() - 1;
                while(lo < hi){
                    long sum = long(nums[i]) + long(nums[j]) + long(nums[lo]) + long(nums[hi]);
                    if(sum > target) hi--;
                    else if(sum < target) lo++;
                    else{
                        result.push_back(vector<int>{nums[i], nums[j], nums[lo], nums[hi]});
                        while(lo < hi && nums[hi] == nums[hi - 1]) hi--;
                        while(lo < hi && nums[lo] == nums[lo + 1]) lo++;
                        hi--;
                        lo++;
                    }
                }
            }
        }
        return result;
    }
       
};