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

454.四数相加II 

import java.util.HashMap;
import java.util.Map;

public class day7_454_四数相加 {
    public static void main(String[] args) {
        
    }
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {

        //四个for 的话时间复杂度就是4次方了，随意进行分组，这样就是2Xn的平方，这样
        //操作的话会增加查找过程，但是查找是哈希的优点，总体还是降低的
        int res=0;
        Map<Integer,Integer>map1=new HashMap<>();
        
        //创建两个分组的哈希map
        //接着去搞前两个
        for(int i=0;i<nums1.length;i++){
            for(int j=0;j<nums2.length;j++){
                //这时候去把两个数的和去加进去，存在就加一，
                map1.put((nums1[i]+nums2[j]),map1.getOrDefault((nums1[i]+nums2[j]), 0)+1);
                //这个瑜语句就是 把和当成key放进去，如归目前这个he已经存在 value就等于目前的value加上1，如果没就是0+1；
                


            }
        }
        //这里把前两个循环完毕
        //接下来循环的就是后面剩下的两个
        for(int i:nums3){
            for (int j : nums4) {
                res+=map1.getOrDefault(0-i-j, 0);
                //这里的意思就是，0-i-j得到的就是负数，加上map1里面的数字如果是0就符合结果，现在就去查找，如果符合要求了，就把res加上一个value如果没有就
                //加上一个0；


                
            }
        }
        return res;


    }

    
}

这题就是用哈希查找去节省时间复杂度，正常来说是4次方，现在是2次方加2次方然后再加上哈希查找的时间，先把前两个数组加起来v遍历然后存在了第一个hash中，记得要保存每个和出现的次数，然后去遍历后两个，如果和为0 就把res加上对应的次数，其中要注意的是=map1.getOrDefault这个函数的运用，这个高清，其他没啥问题

383. 赎金信

public class day7_383_赎金信 {
    public static void main(String[] args) {
        
    }
    public static boolean canConstruct(String ransomNote, String magazine) {
        //哈希判断即可
        int[] res=new int[26];
        //因为是英文字母所以就是ascll码
        for(int i=0;i<ransomNote.length();i++){
            res[(ransomNote.charAt(i)-'a')]+=1;
        }
        for(int j=0;j<magazine.length();j++){
            res[(magazine.charAt(j)-'a')]-=1;
            if (res[(magazine.charAt(j)-'a')]<0) {
                return false;
                
            }
        }
        return true;



    }

    
}

这题用简单的hash数组就行，要注意是谁由谁组成，别弄反了

15. 三数之和

第一种方法只用set进行去重思路简单，但是时间复杂度比较久

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class day7_15_三数之和 {
    public static void main(String[] args) {
        
    }
    public List<List<Integer>> threeSum(int[] nums) {
        Set<List<Integer>> output= new  HashSet<>();
        Arrays.sort(nums);//对数组进行了排序，从小到大
        List<List<Integer>> demo = new ArrayList<>();
        for(int i=0;i<nums.length;i++){
            int last=nums.length-1;
            int left=i+1;
            
            while (left<last) {
                int sum=nums[i]+nums[left]+nums[last];
                if (sum>0) {
                    last-=1;
                    
                }
                if (sum<0) {
                    left+=1;  
                }
                if (sum==0) {
                    List<Integer> list1=new ArrayList<>();
                    list1.add(nums[i]);
                    list1.add(nums[left]);
                    list1.add(nums[last]);
                    output.add(list1);
                    last-=1;
                }

                
            }
             demo = new ArrayList<>(output);

        }
        return demo;


    }

    
}

第二种就是 双指针法，分为i去重和leftright去重

一个大前提就是排序，一定要记得排序，

三个数字，

第一步我们先去循环，确定的就是第一个数，

i  left  right三个数字

比如-1 -1 -1 -1 0 0 0 0 2 2 2 2 

结果只有-1 -1 2 还有000

我们遍历第一次-1时候就把-1开头的所有结果都遍历出来了，

所以后面在遇到-1开头的直接跳过就行，不用担心我们会用到好几个-1如果用到两个-1 那第三个就确定了，所以一定是重复的，

i去重后，就是left和right  因为这两个数是在i确认的前提下的，所以，当遇到left等于前一个left直接跳过就好，因为left确定了 right也就确定了，，right跳过同理

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
	// 找出a + b + c = 0
        // a = nums[i], b = nums[left], c = nums[right]
        for (int i = 0; i < nums.length; i++) {
	    // 排序之后如果第一个元素已经大于零，那么无论如何组合都不可能凑成三元组，直接返回结果就可以了
            if (nums[i] > 0) { 
                return result;
            }

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

            int left = i + 1;
            int right = nums.length - 1;
            while (right > left) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0) {
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {
                    result.add(Arrays.asList(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. 四数之和

这一题思路和三数之和区别不大，主要是多了一层for循环