代码随想录day07

第454题.四数相加II

题目：给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

        此题使用的是哈希表法，首先定义 一个map，用于存放a和b两数之和，value 放a和b两数之和出现的次数。遍历A和B数组，统计两个数组元素之和，和出现的次数，放到map中。定义int变量count，用来统计 a+b+c+d = 0 出现的次数。在遍历C和D数组，找到如果 -(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来。最后返回统计值 ans就可以了

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4){
        int ans=0;
        map<int,int> mymap;
        for(int i=0;i<nums1.size();++i){//对第一第二个数组元素之和进行处理
            for(int j=0;j<nums2.size();++j){
                int a=nums1[i];
                int b=nums2[j];
                mymap[a+b]++;
            }
        }
        for(int i=0;i<nums3.size();++i){//在第三第四个数组中尽显查找是否存在对应的值
            for(int j=0;j<nums4.size();++j){
                int temp=-(nums3[i]+nums4[j]);
                if(mymap.find(temp)!=mymap.end()){
                    ans+=mymap[temp];
                }
            }
        }   
        return ans;                                   
    }
};

 383. 赎金信

题目：给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

        该题思路与有效的字母异位词思路完全一样，均是定义一个长为26的标记数组，对两个字符数组进行相反的操作，最后判断标记即可。

bool canConstruct(char* ransomNote, char* magazine) {
    int isexist[26]={0};
    for(int i=0;i<strlen(magazine);++i){
        isexist[magazine[i]-'a']++;
    }
    for(int i=0;i<strlen(ransomNote);++i){
        isexist[ransomNote[i]-'a']--;
    }
    for(int i=0;i<26;++i){
        if(isexist[i]<0){
            return false;
        }
    }
    return true;                           
}

 15题. 三数之和

题目：给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意： 答案中不可以包含重复的三元组。

        排序加双指针 

        此题要求三个数不相同，因此去重是关键，视同哈希表法，去重操作十分复杂。此题只要返回值，而不需要下标，故此题最好的做法是先排序在用双指针进行查找。

class Solution {
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) {
                return result;
            }
            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[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]});
                    // 去重逻辑应该放在找到一个三元组之后，对b 和 c去重
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    // 找到答案时，双指针同时收缩
                    right--;
                    left++;
                }
            }

        }
        return result;
    }
};

18题. 四数之和

题目：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：答案中不可以包含重复的四元组。

        思路同上题，使用双指针进行查找，就是多了一个循环。使用两个for循环。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> ans;
        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 {
                        ans.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 ans;
    }
};

16.最接近的三数之和

给你一个长度为 n 的整数数组 nums 和 一个目标值 target。请你从 nums 中选出三个整数，使它们的和与 target 最接近。

返回这三个数的和。

假定每组输入只存在恰好一个解。

int cmp(int *a,int* b){
    return *a-*b;
}
int threeSumClosest(int* nums, int numsSize, int target) {
    qsort(nums,numsSize,sizeof(int),cmp);
    int ans=nums[0]+nums[1]+nums[2];
    for(int i=0;i<numsSize;++i){
        int start=i+1,end=numsSize-1;
        while(start<end){
            int sum=nums[start]+nums[end]+nums[i];
            if(abs(target-sum)<abs(target-ans)){
                ans=sum;
            }
            if(sum>target){
                end--;
            }else if(sum<target){
                start++;
            }else{
                return ans;
            }
        }
    }
    return ans;
}