代码随想录算法训练营第七天-哈希表 | 454.四数相加II 383. 赎金信 15. 三数之和 18. 四数之和

454.四数相加II

本题是使用哈希法的经典题目，而0015.三数之和，0018.四数之和 并不合适使用哈希法，因为三数之和和四数之和这两道题目使用哈希法在不超时的情况下做到对结果去重是很困难的，很有多细节需要处理。

而这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况，所以相对于题目18. 四数之和（一个数组里需要考虑去重），题目15.三数之和，还是简单了不少！

import java.util.HashMap;
import java.util.Map;

public class FourSum2 {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4){
        Map map = new HashMap<>();
        int temp;
        int res = 0;
        //统计两个数组中的元素之和，同时统计出现的次数，放入map
        for(int i : nums1){
            for (int j : nums2){
                temp = i + j;
                if(map.containsKey(temp)){
                   map.put(temp, map.get(temp) + 1);
                }else {
                    map.put(temp,1);//temp没出现过
                }
            }
        }
        //统计剩余的两个元素的和，在map中找是否存在相加为0的情况，同时记录次数
        for(int i : nums3){
            for (int j : nums4){
                temp = i + j;//重新的for循环需要再写一次
                if(map.containsKey(0 - temp)){
                     res += map.get(0 - temp);
                }
            }
        }
        return res;
    }
}

383. 赎金信

这道题目和242.有效的字母异位词很像，242.有效的字母异位词 相当于求 字符串a 和 字符串b 是否可以相互组成 ，而这道题目是求 字符串a能否组成字符串b，而不用管字符串b 能不能组成字符串a。

本题判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成，但是这里需要注意两点。

• 第一点“为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思”  这里说明杂志里面的字母不可重复使用。

• 第二点 “你可以假设两个字符串均只含有小写字母。” 说明只有小写字母，这一点很重要

因为题目所只有小写字母，那可以采用空间换取时间的哈希策略， 用一个长度为26的数组还记录magazine里字母出现的次数。

然后再用ransomNote去验证这个数组是否包含了ransomNote所需要的所有字母。

依然是数组在哈希法中的应用。

public class RansomNote {
    public boolean canConstruct(String ransomNote, String magazine){
        // 定义一个哈希映射数组
        int[] record = new int[26];
        //遍历
        for(char c : magazine.toCharArray()){
            record[c - 'a'] +=1;//record[c - 'a'] ++
        }
        for (char c : ransomNote.toCharArray()){
            record[c - 'a'] -=1;//record[c - 'a'] --
        }
        // 如果数组中存在负数，说明ransomNote字符串总存在magazine中没有的字符
        for(int i : record){
            if( i< 0){
                return false;
            }
        }
        return true;
    }
}

15. 三数之和

时间复杂度：O(n^2)

if (i > 0 && nums[i] == nums[i - 1]) {
    continue;
}

这么写就是当前使用 nums[i]，我们判断前一位是不是一样的元素，在看 {-1, -1 ,2} 这组数据，当遍历到 第一个 -1 的时候，只要前一位没有-1，那么 {-1, -1 ,2} 这组数据一样可以收录到 结果集里。

这是一个非常细节的思考过程。

#思考题

既然三数之和可以使用双指针法，我们之前讲过的1.两数之和，可不可以使用双指针法呢？

如果不能，题意如何更改就可以使用双指针法呢？ 大家留言说出自己的想法吧！

两数之和 就不能使用双指针法，因为1.两数之和要求返回的是索引下标， 而双指针法一定要排序，一旦排序之后原数组的索引就被改变了。

如果1.两数之和 要求返回的是数值的话，就可以使用双指针法了。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ThreeSum {
    public List> threeSum(int[] nums){
        //双指针
        //求数值而不是下标index，所以可以排序
        List> result = new ArrayList<>();
        Arrays.sort(nums);

        for(int i = 0; i < nums.length; i++){
            if(nums[i] > 0){
                return result;
            }
            //去重
            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{
                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));//收获至少一个结果集
                    //left, right去重
                    while (right > left && nums[right] == nums[right - 1])right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    right--;
                    left++;
                }
            }
        }
        return result;
    }
}

18. 四数之和

四数之和的时间复杂度是O(n^3)

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class FourSum {
    public List> fourSum(int[] nums, int target){
        List> result = new ArrayList<>();
        Arrays.sort(nums);

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

                        while (right > left && nums[right] == nums[right- 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

                        right--;
                        left++;
                    }
                }
            }

        }
        return result;

    }
}

双指针法将时间复杂度：O(n^2)的解法优化为 O(n)的解法。也就是降一个数量级，题目如下：

• 27.移除元素(opens new window)
• 15.三数之和(opens new window)
• 18.四数之和(opens new window)

链表相关双指针题目：

• 206.反转链表(opens new window)
• 19.删除链表的倒数第N个节点(opens new window)
• 面试题 02.07. 链表相交(opens new window)
• 142题.环形链表II