Question

我正在尝试删除this question

中的返回列表中的重复项

给定候选数字（C）和目标数字（T）的集合，找到C中所有候选数字总和为T的唯一组合。

C中的每个数字只能在组合中使用一次。

注意：

所有数字（包括目标）都是正整数。
组合中的元素（a1，a2，...，ak）必须按非降序排列。（即a1≤a2≤...≤ak）。
解决方案集不得包含重复的组合。

例如，给定候选集10,1,2,7,6,1,5和目标8，解决方案集是：

[1, 7] 
[1, 2, 5] 
[2, 6] 
[1, 1, 6]

我的问题是如何有效地删除重复？以下是我的代码：

public class Solution {
    public static void main(String[] args) {
        int[] input = { 10, 1, 2, 7, 6, 1, 5 };
        // int[] input = { 2, 1, 1, 4, 4, 2 };
        System.out.println(combinationSum2(input, 8));
    }

    private static class Entry {
        List<Integer> list;
        int target;
        int index; // the previous index

        public Entry(int target) {
            list = new LinkedList<Integer>();
            this.target = target;
        }

        public int add(int num, int index) {
            this.list.add(num);
            this.index = index;
            this.target -= num;
            return target;
        }

        public Entry copy() {
            Entry copy = new Entry(this.target);
            copy.list = new ArrayList<>();
            copy.list.addAll(list);
            copy.target = target;
            copy.index = index;
            return copy;
        }

    }

    public static List<List<Integer>> combinationSum2(int[] input, int target) {
        List<List<Integer>> ret = new LinkedList<List<Integer>>();

        if (null == input || input.length <= 0)
            return ret;

        Arrays.sort(input);

        int N = input.length;
        Queue<Entry> pool = new LinkedList<Entry>();
        for (int i = 0; i < N; i++) {
            if (input[i] <= target) {
                Entry entry = new Entry(target);
                entry.add(input[i], i);
                pool.add(entry);
            }
        }

        while (!pool.isEmpty()) {
            Entry cur = pool.poll();
            if (cur.target == 0) {
                ret.add(cur.list);
            } else if (cur.target > 0) {
                for (int i = cur.index + 1; i < N; i++) {
                    if (cur.target - input[i] >= 0) {
                        Entry copy = cur.copy();
                        copy.add(input[i], i);
                        pool.offer(copy);
                    } else {
                        break;
                    }
                }
            }
        }

        return ret;
    }
}

我的第一个想法是对返回列表中的列表进行排序，逐个比较以删除重复。但有更快的方法吗？或任何建议？

Answer 1

我的建议是使用HashSet来阻止添加任何现有条目。首先要做的是覆盖Entry类的equals和hashCode函数。（more material）

private static class Entry {
    List<Integer> list;
    int target;
    int index;
    int hash; // <---- add this

    public Entry(int target) {
        list = new LinkedList<Integer>();
        this.target = target;
        hash = target;
    }

    public int add(int num, int index) {
        this.list.add(num);
        this.index = index;
        this.target -= num;
        hash = hash * 17 + num;
        return target;
    }

    public Entry copy() {
        Entry copy = new Entry(this.target);
        copy.list = new ArrayList<>();
        copy.list.addAll(list);
        copy.target = target;
        copy.index = index;
        copy.hash = hash;
        return copy;
    }

    @Override
    public boolean equals(Object obj) {
        Entry e = (Entry) obj;
        if ((this.target != e.target) || (this.list.size() != e.list.size())) {
            return false;
        }
        for (int i = 0; i < this.list.size(); i++) {
            if (!this.list.get(i).equals(e.list.get(i)))
                return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        return hash;
    }
}

下一步是使用哈希集来过滤结果。

Set<Entry> nodup = new HashSet<Entry>();

while (!pool.isEmpty()) {
    Entry cur = pool.poll();
    if (cur.target == 0) {
        nodup.add(cur);
    } else if (cur.target > 0) {
        // ... your code
    }
}

for (Entry entry : nodup) {
    ret.add(entry.list);
}

Answer 2

您可以通过将List转换为Java中的HashSet来从Java中的List中删除重复项或重复元素。但在此之前，请记住，Set不会保留由List保证的插入顺序，实际上这是List中的List和Set之间的主要区别。

因此，当您将List转换为HashSet时，所有重复元素都将被删除，但插入顺序将会丢失。

可以找到更详细的说明here

Answer 3

您可以使用散列作为另一种解决方案，但它会在空间方面使用O(n)（时间相同）。

基本上，从头到尾遍历列表。对于每个新遇到的元素，我们检查它是否在哈希集（HashSet）中：如果是，我们将其删除;否则我们把它放进去。

C ++删除一组列表中的重复项

3 个答案: