代码随想录第7天

代码随想录第7天

四数相加 II

/*
* @lc app=leetcode.cn id=454 lang=cpp
*
* [454] 四数相加 II
*/
 
// @lc code=start
#include<string.h>
#include<vector>
#include<algorithm>
#include<unordered_map>
using namespace std;
class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        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){
                int tmp = -(c+d); //a+b
                if (map.find(tmp) != map.end())
                {
                    count += map[tmp];
                }
 
 
            }
 
        }
        return count;
    }
};
// @lc code=end
 
 

赎金信

/*
* @lc app=leetcode.cn id=383 lang=cpp
*
* [383] 赎金信
*/
 
 
// @lc code=start
#include<iostream>
#include<unordered_set>
using namespace std;
class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int n = ransomNote.size();
        int m = magazine.size();
        if (n > m )
        {
            return false;
        }
 
        int record[26] = {0};
        for (int i = 0; i < m; i++)
        {
            record[magazine[i] - 'a']++;
        }
 
 
        for (int j = 0; j < n; j++)
        {
            record[ransomNote[j] - 'a']--;
        }
 
        for (int k = 0; k < 26; k++)
        {
            if (record[k] < 0)
            {
                return false;
            }
 
        }
        return true;
 
    }
};
// @lc code=end
 
 

三数之和

/*
 * @lc app=leetcode.cn id=15 lang=cpp
 *
 * [15] 三数之和
 */

// @lc code=start
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
       vector<vector<int>> result;
       if (nums.size() == 0)
       {
        return result;
       }
       sort(nums.begin(),nums.end());
       for (int i = 0; i < nums.size(); i++)
       {
        if (i > 0 && nums[i] == nums[i-1])
        {
            continue;
        }
        int left = i + 1;
        int right = nums.size()-1;
        while (left < right)
        {
            int tmp = nums[i] + nums[left] + nums[right];

            if (tmp > 0)
            {
                right--;
            }else if (tmp < 0)
            {
                left++;
            }else
            {
                result.push_back(vector<int>{nums[i],nums[left],nums[right]});
                while (nums[right] == nums[right-1] && left <right)
                {
                    right--;
                }
                //不加限定条件000的情况过不去
                while (nums[left] == nums[left+1] && left < right)
                {
                    left++;
                }
                right--;
                left++;
                
            }
            
        }
        
       }
         return result;
    }
};
// @lc code=end

四数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>>  result;
        if (nums.size() == 0)
        {
            return result;
        }
        sort(nums.begin(),nums.end());
        for (int k = 0; k < nums.size(); k++)
        {
            if (k > 0 && nums[k] == nums[k-1])
            {
                continue;
            }
            for (int i = k+1; i < nums.size(); i++)
            {   
                if (i > k+ 1&& nums[i] == nums[i-1])
                {
                    continue;
                }
                
                int left = i + 1;
                int right = nums.size()-1;
                while (left <right)
                {
                    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 (left <right && nums[left] == nums[left+1])
                        {
                            left++;
                        }
                        while (left <right && nums[right] == nums[right-1])
                        {
                            right--;
                        }
                        left++;
                        right--;
                        
                    }
                    
                }
                
            }
            
        }
            return result;
    }
};

原始代码，剪枝操作的思路如下：

第一个k的剪枝

 if (k > nums.size()-4 || nums[k] > target && nums[k] >= 0) {
            	break; 
            }

先看长度，长度符合要求，看数值，排除负数情况后，看是否大于target，大于的话就可以剪枝了

第二个i的剪枝

 if (i > nums.size()-3||nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }

不剪枝也没啥，就是速度慢一点，核心是双指针的应用