Question

我正在组合3个不同的值，给出一个请求的总和，在这种情况下，请求的总和是0.我无法找到一种方法来循环遍历一个TreeSet，其中2个for循环按顺序接收一组3个数字而不重复该解决方案。我想通过使用TreeSet的contains方法获得的第三个数字。

这是我的代码到目前为止，它提供了很好的解决方案，但它重复了它们。

import java.util.*;

public class Tree
{
    public static void main(String[] args)
    {
        TreeSet<Integer> ts = new TreeSet<>();
        int array[] = {-5, 1, -4, 6, 2, 3, 9, 5};

        int sumSearching = 0;
        int valueSearching;

        for(int i = 0; i < array.length; i++)
            ts.add(array[i]);

        for(Integer i: ts)
        {
            for(Integer j : ts)
            {
                if(i != j)
                {
                    valueSearching = sumSearching - (i + j);
                    if(valueSearching != i && valueSearching != j)
                        if(ts.contains(valueSearching))
                            System.out.println("Solution: "
                                + i + ", " + j + ", " + valueSearching);
                }
            }
        }
    }
}

感谢您提供任何帮助！

Answer 1

转到j＆gt;我，删除一个对称。

这不排除{i，j，valueSearching}上的双打，因为涉及负数。因此，需要保持所有解决方案。

    Set<Set<Integer>> solutions = new HashSet<>();
    for (int i: ts)
    {
        for (int j : ts.tailSet(i, false))
        {
            valueSearching = sumSearching - (i + j);
            if (valueSearching != i && valueSearching != j)
                if (ts.contains(valueSearching)) {
                    Set<Integer> solution = new TreeSet<>();
                    Collections.addAll(solution, i, j, valueSearching);
                    if (solutions.add(solution)) {
                        System.out.println("Solution: "
                                + i + ", " + j + ", " + valueSearching);
                    }
                }
        }
    }

另请注意：i != j对于整数最好应为i.intValue() != j.intValue()，因为只有在-128 .. 127范围内，数字的对象才是唯一的。

这里只使用int基元类型，这更合适。另外Set.tailSet(value, exclusive)在之后给出集合。使用迭代器可能会更有效率。

Answer 2

要排除重复的解决方案，它只包含那些按升序排列的三元组。

所以，请尝试更改此行：

if (valueSearching != i && valueSearching != j)

为：

if (i < j && j < valueSearching)

Answer 3

实施可逆对类：

class ReversablePair<T>
{
    private final T first;
    private final T second;

    ReversablePair(final T first, final T second)
    {
        this.first = first;
        this.second = second;
    }

    // Some getters...

    @Override
    public boolean equals(final Object o)
    {
        if (o == null) return false;
        if (!(o instanceof ReversablePair)) return false;

        final ReversablePair that = (ReversablePair) o;

        return (this.first.equals(that.first) && this.second.equals(that.second))
            || (this.first.equals(that.second) && this.second.equals(that.first));
    }

    @Override
    public int hashCode()
    {
        return first.hashCode() + second.hashCode();
    }
}

然后维护一组先前的解决方案：

Set<ReversablePair<Integer>> previousSolutions = new HashSet();

在打印前检查设置：

if (! previousSolutions.contains(new ReversablePair<>(i, j))
{
    // whatever
}

通过TreeSet迭代而不重复解

3 个答案: