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

454.四数相加II

初见想法：使用3个for循环,构建3个hashma, 最后固定一个vector, 时间复杂度o(n^3), 太复杂了

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> dic;
        for (int num1: nums1)
        {
            for (int num2: nums2)
            {
                dic[num1+num2]++;
            }
        }
        
        int ans = 0;
        for (int num3: nums3)
        {
            for (int num4: nums4)
            {
                if (dic.count(-num3-num4))
                {
                    ans += dic[-num3-num4]; 
                }
            }
        }

        return ans;
    }
};

1. 把abcd四组vector分成两组，然后把ab的值记入hashmap中，这样最终时间复杂度为o(n^2)

2. 如果是一个vector里的四个数相加，难度会高很多，这里是单独4个vector

383. 赎金信

初见想法：hashmap

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        
        if (ransomNote.size() > magazine.size()) return false;

        int dic[26] = {0};

        for (char c: magazine)
            dic[c-'a']++;
        
        for (char c:ransomNote)
            dic[c-'a']--;
        
        for (int i = 0; i < 26; i++)
        {
            if (dic[i] < 0) return false;
        }

        return true;
    }
};

1. 当元素为小写字母时 （一般题目会给一个string），可以使用一个26位的数组

2. 26位数组可以充当一个简单的hashmap

15. 三数之和

初见想法：hashmap?

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {   

        vector<vector<int>> ans;
        
        int sz = nums.size();
        if (sz < 3) return ans;

        sort(nums.begin(), nums.end());

        for (int i = 0; i < sz; i++)
        {
            // 排序后，如过遍历至nums[i] > 0时，不用再往后遍历了，因为必然三数之和>0
            if (nums[i] > 0) break;

            // a去重
            if (i > 0 && nums[i-1] == nums[i]) continue;

            int left = i + 1;
            int right = sz - 1;
            while (right > left)
            {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0) right--;
                else if (sum < 0) left++;
                else 
                {
                    ans.push_back(vector<int> {nums[i], nums[left], nums[right]});

                    // b c 去重 , 用 while 而不是if的原因是可能出现连续的情况
                    while (right > left && nums[left] == nums[left+1]) left++;
                    while (right > left && nums[right] == nums[right-1]) right--;

                    left++;
                    right--;
                }
            }

        }
        
        return ans;

    }
};

1. a,b,c三个数，在去重的过程中, 在遍历的过程中，a自己不能和自己重复，但是a可以和b或者c重复，因此判断a重不重复不能用a[i] == a[i+1], 应该用a[i-1] == a[i] (i > 0)

18. 四数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        
        vector<vector<int>> ans;

        int sz = nums.size();

        if (sz < 4) return ans;

        sort(nums.begin(), nums.end());
        
        for (int i = 0; i < sz; i++)
        {   
            // 如果是负数的话，反而会减小，所以一定需要nums[i] >= 0
            if (nums[i] > target && nums[i] >= 0) break;

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

            int mu = target - nums[i];

            for (int j = i+1; j < sz; j++)
            {
                if (nums[j] > mu && nums[j] >= 0) break;

                if (j > i+1 && nums[j-1] == nums[j]) continue;

                int left = j+1;
                int right = sz-1;
                while (right > left)
                {
                    // nums[j] + nums[left] + num[right]的和默认是int类型，在
                    // 求和的过程中，先转成long，然后再赋给long类型
                    long sum = (long) nums[j] + nums[left] + nums[right];
                    if (sum > mu) right--;
                    else if (sum < mu) left++;
                    else
                    {
                        ans.push_back(vector<int> {nums[i], nums[j], nums[left], nums[right]});
                        while (right > left && nums[right] == nums[right-1]) right--;
                        while (right > left && nums[left] == nums[left+1]) left++;

                        right--;
                        left++; 
                    } 
                }
            }
        }

        return ans;
    }
};