代码随想录一刷(day07) |454.四数相加II|383. 赎金信|15. 三数之和|18 四数之和

454.四数相加II leetcode链接

思考

直接使用四层for循环遍历出所有的四数相加的结果，选出其中和为0的结果。最终方法算法时间复杂度为O(n^4)，并不太可取。可以使用map记录出其中前两组（A+B）组合相加的和的结果，并且在结果相同时将其对应的map中的value也加一。定义变量count记录四数相加等于零的情况出现的次数。遍历后两组(C+B)，如果 0-(c+d) 在map中出现过的话，就用count把map中key对应的value也就是出现次数统计出来

代码展示

    public static int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        int count = 0;
        HashMap<Integer, Integer> hashMap = new HashMap<>();

        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                int sum1 = nums1[i] + nums2[j];
                if (hashMap.get(sum1) == null){
                    hashMap.put(sum1,1);
                }else{
                    hashMap.put(sum1,hashMap.get(sum1)+1);
                }
            }
        }
        for (int i = 0; i < nums3.length; i++) {
            for (int j = 0; j < nums4.length; j++) {
                int sum2 = nums3[i] + nums4[j];
                if(hashMap.get(0-sum2)!=null){
                    count += hashMap.get(0-sum2);
                }
            }
        }
        return count;
    }

总结

由于本题只需要求出A[i] + B[j] + C[k] + D[l] = 0即可，并不考虑排重，是使用哈希法解决的经典题目

383. 赎金信 leetcode链接

思考

使用hashMap记录第一个字符串中的每一个字母[key]-以及每一个字母出现的次数[value]，使用for循环遍历第二个字符串中的每一个字符，判断hashMap中有没有该字符，如果有就取出hashMap的value并重新将其设置为value-1，最终遍历hashMap查看里面每一个key对应的value是否为0，如果都为零，返回true，否则返回false

代码展示

    public static boolean canConstruct(String ransomNote, String magazine) {
        //判断 ransomNote 能不能由 magazine 里面的字符构成
        HashMap<Character, Integer> hashMap = new HashMap<>();
        for (int i = 0; i < ransomNote.length(); i++) {
            char c = ransomNote.charAt(i);
            Integer value = hashMap.get(c);
            if (value!=null){
                hashMap.put(c,++value);
            }else {
                hashMap.put(c,1);
            }
        }

        for (int i = 0; i < magazine.length(); i++) {
            char c = magazine.charAt(i);
            Integer value = hashMap.get(c);
            if (value!=null&&value!=0){
                hashMap.put(c,--value);
            }
        }
        for (Character character : hashMap.keySet()) {
            if (hashMap.get(character)!=0){
                return false;
            }
        }
        return true;
    }

总结

hashMap适合记录元素出现的次数，set适合记录元素是否出现过，数组常常在元素个数一定的时候考虑 

三数之和 leetcode链接

思考

哈希法： 使用两个for循环就可以得到a , b 的值了，再使用哈希法判断 0 - (a + b)是否在数组中出现过，然而本题要求不可以包含重复的三元组。按照哈希法，会将符合条件的三元组放入到List中，最终需要再对List集合进行去重，能做的剪枝操作很有限，去重的过程中需要注意很多小细节，如果在面试中很难想到位。

双指针法：先将数组进行由小到大的排序，使用一个for循环遍历数组nums，并在遍历时判断nums[i]是否大于0，由于此时的数组是有序的，所以如果大于零，就可以直接返回之前找到的resultList结果【此为第一次剪枝】，如果不大于0且i大于一，判断nums[i]和nums[i-1]是否相等，如果相等就就进行去重操作，并且continus进入下一次循环。而在i的后面，设置left和right两个下标，分别指向i的后面和数组的末尾下标，在while循环中【条件right > left】判断nums[i] + nums[left] + nums[right]的和是否大于0，如果大于零就将right--,如果小于零就将left++，如果等于零就将这三个下标对应的值放入到List集合中，之后再判断使用while循环【right > left情况下】nums[left+1]和nums[left]是否相等，如果相等就将left++【后移一位】。同理判断nums[right+1]和nums[right]是否相等,如果相等就将right--【前移一位】。最终再将left++,right--，直到right > left再将i++，进入下一次循环。直到i 遍历完整个数组。

代码展示

    public static List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> resultList = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) {
                return resultList;
            }
            if (i > 0 && nums[i] == nums[i - 1]) {
                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 {
                    resultList.add(Arrays.asList(nums[i],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 resultList;
    }

总结【摘抄自代码随想录】

这道题目使用哈希法并不十分合适，因为在去重的操作中有很多细节需要注意，在面试中很难直接写出没有bug的代码。而且使用哈希法 在使用两层for循环的时候，能做的剪枝操作很有限，虽然时间复杂度是O(n^2)，也是可以在leetcode上通过，但是程序的执行时间依然比较长 。这道题目使用双指针法 要比哈希法高效一些

 18 四数之和 leetcode链接

思考

四数之和的思路和三数之和大体一致，只需在三数之和的基础上在外层加一个for循环即可，需要注意的是： 不要在第一次for循环中判断nums[k] > target 就返回了，因为本题的target是一个不确定的数，应该加一个判断 &&nums[k] > 0；在第二个for循环中同理

代码展示

    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> resultList = new ArrayList<>();
        for (int k = 0; k < nums.length; k++) {

            if (nums[k] > 0 && nums[k] > target) {
                return resultList;
            }
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;//去重
            }
            for (int i = k + 1; i < nums.length; i++) {
                if (nums[i] + nums[k] > 0 && target > 0 && nums[i] + nums[k] > target) {
                    break;
                }
                if (i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;//去重
                }
                int left = i + 1;
                int right = nums.length - 1;
                while (right > left) {
                    long sum = (long) nums[k] + nums[i] + nums[left] + nums[right];//防止数据溢出
                    if (sum > target) {
                        right--;
                    } else if (sum < target) {
                        left++;
                    } else {
                        resultList.add(Arrays.asList(nums[k], nums[i], 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 resultList;
    }

总结

四数之和看起来只比三数之和多一层for循环，还要注意本题的target的正负不确定性。