代码随想录训练营第7天LeetCode454四数相加2，LeetCode383救赎信，LeetCode15三数之和，LeetCode18四数之和

代码随想录训练营第七天|LeetCode454四数相加2，LeetCode383救赎信，LeetCode15三数之和，LeetCode18四数之和

题目链接454四数相加2

思路：因为题目要求的结果可以重复，且不仅要统计数量还要统计出现的次数，所以选择map作哈希结构映射。将四个数组分为两两遍历将时间复杂度降到平方，遍历完前面两个数组后将所有的结果和其次数放在map中，然后再遍历后面两个数组，将结果的相反数与前面两个数组结果比较，如果相等就将次数加1。

代码如下：

    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0;
        Map<Integer,Integer> map = new HashMap<>();
        for(int number1 : nums1){
            for(int number2 : nums2){
                int sum1 = number1 + number2;
                map.put(sum1,map.getOrDefault(sum1, 0)+1);//若该元素不存在则存入表中计数为1，已经存在				直接加1
            }
        }
         for(int number3 : nums3){
            for(int number4 : nums4){
                int sum2 = -(number3 + number4);//如果相反数出现在map中，则四个数组中元素相加一定为0
                if(map.containsKey(sum2)){
                    count += map.get(sum2);//返回的次数就是相等的结果出现的次数
                }
            }
        }
        return count;

    }

题目链接383赎金信

思路：本质上还是一个元素在另一个集合中出现的次数，用哈希表法，但由于都是小写字母数组下标可控，所以选择数组作为哈希表，遍历magizine字符串的时候在哈希表对应的位置++，遍历ransomNote字符串的时候在哈希表对应的位置–，如果最后哈希表里面的长度变成了负数，则说明ransomNote字符串中有magizine字符串没有的字符，也就是不能由其构成。

代码如下：

 public boolean canConstruct(String ransomNote, String magazine) {
        int[] HashTable = new int[26];
        if(ransomNote.length() > magazine.length()){
            return false;
        }
        for(int i = 0; i < magazine.length();i++ ){
            HashTable[magazine.charAt(i) - 'a']++;
        }
        for(int i = 0; i < ransomNote.length(); i++){
            HashTable[ransomNote.charAt(i) - 'a']--;
        }
        for(int num:HashTable){
            if(num < 0){
                return false;
            }
        }
        return true;
    }

题目链接15三数之和

思路：本题因涉及去重，用哈希表显得格外繁琐，用双指针思路较为简洁，注重去重细节是关键，详细见代码注释。

代码如下：

public List<List<Integer>> threeSum(int[] nums) {  
	List<List<Integer>> res = 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 res;
            }

            if (i > 0 && nums[i] == nums[i - 1]) {  // 去重a，nums[i] == nums[i+1]不行，因为结果是对三元组去重，而不是同一个三元组不能出现重复的元素
                continue;
            }

            int left = i + 1;
            int right = nums.length - 1;
            while (left < right) {
                int sum = nums[i] + nums[left] + nums[right];
                if (sum > 0) {
                    right--;
                } else if (sum < 0) {
                    left++;
                } else {//方法作用是将数组转为list集合
                    res.add(Arrays.asList(nums[i], nums[left], nums[right]));
		    		// 对b 和 c去重应该放在至少找到一个三元组之后
                    //否则当数组元素都为0时，则会提前退出循环
                    while (left < right && nums[right] == nums[right - 1]) right--;
                    while (left < right && nums[left] == nums[left + 1]) left++;
                    
                    //找到结果后双指针同时向中间移动
                    right--; 
                    left++;
                }
            }
        }
        return res;
}

题目链接18四数之和

思路：大致思路和三数之和类似，多一层for循环，多一层剪枝与去重，需要注意细节，详细见代码。

代码如下：

 public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
       
        for (int i = 0; i < nums.length; i++) {
		
            // 一级剪枝，因为target可能为负数
            if (nums[i] > 0 && nums[i] > target) {
                return res;
            }
		
            if (i > 0 && nums[i - 1] == nums[i]) {    // 一级去重，对nums[i]去重
                continue;
            }
            
            for (int j = i + 1; j < nums.length; j++) {
                 //二级剪枝
                 if (nums[i] + nums[j] > target && nums[i] + nums[j] >= 0) {
                    return res;
                }

                if (j > i + 1 && nums[j - 1] == nums[j]) {  // 二级去重，对nums[j]去重
                    continue;
                }
				//以下和三数之和基本一样
                int left = j + 1;
                int right = nums.length - 1;
                while (left < right) {
		    // nums[i] + nums[j] + nums[left] + nums[right] > target int会溢出
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        res.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        // 对nums[left]和nums[right]去重
                        while (left < right && nums[right] == nums[right - 1]) right--;
                        while (left < right && nums[left] == nums[left + 1]) left++;
					//找到结果后双指针同时向中间移动
                        right--;
                        left++;
                    }
                }
            }
        }
        return res;
 }