leetcode刷题记录总结-3. 哈希表

一、字母异位

242.有效的字母异位词

给定两个字符串 *s* 和 *t* ，编写一个函数来判断 *t* 是否是 *s* 的字母异位词。

**注意：**若 *s* 和 *t* 中每个字符出现的次数都相同，则称 *s* 和 *t* 互为字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

提示:

• 1 <= s.length, t.length <= 5 * 104
• s 和 t 仅包含小写字母

进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

题解

普通字符

• 消消乐
• 如果多消或没有消，都是不满足的
• 互相能表示，个数必须相同

class Solution {
    public boolean isAnagram(String s, String t) {
        // 用哈希表记录，普通ascii编码，直接用数值哈希即可
        if(s.length() != t.length()) return false; // 互相能表示，个数必须相同
        char[] st = s.toCharArray();
        char[] tt = t.toCharArray();
        int[] table = new int[26];
        // 1.先记录s中每个字符的哈希值（次数）
        for(char c : st) table[c - 'a']++;
        // 2.遍历t中每个字符的哈希值，发现小于零，多算或没有key
        //   因此可以在一个循环内判断，无需再开个循环判断哈希
        for(char c : tt) {
            table[c - 'a']--;
            if(table[c - 'a'] < 0) return false;
        }
        return true;     
    }
}

进阶：含特殊字符

class Solution {
    public boolean isAnagram(String s, String t) {
        // 用哈希表记录，如果有特殊字符，还是用hashmap记录
        if(s.length() != t.length()) return false;
        char[] st = s.toCharArray();
        char[] tt = t.toCharArray();
        HashMap<Character, Integer> map = new HashMap<>();
        // 1. 记录s
        for(char c : st) map.put(c, map.getOrDefault(c, 0) + 1);
        // 2. 查询t,并判断
        for(char c : tt) {
            map.put(c, map.getOrDefault(c, 0) - 1);
            if(map.get(c) < 0) return false;
        }
        return true;       
    }
}

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

示例 1：

输入：ransomNote = "a", magazine = "b"
输出：false

示例 2：

输入：ransomNote = "aa", magazine = "ab"
输出：false

示例 3：

输入：ransomNote = "aa", magazine = "aab"
输出：true

提示：

• 1 <= ransomNote.length, magazine.length <= 105
• ransomNote 和 magazine 由小写英文字母组成

题解

用两个hash记录比较

• 不是完全相等，magazine>=ransomNote都可以

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        HashMap<Character, Integer> rmap = new HashMap<>();
        HashMap<Character, Integer> mmap = new HashMap<>();
        // 1. 记录目标串中每个字符出现的频率
        char[] rt = ransomNote.toCharArray();
        char[] mt = magazine.toCharArray();
        for(char c : rt) rmap.put(c, rmap.getOrDefault(c, 0) + 1);
        // 2. 记录magazine串
        for(char c : mt) mmap.put(c, mmap.getOrDefault(c, 0) + 1);
        // 3. 比较两个map
        for(char c : rmap.keySet()) {
            if(!mmap.containsKey(c)) return false;
            if(mmap.get(c) < rmap.get(c)) return false; // 不是完全相等，>=都可以
        }
        return true;
    }
}

用一个hash记录比较

• 与有效的字母异位词不同的是，无需两者互相满足，只需ransomNote由magazine组成即可
• 因此，需要先记录magazine的词频，遍历ransomNote时，每个字符都能找到且次数充足
  • 与两者互相能表示的区别是，可以不用判断两者的元素个数是否相同，可以不用相同

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[] table = new int[26];
        char[] rt = ransomNote.toCharArray();
        char[] mt = magazine.toCharArray();
        // 1. 记录素材中每个字符出现的频率
        for(char c : mt) table[c - 'a']++;
        // 2. 遍历验证的字符串，判断是否包含，包含了频次对不对
        for(char c : rt) {
            table[c - 'a']--;
            if(table[c - 'a'] < 0) return false;// 不包含就为负
        }
        return true;
    }
}

49. 字母异位词分组

• 给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

• 字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。

示例 1:

输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
示例 2:

输入: strs = [""]
输出: [[""]]
示例 3:

输入: strs = ["a"]
输出: [["a"]]


提示：

1 <= strs.length <= 10^4
0 <= strs[i].length <= 100
strs[i] 仅包含小写字母

题解

• 1.对于组合问题，先用哈希表的key记录每组的源字母，用value储存对应的变异的单词列表

  • **即同一组字符串具有相同的hash函数值，不同组，哈希值不同，**这就涉及到对key求哈希函数的操作，要保证key唯一
    • 方式1：字符串不是很长时，对字符串进行排序，同一组字母顺序变异，排好序唯一
      • 涉及到字符串字符的排序问题
    • 方式2：统计每组中每个字母出现的次数，在26个字母表中，相同字母出现次数相同唯一

• 2.注意数据的原始性，每次hash的字符串，不能污染原数据

  • java中，需要将字符串转为字符数组，再对字符数组排序，最后将字符数组转为字符串，不会污染原字符串

    char[] charArr = s.toCharArray();
    Arrays.sort(charArr);
    String oriStr = Arrays.toString(charArr); 
    

• 3.遍历HashMap的key，value

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7cb1zEF7-1674742072220)(assets/eb5f6e8dee0c4d6ba78f66d79d80aba7.png)]

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> res = new ArrayList<>();
        if(strs == null || strs.length == 0) return res;
        // 1.先用哈希表记录每组源单词,对应的变异后的单词
        Map<String, ArrayList<String>> map = new HashMap<>();
        for(String s : strs) {
            // 通过排序计算hash，判定key是否相等,注意不要污染原数据
            char[] ct = s.toCharArray();
            Arrays.sort(ct);
            String oriStr = String.valueOf(ct);
            ArrayList<String> list;
            if(!map.containsKey(oriStr)) { // 新的key，创建一个新的数组容器
                list = new ArrayList<>();
            } else {
                list = map.get(oriStr);     // 已经找到key，找到key对应的容器
            }
            list.add(s);  // 往源单词的hash桶里放相同hash值的数据
            map.put(oriStr, list);
        }
        // 2.遍历每个变异后的单词列表，保存到list集合中输出
        for(ArrayList<String> list : map.values()) {
            res.add(list);
        }
        return res;        
    }
}

438.找到字符串中所有字母异位词

给定两个字符串 s 和 p，找到 s 中所有 p 的 异位词 的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词 指由相同字母重排列形成的字符串（包括相同的字符串）。

示例 1:

输入: s = "cbaebabacd", p = "abc"
输出: [0,6]
解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。

示例 2:

输入: s = "abab", p = "ab"
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。

提示:

• 1 <= s.length, p.length <= 3 * 104
• s 和 p 仅包含小写字母

题解

两个哈希

• 理论上可以解决，但超出时间限制
• for(int k = i; k < i + len; k ++) { // i+len，边界

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> list = new ArrayList<>();
        // 1.先用hash记录p，
        // int[] table = new int[26];涉及到多次判断，用map比较合适
        Map<Character,Integer> map = new HashMap<>();
        char[] pt = p.toCharArray();
        int len = pt.length;
        for(char c : pt) map.put(c, map.getOrDefault(c, 0) + 1);
        // 2.拆分遍历s每个子串进行判定
        char[] st = s.toCharArray();
        Map<Character,Integer> th;
        for(int i = 0; i <= st.length - len; i ++) {
            // 以每个字符开头，截取len长度进行判断
            th = new HashMap<>();
            for(int k = i; k < i + len; k ++) { // i+len，边界
                char c = st[k];
                th.put(c, th.getOrDefault(c, 0) + 1);         
            }
            if(check(th, map)) list.add(i);
            System.out.println("------");
        }
        return list;
    }

    private boolean check(Map<Character,Integer> m1, 
                          Map<Character,Integer> m2) {
        for(Character key : m1.keySet()) {
            if(!m2.containsKey(key)) return false;
            if(!m2.get(key).equals(m1.get(key))) return false; 
        }
        return true;
    }
}

优化：滑动窗口

• 先形成窗口，再判断窗口，起始位置
• i+plen-1<=slen-1

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        List<Integer> list = new ArrayList<>();
        int slen = s.length(), plen = p.length();
        // 1.先处理特殊边界
        if(slen < plen) return list;
        char[] st = s.toCharArray();
        char[] pt = p.toCharArray();
        // 2.用两个哈希表分别记录窗口和p中的字符
        int[] wh = new int[26]; // 滑动窗口
        int[] th = new int[26]; // 比较的源p字符串
        // 窗口初始化，先形成窗口，并记录p的字符
        for(int i = 0; i < plen; i ++) {
            wh[st[i] - 'a']++;  // 窗口初始化，记录s子串
            th[pt[i] - 'a']++;  // 记录p的字符
        }
        // 3. 依次向右移动窗口进行判断
        //    先形成窗口，再判断窗口，起始位置
        for(int i = 0; i <= slen - plen; i++) { // i+plen-1<=slen-1
            // 1.先判断
            if(Arrays.equals(wh, th)) list.add(i);
            // 2.再移动窗口
            wh[st[i] - 'a']--;       // 左指针右移，清空旧数据。只改变内容
            if(i + plen < slen)
                wh[st[i + plen] - 'a']++;// 右指针右移，添加新元素，只改变内容
        }
        return list;
    }   
}

二、两个数组的交集

349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

提示：

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 1000

题解

• 记录交集要用集合，这样可以去重
• 需要两个集合set
  • 判断另一个列表是否出现过，需要用个集合，需要哈希，不需要记录出现的次数
  • 答案中要去重，需要用集合容器装

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // 1.用哈希集合记录nums1元素和答案
        Set<Integer> set = new HashSet<>();
        Set<Integer> rset = new HashSet<>();// 要用集合装交集元素（答案）
        for(int k : nums1) {
            set.add(k);
        }
        // 2.遍历nums2, 包含相同元素就记录
        for(int k : nums2) {
            if(set.contains(k)) rset.add(k);
        }
        Object[] arr = rset.toArray();
        int[] res = new int[arr.length];
        for(int i = 0; i < res.length; i++) res[i] = (int)arr[i];
        return res;
    }
}

350.两个数组的交集 II

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]

示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]

提示：

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 1000

*进阶*：

• 如果给定的数组已经排好序呢？你将如何优化你的算法？
• 如果 nums1 的大小比 nums2 小，哪种方法更优？
• 如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

题解

• 因要将重复的元素多次打印出来，需要知道次数，因此需要用到hash表

class Solution {
    HashMap<Integer, Integer> m1 = new HashMap<>();
    HashMap<Integer, Integer> m2 = new HashMap<>();
    public int[] intersect(int[] nums1, int[] nums2) {     
        for(int k : nums1) m1.put(k, m1.getOrDefault(k, 0) + 1);
        for(int k : nums2) m2.put(k, m2.getOrDefault(k, 0) + 1);
        return check();
    }
    private int[] check() {
        ArrayList<Integer> arr = new ArrayList<>();
        for(int k : m1.keySet()) {
            if(m2.containsKey(k)) {
                int val = m1.get(k) < m2.get(k) ? m1.get(k) : m2.get(k);
                while(val-- > 0) arr.add(k);
            }
        }
        int[] res = new int[arr.size()];
        for(int i = 0; i < res.length; i ++) res[i] = arr.get(i);
        return res;
    }
}

202.快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

示例 2：

输入：n = 2
输出：false

提示：

• 1 <= n <= 231 - 1

题解

• 题中有个条件：sum循环判断为false，即需要判断sum是否重复出现，需要用到哈希
• 难点：对数值各个位上的数进行平方求和操作
  • 取模/余，得低位数
  • 相除，得高位数

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        // 1.循环获取sum，定义好终止条件
        int sum = n;
        while(sum != 1 && !set.contains(sum)) {
            set.add(sum);
            // 2.获取数值的每位数的平方和
            sum = getSum(sum);
        }
        return sum == 1;
    }
    private int getSum(int n) {
        int sum = 0;
        while(n > 0) {
            sum += (n % 10) * (n % 10); // 取模，得低位数
            n = n / 10;				    // 相除，得高位数
        }
        return sum;
    }
}

三、几个数之和

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

• 2 <= nums.length <= 104
• -109 <= nums[i] <= 109
• -109 <= target <= 109
• 只会存在一个有效答案

**进阶：**你可以想出一个时间复杂度小于 O(n2) 的算法吗？

题解

用HashMap

• 注意，求下个位置时，不能包含当前的位置

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 1.开哈希记录每个数对应的小标
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++) map.put(nums[i], i);
        // 2.遍历一遍数值，查找答案
        for(int i = 0; i < nums.length; i++) {
            // 注意，排除自身的数值
            int key = target - nums[i];
            if(map.containsKey(key) && map.get(key) != i) {
                return new int[]{i, map.get(target - nums[i])};
            }
        }
        return new int[]{-1, -1};
    }
}

代码优化：

• 不能先放入反向表，否则会对同一个位置进行判断，因此要先判断再加入map
• 即从后往前判断，每次从前面已经添加的数据中查找，这样可以避免对同一位置判断

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 为了找到目标数的下标，设计一个反向记录表
        int n = nums.length;
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < n; i ++) {
            if(map.containsKey(target - nums[i])) {
                return new int[]{i, map.get(target - nums[i])};
            }
            // 不能先放入反向表，否则会对同一个位置进行判断，因此要先判断再加入map
            map.put(nums[i], i);
        }
        return new int[]{-1, -1};
    }
}

454. 四数相加 II

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

• 0 <= i, j, k, l < n
• nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

示例 1：

输入：nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]
输出：2
解释：
两个元组如下：
1. (0, 0, 0, 1) -> nums1[0] + nums2[0] + nums3[0] + nums4[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> nums1[1] + nums2[1] + nums3[0] + nums4[0] = 2 + (-1) + (-1) + 0 = 0

示例 2：

输入：nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]
输出：1

提示：

• n == nums1.length
• n == nums2.length
• n == nums3.length
• n == nums4.length
• 1 <= n <= 200
• -2^28 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^28

题解

• 因为用四个数值在四个数组中，因此，可以不用考虑重复的问题
• 可以将四数之和，两两分组，分组计算，两组处理的逻辑与两数之和类似

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        Map<Integer, Integer> map = new HashMap<>();// 前两组和及次数
        // 1.先统计前两个数组的和以及出现的次数-需要遍历n^2
        for(int i : nums1) {
            for(int j : nums2) {
                int count = i + j;
                map.put(count, map.getOrDefault(count, 0) + 1);
            }
        }
        // 2.遍历后两组的和，统计总和为0的次数
        int res = 0;
        for(int i : nums3) {
            for(int j : nums4) {
                int key = -(i + j);
                if(map.containsKey(key)) res += map.get(key);
            }      
        }
        return res;
    }
}

15.三数之和

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

**注意：**答案中不可以包含重复的三元组。

示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
解释：
nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
注意，输出的顺序和三元组的顺序并不重要。

示例 2：

输入：nums = [0,1,1]
输出：[]
解释：唯一可能的三元组和不为 0 。

示例 3：

输入：nums = [0,0,0]
输出：[[0,0,0]]
解释：唯一可能的三元组和为 0 。

提示：

• 3 <= nums.length <= 3000
• -105 <= nums[i] <= 105

题解

题解1:排序+滑动窗口-三层模板

• 其实这道题目使用哈希法并不十分合适，因为在去重的操作中有很多细节需要注意，在面试中很难直接写出没有bug的代码。

1.先排序，优化三重循环比较的次数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UW02ChgS-1674742072222)(assets/image-20221210155538055.png)]

2.双指针，一个指向二重循环，一个指向三重循环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sfUIjfzJ-1674742072223)(assets/image-20221210155828898.png)]

• 使用双指针，都只向一侧移动，复杂度降了一个等级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OMqwgtN1-1674742072224)(assets/image-20221210160204194.png)]

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        Arrays.sort(nums);
        int n = nums.length;
        // 1. 枚举a
        for(int ia = 0; ia < n; ia ++) {
            // 1.1 要保证枚举的数不重复
            if(ia > 0 && nums[ia] == nums[ia - 1]) continue;
            // 2. 创建b,c组成的滑动窗口的指针
            int ic = n - 1;  // 第三元数据，右指针
            int target = -nums[ia];    // 滑动窗口的内容
            for(int ib = ia + 1; ib < n; ib ++) { // 第二元数，左指针
                // 同样，先保证枚举元素不重复
                if(ib > ia + 1 && nums[ib] == nums[ib - 1]) continue;
                // 维护滑动窗口， 左指针已经定了，移动右指针，注意边界
                while(ib < ic && nums[ib] + nums[ic] > target) --ic;
                if(ib == ic) break; // 后续b增加，更不会有等于target的值
                // 如果找到满足条件的值，记录答案
                if(nums[ib] + nums[ic] == target) {
                    List<Integer> list = new ArrayList<>();
                    list.add(nums[ia]);list.add(nums[ib]);list.add(nums[ic]);
                    res.add(list);
                }
            }
        }
        return res;
    }
}

题解2：排序+滑动窗口-利用两数之和模板

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        Arrays.sort(nums);
        for(int i = 0; i < nums.length; i ++) {
            // 当前端点对应的两数和为-nums[i]
            // 注意重复元素的截断
            if(i > 0 && nums[i] == nums[i - 1]) continue;
            for(ArrayList<Integer> opt : twoSum(nums, i + 1, -nums[i])) {
                ArrayList<Integer> arr = new ArrayList<>();
                arr.add(nums[i]); arr.add(opt.get(0)); arr.add(opt.get(1));
                ans.add(arr);
            }
        }
        return ans;
    }

    // 两数之和
    public ArrayList<ArrayList<Integer>> twoSum(int[] numbers, int start, int target) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        // 一层遍历节省不了，因此，可用一个for循环
        // 1.定义右指针
        int j = numbers.length - 1;
        for(int i = start; i < numbers.length; i ++) {
            // 2.去重
            if(i > start && numbers[i] == numbers[i - 1]) continue;
            // 3.移动右指针
            while(i < j && numbers[i] + numbers[j] > target) j --;
            // 4.截断
            if(i == j) break;
            // 5.记录满足条件得答案
            if(numbers[i] + numbers[j] == target) {
                ArrayList<Integer> opt = new ArrayList<>();
                opt.add(numbers[i]); opt.add(numbers[j]);                
                res.add(opt);         
            }          
        }
        return res;
    }
}

18. 四数之和

给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

• 0 <= a, b, c, d < n
• a、b、c 和 d 互不相同
• nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

示例 1：

输入：nums = [1,0,-1,0,-2,2], target = 0
输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

示例 2：

输入：nums = [2,2,2,2,2], target = 8
输出：[[2,2,2,2]]

提示：

• 1 <= nums.length <= 200
• -109 <= nums[i] <= 109
• -109 <= target <= 109

题解

同样，使用排序加双指针

• 最后两个数依旧使用双指针，可以减少复杂度
• 只是前面两个数需要两重循环

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1BUvLNiZ-1674742072224)(assets/image-20221218145450936.png)]

注意：int数据相加，会有可能越界，因此，要转为long类型

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        if(nums == null || nums.length < 4) return res;
        int n = nums.length;
        Arrays.sort(nums);
        // 处理前两重循环
        for(int i = 0; i < n; i ++) {
            // 注意，每层循环，都要去重操作
            if(i > 0 && nums[i] == nums[i - 1]) continue;
            for(int j = i + 1; j < n; j ++) {
                if(j > i + 1 && nums[j] == nums[j - 1]) continue;
                // 寻找剩下的两个数，滑动窗口封装的结果
                long two = (long)nums[i] + nums[j];
                for(ArrayList<Integer> opt : 
                    twoSum(nums, j + 1, target-two)) {
                    ArrayList<Integer> arr = new ArrayList<>();
                    arr.add(nums[i]); arr.add(nums[j]);
                    arr.add(opt.get(0)); arr.add(opt.get(1));
                    res.add(arr);
                }
            }
        }
        return res;
    }

    // 1.最后两重循环用双指针，封装好
    private ArrayList<ArrayList<Integer>> twoSum(int[] nums, int start, long target) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        // 1.确定右指针
        int right = nums.length - 1; 
        // 2.循环遍历左指针
        for(int i = start; i < nums.length; i ++) {
            // 3. 先去重
            if(i > start && nums[i] == nums[i - 1]) continue;
            // 4. 维护滑动窗口内容，先移动右指针
            while(i < right && (long)nums[i] + nums[right] > target) --right;
            // 5. 截断：后续左边界右移，内容变大，一定找不到<=target的数
            if(i == right) break; // 截断，直接结束循环判断
            // 6. 找到满足条件，记录下来
            if((long)nums[i] + nums[right] == target) {
                ArrayList<Integer> arr = new ArrayList<>();
                arr.add(nums[i]); arr.add(nums[right]);
                res.add(arr);
            }
        }
        return res;
    }
}

还可以进行一些剪枝操作：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QrOqJhbd-1674742072225)(assets/image-20221218150229824.png)]

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        if(nums == null || nums.length < 4) return res;
        int n = nums.length;
        Arrays.sort(nums);
        // 处理前两重循环
        for(int i = 0; i < n - 3; i ++) { // 剪枝时，要注意数组边界
            // 注意，每层循环，都要去重操作
            if(i > 0 && nums[i] == nums[i - 1]) continue;
            // 可以做些剪枝
            if((long)nums[i] + nums[i + 1] + nums[i + 2] + nums[i + 3] > target) 	
                break;   // 左不能再扩，因此，直接结束循环
            if((long)nums[i] + nums[n - 3] + nums[n -2] + nums[n - 1] < target) 
                continue;// 右不能再往左扩，因此，当前循环截断，继续下轮循环
            for(int j = i + 1; j < n - 2; j ++) {
                if(j > i + 1 && nums[j] == nums[j - 1]) continue;
                if((long)nums[i] + nums[j] + nums[j + 1] + nums[j + 2] > target) 
                     break;   // 左不能再扩，因此，直接结束循环
            	if((long)nums[i] + nums[j] + nums[n -2] + nums[n - 1] < target) 
                	continue;// 右不能再往左扩，因此，当前循环截断，继续下轮循环
                // 寻找剩下的两个数，滑动窗口封装的结果
                long two = (long)nums[i] + nums[j];
                for(ArrayList<Integer> opt : 
                    twoSum(nums, j + 1, target-two)) {
                    ArrayList<Integer> arr = new ArrayList<>();
                    arr.add(nums[i]); arr.add(nums[j]);
                    arr.add(opt.get(0)); arr.add(opt.get(1));
                    res.add(arr);
                }
            }
        }
        return res;
    }

    // 1.最后两重循环用双指针，封装好
    private ArrayList<ArrayList<Integer>> twoSum(int[] nums, int start, long target) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        // 1.确定右指针
        int right = nums.length - 1; 
        // 2.循环遍历左指针
        for(int i = start; i < nums.length; i ++) {
            // 3. 先去重
            if(i > start && nums[i] == nums[i - 1]) continue;
            // 4. 维护滑动窗口内容，先移动右指针
            while(i < right && (long)nums[i] + nums[right] > target) --right;
            // 5. 截断：后续左边界右移，内容变大，一定找不到<=target的数
            if(i == right) break; // 截断，直接结束循环判断
            // 6. 找到满足条件，记录下来
            if((long)nums[i] + nums[right] == target) {
                ArrayList<Integer> arr = new ArrayList<>();
                arr.add(nums[i]); arr.add(nums[right]);
                res.add(arr);
            }
        }
        return res;
    }
}