有人知道为什么这段代码在 leet 代码中的 3sum 中出现错误吗

Question

给定一个整数数组 nums，返回所有三元组 [nums[i], nums[j], nums[k]]，使得 i != j, i != k, and j != k，并且 nums[i] + nums[j] + nums[k] == 0.

请注意，解决方案集不得包含重复的三元组。

示例1：

Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]
Explanation: 
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.
The distinct triplets are [-1,0,1] and [-1,-1,2].

请注意，输出的顺序和三元组的顺序并不重要。 示例2：

Input: nums = [0,1,1]
Output: []

解释：唯一可能的三元组之和不为 0。 例3：

Input: nums = [0,0,0]
Output: [[0,0,0]]
Explanation: The only possible triplet sums up to 0.

限制：

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

所以这是 3 和的问题，我尝试的解决方案如下 导入 java.util.*;

class Solution {
        public static List<List<Integer>> threeSum(int[] nums) {
            List<List<Integer>> ans = new ArrayList<>();
            Map<Integer, Integer> hashMap = new HashMap<>();
            boolean isEmpty=true;
            // Copy elements from the array to the HashMap
            for (int num : nums) {
                // Assuming you want to use the array elements as both keys and values
                hashMap.put(num, num);
            }
            boolean flag=false;
            for(int i=0;i<nums.length;i++){
                for(int j=i+1;j<nums.length;j++){
                    int compliment=-nums[i] -nums[j];
                    if(hashMap.containsKey(compliment)){
                        func(nums[i],nums[j],compliment,ans);
                    }
                }
            }
            return ans;
        }
    static void func(int a, int b, int c, List<List<Integer>> ans) {
        List<Integer> al = new ArrayList<>();
        al.add(a);
        al.add(b);
        al.add(c);

        Collections.sort(al);

        boolean duplicate = false;
        for (List<Integer> il : ans) {
            if (il.equals(al)) {
                duplicate = true;<kbd>
                break;
            }
         }

        if (!duplicate) {
            ans.add(al);
        }
    }
}

所以基本上这个问题是找到总和为0的三元组，但即使是不同顺序的相同数字也是不允许的。所以我尝试的是我基本上创建了一个带有数组元素的哈希映射并迭代2个for循环并找到它在 O(N^2) 时间复杂度中对哈希映射进行补充。我不知道怎么做，但是发生了这个错误：

- Input:
- [-1,0,1,2,-1,-4]
- Output
- [[-1,0,1],[-1,-1,2],[-4,2,2]]
- Expected
- [[-1,-1,2],[-1,0,1]]
- 

另一张：

**Input
nums =
[1,2,3,0,-1,-2,-3,-1,-1,-1,-2]
Output
[[-3,1,2],[-1,0,1],[-2,1,1],[-2,0,2],[-1,-1,2],[-3,0,3],[-2,-1,3]]
Expected
[[-3,0,3],[-3,1,2],[-2,-1,3],[-2,0,2],[-1,-1,2],[-1,0,1]]

所以我遇到了一个错误，正在生成一个额外的答案，我一直在尝试解决它，但现在我不能。所以请帮助我解决我的错误

抱歉我的英语不好。

Answer 1

哈希图不允许您处理值的计数，因此您无法检查

i!=j

和

j!=k

条件

在每次迭代中，您需要一个不包含

i

和

j

的初始值列表，以便您可以检查

compliment

的剩余值

还可以使用

Set

而不是

List

，这样您就不必手动检查现有的重复答案

public static Set<List<Integer>> threeSum(int[] nums) {
    Set<List<Integer>> ans = new HashSet<>();
    List<Integer> values = new ArrayList<>();
    for (int num : nums) {
        values.add(num);
    }
    List<Integer> tmpValues;
    for (int i = 0; i < nums.length; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            tmpValues = new ArrayList<>(values);
            tmpValues.remove((Integer) nums[i]);
            tmpValues.remove((Integer) nums[j]);
            int compliment = -nums[i] - nums[j];
            if (tmpValues.contains(compliment)) {
                ans.add(func(nums[i], nums[j], compliment));
            }
        }
    }
    return ans;
}

static List<Integer> func(int a, int b, int c) {
    List<Integer> al = new ArrayList<>(List.of(a, b, c));
    Collections.sort(al);
    return al;
}