Day7 哈希表part2

Day7

一、454. 四数相加 II

文章链接

1. 思路分析

暴力解法是$O(n^4)$的时间，比这少就赢！

分析题目可知，结果是不用去重的，只要数据的序号不完全一样就行。
并且不用把序号写出来，只是记录个个数即可。
解法竟然是两两分批遍历，通过map记录前两个数组的遍历结果，然后利用后两个数组的遍历去寻找符合条件的元组数目。

上面所说只是大概的，要记录的是什么呢？前一组遍历是两数之和，以及这种和出现的次数。
后一组遍历就是将和算出来的同时，在map里进行搜寻。如果能找到与本组和相加为0的键，就让总数量加上这个键所对的值。
将后两个数组的数据组合遍历一遍，搜寻一遍，就计算出了全部的个数。

2. 解法分析

第一块代码是听完思路后写的，很朴素，但是代码多，比较慢。
第二块代码是借鉴的，里面有一些用法很需要我记得用：

• for-each循环（只需取值的时候好用）
• getOrDefault方法
  

3. 代码展示

import java.util.HashMap;

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

import java.util.HashMap;

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int res = 0;
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        //统计两个数组中的元素之和，同时统计出现的次数，放入map
        for (int i : nums1) {
            for (int j : nums2) {
                int sum = i + j;
                map.put(sum, map.getOrDefault(sum, 0) + 1);
            }
        }
        //统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
        for (int i : nums3) {
            for (int j : nums4) {
                res += map.getOrDefault(0 - i - j, 0);
            }
        }
        return res;
    }
}

二、383. 赎金信

文章链接

1. 思路分析

好像英文字母查找的题目，就是对数组哈希表的天然适配。

没什么特别好说的， 和 242.有效的字母异位词 是一个思路。
遍历，将库字符串的字母数目统计到数组哈希表当中，之后再遍历目标字符串，遍历到一个减去一个数目。一旦有一个减完以后是负一，则说明ransomNote 不能由 magazine 里面的字符构成返回false。

循环结束后return true。

2. 解法分析

特别需要注意的是Java字符串的处理方法，和C++大有不同。
在Java中，字符串是不可变的，这意味着一旦创建了一个字符串对象，就不能修改它的值。因此，如果需要对字符串进行修改或遍历其中的每个字符，则需要将其转换为字符数组。

在本题中就使用了string.toCharArray()，将字符串转换为字符数组，并使用增强for循环遍历其中的每个字符。

3. 代码展示

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] array = new int[26];
        for (char i : magazine.toCharArray()) {
            array[i-'a']++;
        }
        for (char i : ransomNote.toCharArray()) {
            if (--array[i-'a'] < 0) 
                return false;
        }
        return true;
    }
}

三、15. 三数之和（难）

文章链接

1. 思路分析

这题实是有些恐怖，其中需要思考和顾虑的地方太多。就算是听完了讲解视频，自己去实现也是出现了很多问题。
接下来就大致讲解一下本题的思路吧！

双指针法。
本题名称为三数之和，实际上和 两数之和 那道题有所不同。这次由于返回的是数值本身，所以需要去重。由于听闻哈希法边界条件过多，尤其复杂，于是只了解了双指针法。

双指针法的本身原理是不难。
首先将数组进行排序。然后定义一层for循环，i从下标0的地方开始遍历数组，同时下标left 定义在i+1的位置上，下标right 定义在数组结尾的位置上。

那么指针应该怎么动呢？
要求这三个指针所指向的三个数的和。
若和大于0，则要减小它们。i是肯定不能动了，这时就该right–。
若和小于0，则要增大它们，即left++。
而当和等于0时，就使用ArrayList记录下来，装到表示结果的ArrayList里面。
并且双指针同时收缩，继续寻找这个i对应的下一个三元组。

最需要深思熟虑的地方是如何去重。

首先是i的去重。
有两种方案：nums[i] == nums[i - 1]时 continue，
或者nums[i] == nums[i + 1]时 continue。
要选择nums[i] == nums[i - 1]时。
因为如果选择后者，那么现在的i就是该数值的最后一个。
但问题是，同一个三元组，数值是可以重复的，也就是说left的值是可以等于i的值的。
而后者的方案显然忽略了这个问题，它不能让i和left的值都为-1，所以会遗漏一些。

然后是left与right的去重。
有一种特殊情况，就是整个数组全都为0的情况。如果我们一上来就给left和right去重，那么无疑会遗漏这种特殊情况。
所以，我们先记录，再去重。
之前我对这种方式怀疑，因为觉得最终左右指针会落在重复的最后一位数值上，从而导致再录入一次。
但我没有想到的是，在录入一次以后，双指针会收缩，所以在下一轮while循环会恰好指在不重复的那一位上。
而且我们是把去重操作放在了真正录入以后，用来去掉可能的重复录入，而不是放在if-else之外每一次都执行，那样没有意义。

最后有一点，若nums[i]都大于0了，那就不存在以nums[i]为基准的三元组了，直接return就完事了。

2. 解法分析

还有一些值得注意的就是Java的系统自带方法调用以及数据结构的认识与应用。我在Java上对这方面的基础完全不如C++，要多加积累，多加学习。

比如：

• Arrays.sort(nums); // Java的排序方法调用
• List result = new ArrayList<>(); // ArrayList顺序表。追求线程安全就用Vector。
• Arrays.asList(nums[i], nums[left], nums[right]) // 生成一个临时的匿名列表对象。省去了那么多add的步骤。

3. 代码展示

import java.util.Arrays;

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums); //Java的排序方法调用
        //相当于创建了一个顺序表的顺序表。和二维数组原理相同。
        List<List<Integer>> result = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            //若nums[i]都大于0了那相加就不可能为0了
            if (nums[i] > 0)
                break;
            //nums[i]的去重
            //不能与nums[i + 1]作比较，因为可能会遗漏i与left对应数据相等的情况。
            if (i > 0 && nums[i] == nums[i - 1]) 
                continue;
            int left = i + 1;
            int right = nums.length - 1;
            while (right > left) {
                //考虑到当数组全为0的情况，要先记录，再去重
                if (nums[i] + nums[left] + nums[right] > 0) {
                    right--;
                }
                else if (nums[i] + nums[left] + nums[right] < 0) {
                    left++;
                }
                else {
                    // List<Integer> list = new ArrayList<>();
                    // list.add(nums[i]);
                    // list.add(nums[left]);
                    // list.add(nums[right]);
                    // result.add(list);
                    /* 上面是比较笨的语法，下面是通过Arrays.asList方法
                    创建一个临时的匿名列表对象。
                    它将传递给它的参数转换为一个固定长度的列表，
                    并返回这个列表对象。*/
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
                     //nums[left]与nums[right]的去重。
                    while (right > left && nums[left] == nums[left + 1])
                        left++;
                    while (right > left && nums[right] == nums[right - 1])
                        right--;
                    // 找到答案时，双指针同时收缩。
                    left++; right--;
                }
               
            }
        }
        //返回值
        return result;
    }
}

四、18. 四数之和（与上题同思路）

文章链接

1. 思路分析

参考三数之和的双指针法，只是套上了两层for循环，在i的遍历之外加上一层j的遍历。

改动的地方是剪枝条件，需要target >= 0并且nums[j] > 0。（负数相加会更小）

还有一处是sum改成long，并把第一个数转成long，确保四个值相加时不会由于int容量不足而发生溢出。

2. 解法分析

要多加注意代码的准确率，因为这个报错了好几次。详情都在注释里。

3. 代码展示

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> result = new ArrayList<>();
        for (int j = 0; j < nums.length; j++) {
            // 一开始写成 j > target 了
            if (target >= 0 && nums[j] > target) 
                return result;
            if (j > 0 && nums[j] == nums[j-1])
                continue;
            for (int i = j + 1; i < nums.length; i++) {
                if (i > j + 1 && nums[i] == nums[i-1]) 
                    continue;
                int left = i + 1;
                int right = nums.length - 1;
                while (left < right) {
                    // 使用了强制类型转换(long)将nums[j]转换为long类型，以确保四个值相加时不会发生溢出。
                    long sum = (long)nums[j] + nums[i] + nums[left] + nums[right];
                    // 一开始把target写成0了谁懂
                    if (sum > target) {
                        right--;
                    }
                    else if (sum < target) {
                        left++;
                    }
                    else{
                        result.add(Arrays.asList(nums[j],nums[i],nums[left],nums[right]));
                        // 匪夷所思，怎么能有人把索引的+1和-1写到中括号外面去啊，服了！
                        while (left < right && nums[left] == nums[left + 1] )
                            left++;
                        while (left < right && nums[right] == nums[right - 1])
                            right--;
                        left++; right--;
                    }
                }
            }
        }
        return result;
    }
}

五、总结

题目不简单，做了很久。
重回正规第一天，以后也这样坚持吧！