Java 在以下情况下，检查重复答案的有效方法是什么？

我试图在leetcode中解决这个问题：

公共列表组合总和（int[]候选项，int目标）
{
List res=new ArrayList（）；
数组。排序（候选）；
助手（候选对象、目标、资源、新ArrayList（）、0）；
返回res；
} 
私有void助手（int[]候选对象、int目标、列表资源、列表临时值、int索引）{
如果（目标<0）返回；
如果（目标==0）{
res.add（新阵列列表（临时））；
返回；
}
for（int i=索引；i目标）{
返回；
}
临时添加（候选人[i]）；
助手（候选者、目标-候选者[i]、资源、临时、索引）；
温度移除（温度大小（）-1）；
}
}
对于输入：候选者=[2,3,6,7]，目标=7
我的输出是：[[2,2,3]，[2,3,2]，[3,2,2]，[7]]
正确输出：[[2,2,3]，[7]]

显然，在添加到结果之前，我需要检查副本

我知道我可以创建一组字符串，其中每个字符串都是列表的排序版本，例如，[2,3,2]=>“223”。这将帮助我检查是否需要将列表添加到结果中

---

我的问题是，在我的情况下，检查副本的最佳方法是什么？

您不一定需要设置。相反，您可以使用

Arrays.sort（）

对两个数组进行排序，然后检查所有索引是否相等，例如：

public Boolean isEqual(int[] a1, int[] a2) {
    if (a1.length != a2.length) {
        return false;
    }
    Arrays.sort(a1);
    Arrays.sort(a2);
    for (int i = 0; i < a1.length; i++) {
        if (a1[i] != a2[i]) {
            return false;
        }
    }
    return true;
}

公共布尔值相等（int[]a1，int[]a2）{
如果（a1.长度！=a2.长度）{
返回false；
}
数组。排序（a1）；
数组。排序（a2）；
对于（int i=0；i

将此应用于您的结果，并保留返回

false

的数组结果。我不确定什么是最佳方法，但您可以使用和

公共静态集合组合和（int[]候选，int目标）
{
--->>Set res=新的HashSet（）；
数组。排序（候选）；
助手（候选对象、目标、资源、新ArrayList（）、0）；
返回res；
}
私有静态void助手（int[]候选对象、int目标、Set res、List temp、int索引）{
如果（目标<0）返回；
如果（目标==0）{
ArrayList newRes=新ArrayList（临时）；
--->>集合。排序（newRes）；
决议添加（新决议）；
返回；
}
for（int i=索引；i目标）{
返回；
}
临时添加（候选人[i]）；
助手（候选者、目标-候选者[i]、资源、临时、索引）；
温度移除（温度大小（）-1）；
}
}

输入

候选人=[2,3,6,7]，目标=7

输出

---

[[2,2,3]，[7]]

通过在助手方法中添加以下行将获得预期的结果

if(target == 0 ) {
    Collections.sort(temp); // This will sort your list, that you want to add
    if(!res.contains(temp)) // Check if sorted list already existing in your result list or not. Only add the temp list if it does not exist in your res list.
        res.add(new ArrayList<>(temp));
    return;
}

---

完全避免重复（无需明确检查）的一种可能的替代方法如下：

您不必在helper函数中循环遍历for循环中的每个元素（请注意，在递归调用中，index参数总是相同的），您可以考虑如下解决方案：

<> LI>在给定的索引中考虑元素，并用相同的索引再次递归（因此能够多次考虑同一个元素）或 您不考虑当前元素，并用索引+ 1递归。 这样，您就不会在解决方案中得到重复项

不在此处发布整个解决方案（不想剥夺您所有的乐趣：p），但helper函数中的递归步骤本质上是：

# don't consider element at index, and increment index in recursive call
self.helper(candidates, target, index+1, res, temp) 

# consider element at index `index`
self.helper(candidates, target-candidates[index], index, res, temp+[candidates[index]])    

---

你为什么需要最好的？你对最佳的定义是什么？最快的？使用更少的内存？看起来最优雅的那个？为什么您已经找到的解决方案不够好？这个问题类似于硬币兑换问题……请看一看。@Wisthler您提出了一个合理的问题。在我的问题中，我不太清楚我要寻找的答案是什么。基本上，我是在寻找一个答案，对我的思维方式提出一些批评，同时也是另一种方式。具体地说，我在寻找一个关于时间和空间之间权衡的讨论，同时以不同的方式做同样的事情。：-）我的错。在我的问题中，我不太清楚我要寻找的答案是什么。基本上，我在寻找一个答案，这个答案对我的思维方式提出了一些批评，同时也是另一种方式。具体来说，我想讨论一下时间和空间之间的权衡，同时用不同的方式做同样的事情。：-）谢谢你的建议。我很感激没有给我代码，我修改了代码，得到了预期的结果。我接受之前的评论，只是因为它们解决了处理“重复”的问题，而您在解决问题时没有实际检查重复项。：-）事实上，找到一种完全消除重复项的方法与公认的答案一样有效地解决了您的问题。从性能、内存使用率和优雅程度来看，这是理想的解决方案：）

if(target == 0 ) {
    Collections.sort(temp); // This will sort your list, that you want to add
    if(!res.contains(temp)) // Check if sorted list already existing in your result list or not. Only add the temp list if it does not exist in your res list.
        res.add(new ArrayList<>(temp));
    return;
}

 Set<List<Integer>> set = new HashSet<>(res);
 res.clear();
 res.addAll(set);

# don't consider element at index, and increment index in recursive call
self.helper(candidates, target, index+1, res, temp) 

# consider element at index `index`
self.helper(candidates, target-candidates[index], index, res, temp+[candidates[index]])