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

454：四数相加

第一次想的时候想到用一个current表示四个元素之和，然后，每次依次挖掉一个，去对应数组中找有无满足相加等于0的数。但是忽略了这是四个数相加而不是两个数相加，导致忽略了同时改变多个位置的情况。

第二次想的时候想着用一个哈希表存储第一个数组和第二个数组的和，再把该哈希表中的值和第三个数组一一遍历求和再存在一个表中，依次类推，直到把所有的都加完，那么看最后有几个0就行。但是因为哈希表中的值不能重复，所以会导致漏算，回头去改的话发现好像不好跟踪到。

最后看了题解就恍然大悟了。用HashMap记录每个和的次数就可以避免漏算的情况。

因为本题是四数相加，因此可以分组计算，nums1和nums2一组，nums3和nums4一组。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0;
        HashMap<Integer, Integer> map1 = new HashMap<>();
        HashMap<Integer, Integer> map2 = new HashMap<>();
        
        for(int a:nums1){
            for(int b:nums2){
                if(map1.containsKey(a+b)) {
                	map1.put(a+b, map1.get(a+b)+1);
                }else {
					map1.put(a+b, 1);
				}
            }
        }
        for(int a:nums3){
            for(int b:nums4){
                if(map2.containsKey(a+b)) {
                	map2.put(a+b, map2.get(a+b)+1);
                }else {
					map2.put(a+b, 1);
				}
            }
        }
        for(Integer a:map1.keySet()){
            for(Integer b:map2.keySet()){
                if((a+b)==0) {
                	count += map1.get(a)*map2.get(b);
                }
            }
        }
        
        return count;
    }
}

 383：赎金信

与242有效的字母异位词类似，只是判断条件变了，对于该题，最后的count元素会出现三种情况：

大于0	说明magazine中的字母数量不够ransomNote，返回false
小于0	说明ransomNote中不需要该字母，不影响结果
等于0	说明magazine中的字母数量刚好相等ransomNote，返回true

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

15：三数之和

先进行排序，再利用双指针求解，注意去重操作。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        int len = nums.length;
        List<List<Integer>> resList = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < len-2; i++) {
        	if (nums[i]>0) {
				return resList;
			}
        	if ((i>0)&&(nums[i]==nums[i-1])) {
				continue;
			}
        	for (int left = i + 1, right = len - 1; left<right;) {
				if ((nums[i]+nums[left]+nums[right])>0) {
					right--;
				}else if ((nums[i]+nums[left]+nums[right])<0) {
					left++;
				}else {
					resList.add(Arrays.asList(nums[i],nums[left],nums[right]));
					while (left<right) {
						if (nums[left+1]==nums[left]) {
							left++;
						}else {
							break;
						}	
					}
					while (left<right) {
						if (nums[right-1]==nums[right]) {
							right--;
						}else {
							break;
						}	
					}
					left++;
					right--;
				}
			}
		}
        return resList;
    }
}

18：四数之和

在三数之和的基础上再加一层循环。

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
      	int len = nums.length;
        List<List<Integer>> resList = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < len-3; i++) {
        	if ((nums[i]>0)&&(nums[i]>target)) {
				return resList;
			}
        	if ((i>0)&&(nums[i]==nums[i-1])) {
				continue;
			}
        	for (int j = i+1; j < len-2; j++) {
        		if ((j>i+1)&&(nums[j]==nums[j-1])) {
					continue;
				}
        		for (int left = j + 1, right = len - 1; left<right;) {
        			int sum = nums[i]+nums[j] + nums[left]+nums[right];
    				if (sum>target) {
    					right--;
    				}else if (sum<target) {
    					left++;
    				}else {
    					resList.add(Arrays.asList(nums[i],nums[j],nums[left],nums[right]));
    					while (left<right) {
    						if (nums[left+1]==nums[left]) {
    							left++;
    						}else {
    							break;
    						}	
    					}
    					while (left<right) {
    						if (nums[right-1]==nums[right]) {
    							right--;
    						}else {
    							break;
    						}	
    					}
    					left++;
    					right--;
    				}
    			}
			}
        	
		}
        return resList;
    }
}

总结：具体问题具体分析，选择合适的求解方法。