【刷题day7】哈希表 | 454.四数相加II、383. 赎金信、15. 三数之和、18. 四数之和、总结

454.四数相加II

题目链接
文章讲解

思路： 参考两数之和的思想，将ABCD分为两组，用map记录AB组各个元素之和（键）以及出现此和的情况个数（值），再分别求CD两数组中各个元素的和，并且在map中找 -(C+D) 的值及其情况个数，累加便可以得到最终结果。
与两（三、四）数之和不同的是，这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用像在一个数组上那样考虑重复的四个元素相加等于0的情况。

class Solution {
    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
        Map<Integer, Integer> countAB = new HashMap<Integer, Integer>();
        // 统计AB两个数组中的元素之和，同时统计出现的次数，放入map
        for (int u : A) {
            for (int v : B) {
                countAB.put(u + v, countAB.getOrDefault(u + v, 0) + 1);
            }
        }
        int ans = 0;
        // 统计CD两个元素的和，在map中找是否存在与其相加为0的情况，同时记录次数
        for (int u : C) {
            for (int v : D) {
                if (countAB.containsKey(-u - v)) {
                    ans += countAB.get(-u - v);
                }
            }
        }
        return ans;
    }
}

383. 赎金信

题目链接
文章讲解

思路： 这道题目和 242.有效的字母异位词 很像，242.有效的字母异位词 相当于求字符串 a 和字符串 b 是否可以相互组成（要求长度相等） ，而这道题目只是求字符串 a 能否组成字符串 b，而不用管字符串 b 能不能组成字符串 a。

class Solution { //数组存储
    public boolean canConstruct(String ransomNote, String magazine) {
    	if(ransomNote.length() > magazine.length()) return false;
    	int[] mag = new int[26];
    	for(char mc: magazine.toCharArray()) {
    		mag[mc - 'a']++;
    	}
    	for(char rc: ransomNote.toCharArray()) {
    		mag[rc - 'a']--;
    		if(mag[rc - 'a'] < 0) return false;
    	}
    	return true;
    }
}

class Solution { //哈希表存储
    public boolean canConstruct(String ransomNote, String magazine) {
    	Map<Character, Integer> mp = new HashMap<>();
    	for(char cm: magazine.toCharArray()) {
    		mp.put(cm, mp.getOrDefault(cm, 0) + 1);
    	}
    	for(char cr: ransomNote.toCharArray()) {
    		if(mp.containsKey(cr) && mp.get(cr) > 0) {
    			mp.put(cr, mp.get(cr) - 1);
    		}else {
    			return false;
    		}
    	}
    	return true;
    }
}

15. 三数之和

题目链接
文章讲解

思路： 这道题目使用哈希法并不十分合适，因为在去重的操作中有很多细节需要注意。使用双指针法要比哈希法高效一些。

1. 哈希表做法

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
    	List<List<Integer>> ans = new ArrayList<>();
    	List<Integer> temp = new ArrayList<>();
    	int len = nums.length;
    	Arrays.sort(nums);//方便去重
    	// 找出a + b + c = 0
        // a = nums[i], b = nums[j], c = -(a + b)
    	for(int i=0; i<len; i++) {
    		// 排序之后如果第一个元素已经大于零，那么不可能凑成三元组 
    		if (nums[i] > 0) {break;}
    		//三元组元素a去重
             if (i > 0 && nums[i] == nums[i - 1]) {continue;}
    		
        	Set<Integer> s = new HashSet<>();
        	for(int j=i+1; j<len; j++) {
        		// 三元组元素b去重
                if (j > i + 2 && nums[j] == nums[j-1] && nums[j-1] == nums[j-2]) { 
                    continue;
                }
        		if(s.contains(- nums[i] - nums[j])) {
        			temp = Arrays.asList(new Integer[] {nums[i], nums[j], - nums[i] - nums[j]});
        			ans.add(temp);
                    // 三元组元素c去重
        			s.remove(- nums[i] - nums[j]);
        		}else {
        			s.add(nums[j]);
        		}
        	}
    	}
        return ans;
    }
}

2. 双指针做法

• 首先将数组排序，然后有一层for循环，i从下标0的地方开始，同时定一个下标left 定义在i+1的位置上，定义下标right 在数组结尾的位置上。
• 如果nums[i] + nums[left] + nums[right] > 0 就说明 此时三数之和大了，因为数组是排序后了，所以right下标就应该向左移动，这样才能让三数之和小一些。
• 如果 nums[i] + nums[left] + nums[right] < 0 说明 此时 三数之和小了，left 就向右移动，才能让三数之和大一些，直到left与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;
    }
}

注意：a去重时是判断 nums[i] 与 nums[i + 1] 是否相同，还是判断 nums[i] 与 nums[i-1] 是否相同。这两种方式所带来的结果是不一样的。如果是第一种方式，我们就把三元组中出现重复元素的情况直接pass掉了。 例如{-1, -1 ,2} 这组数据，当遍历到第一个-1 的时候，判断 下一个也是-1，那这组数据就pass了。我们要做的是不能有重复的三元组，但三元组内的元素是可以重复的！

18. 四数之和

题目链接
文章讲解

思路： 双指针法。基本解法就是在15.三数之和 的基础上再套一层for循环。
有一些细节需要注意，例如： 剪枝操作不要只判断 nums[i] > target 就返回了，三数之和可以通过 nums[i] > 0 就返回，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是[-4, -3, -2, -1]，target是-10，不能因为-4 > -10而跳过。但是我们依旧可以去做剪枝，逻辑变成nums[i] > target && (nums[i] >=0 || target >= 0) 就可以了。

454.四数相加II ，相对于本题简单很多，因为本题是要求在一个集合中找出四个数相加等于target，同时四元组不能重复。而454.四数相加II 是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况。

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
       
        for (int i = 0; i < nums.length; i++) {
            // nums[i] > target 直接返回, 剪枝操作
            if (nums[i] > 0 && nums[i] > target) {
                return result;
            }
            if (i > 0 && nums[i - 1] == nums[i]) {    // 对nums[i]去重
                continue;
            }
 
            for (int j = i + 1; j < nums.length; j++) {
                if (j > i + 1 && nums[j - 1] == nums[j]) {  // 对nums[j]去重
                    continue;
                }
                int left = j + 1, right = nums.length - 1;
                while (right > left) {
		        // nums[k] + nums[i] + 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 {
                        result.add(Arrays.asList(nums[i], nums[j], nums[left], nums[right]));
                        // 对nums[left]和nums[right]去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;
                        left++;
                        right--;
                    }
                }
            }
        }
        return result;
    }
}

454. 总结

文章总结