day7—哈希完结

454.四数相加 II

思路：本题有四个数组，如果用暴力解法就是4个for循环遍历查找符合要求的元组，时间复杂度为O(n⁴)。本题依旧是查找某个元素是否出现在集合中，所以用哈希法，我们可以用两个for循环去存a+b的数值到哈希表中，然后两个for循环c+d的同时查找0-(c+d)是否在哈希表中，存在的话就记录下来，这样的话时间复杂度就为O(n²)。
注意点：明确了使用哈希法后，还要选择使用哪个结构，我们使用map。为什么呢，因为我们不但需要存a+b的值，还要存a+b这个值出现的次数，因为可能在数组的不同下标获得相同的值，如果遇到相同值的话，key对应的value就++，c+b的循环中就直接把count加上value值就好了。

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer,Integer> map = new HashMap();
        int length = nums1.length;
        int sum = 0;
        int temp = 0;
        int count = 0;
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length; j++) {
                sum = nums1[i] + nums2[j];
                if (map.containsKey(sum)){
                    temp = map.get(sum) + 1;
                    map.put(sum, temp);
                }else {
                    map.put(sum, 1);
                }
            }
        }
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length; j++) {
                temp = 0 - nums3[i] - nums4[j];
                if (map.containsKey(temp)){
                    count = count + map.get(temp);
                }
            }
        }
        return count;
    }
}

383.赎金信

思路：这道题是242.有效的字母异位词的扩展，思路差不多，用数组做哈希表。记录每个字符出现的次数，再用另一个字符串遍历一遍即可。

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

15.三数之和

思路：这道题有两种方法。

• 哈希法：两层for循环确定a和b的值，然后在数组查找是否存在0-(a+b)，问题是给abc去重比较复杂，不推荐使用。
• 双指针法：这道题用双指针法。首先将数组排序，有利于后续操作。定义一个i指针遍历数组，left指针为i+1，right指针为最后一个元素。在确定i的情况下，三个数相加大于0则让right–，三个数相加小于0则让left++，直到等于0。还有就是去重的操作：给a去重nums[i] == nums[i-1]，给b去重nums[left]==nums[left+1]，给c去重nums[right]==nums[right-1]。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList();
        Arrays.sort(nums);
        for (int i=0; i<nums.length; i++){
            if (i == 0 && nums[i]>0){
                return result;
            }
            //给a去重
            if (i > 0 && nums[i] == nums[i-1]){
                continue;
            }
            int left = i+1;
            int right = nums.length-1;
            while(left < right){
                if (nums[i]+nums[left]+nums[right] < 0){
                    left++;
                }else if(nums[i]+nums[left]+nums[right] > 0){
                    right--;
                }else {
                    result.add(Arrays.asList(nums[i],nums[left],nums[right]));
                    //给b去重
                    while(left<right && nums[left]==nums[left+1]){left++;}
                    //给c去重
                    while(left<right && nums[right]==nums[right-1]){right--;}
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
}

四数之和

思路：在三数之和的基础上，加了一层循环，也是用双指针法。不过要注意剪枝和去重操作。

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++) {
            //1级剪枝
            if (nums[i] > 0 && nums[i] > target) {
                return result;
            }
            //1级去重
            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            for (int j = i + 1; j < nums.length; j++) {
                //2级去重
                if (j > i + 1 && nums[j] == nums[j - 1]) {
                    continue;
                }
                int left = j + 1;
                int right = nums.length - 1;
                while (left < right) {
                    long sum = (long) nums[i] + nums[j] + nums[left] + nums[right];
                    if (sum < target) {
                        left++;
                    } else if (sum > target) {
                        right--;
                    } else {
                        result.add(Arrays
                                .asList(nums[i], nums[j], nums[left], nums[right]));
                        //去重left
                        while (left < right && nums[left] == nums[left + 1]) {
                            left++;
                        }
                        //去重right
                        while (left < right && nums[right] == nums[right - 1]) {
                            right--;
                        }
                        left++;
                        right--;
                    }
                }

            }
        }
        return result;
    }
}

哈希表总结

一般来说，哈希表用于查找某个元素是否存在于集合中。
对于哈希表，要知道要知道哈希函数和哈希碰撞
哈希函数是把传入的key映射到哈希表的索引上。
哈希碰撞是多个key映射到了同一个索引。
解决哈希碰撞一般两种方法：拉链法和线性探测法。
哈希表一般使用三种数据结构：

• 数组
• Set
• Map

哈希表结构主要用来做映射，并快速判断元素是否在集合中有相应的映射。