如何在不生成镜像置换的情况下置换整数数组（Java）

我已经编写了一个在java中排列整数数组的方法。但是，我不知道如何才能防止找到镜像排列。 例如，我想要[1,2,3]的所有置换。这将是：

[1,2,3]
[1,3,2]
[3,1,2]

[3,2,1]
[2,3,1]
[2,1,3]

最后三种排列是镜像排列，我根本不想找到。原因是，我正在尝试为旅行推销员问题实现一个蛮力解决方案。通过丢弃镜像排列，我可以节省一些时间，因为巡演在哪个方向进行并不重要。这次旅行的费用是一样的

我的想法如下：如上面的例子所示，在镜像排列中，2总是在1前面。如果我遍历数组并找到2，但还没有找到1，这意味着1保存在以后的索引中。这意味着我可以阻止这一变化。但是，我不知道如何执行此检查。此外，我不知道这种方法是否是解决这个问题的最佳方法。 如何执行此检查？有更好的方法吗

public void bruteforce(Graph g) {
    int[] elements = new int[g.size()];
    int length = g.size();

    for(int i = 0; i < elements.length; i++) {
        elements[i] = i;
    }

    permute(elements, length);

}

public void permute(int[] elements, int length) {
    if(length == 1) {
        for(int i = 0; i < length; i++) {
            System.out.println(Arrays.toString(elements));
        }
    }else {
        for(int i = 1; i < length; i++) {
            permute(elements, length-1);

            if(length % 2 == 1) {
                swap(elements, 1, length-1);
            }else {
                swap(elements, i, length-1);
            }
        }
    }
}

public void swap(int[] elements, int firstElement, int secondElement) {
    int tmp = elements[firstElement];
    elements[firstElement] = elements[secondElement];
    elements[secondElement] = tmp;
}

public void bruteforce（图g）{
int[]元素=新的int[g.size（）]；
int length=g.size（）；
for（int i=0；i

您可以使用equals方法创建DTO类“置换”，以比较正常数组和反向数组 并将每个排列保存在

集合中

，以这种方式，反转数组将匹配为重复，并被忽略

 ...
 Set<Permutation> permutations = new HashSet<>();

 public void permute(int[] elements, int length) {
    if(length == 1) {
        for(int i = 0; i < length; i++) {
            permutations.add(new Permutation(elements));
         }
...

public class Permutation {

    private Integer[] elements;

    public Permutation(Integer... elements) {
    this.elements = elements;
    }

    @Override
    public int hashCode() {
    return elements.length;
    }

    @Override
    public boolean equals(Object obj) {

    if (this == obj) {
        return true;
    }

    if (obj == null) {
        return false;
    }

    if (getClass() != obj.getClass()) {
        return false;
    }

    Permutation other = (Permutation) obj;
    // reversed elements
    List<Integer> revCurElements = Arrays.asList(this.elements);
    Collections.reverse(revCurElements);

    if (Arrays.equals(this.elements, other.elements) || Arrays.equals(revCurElements.toArray(new Integer[1]), other.elements)) {
        return true;
    }

    return false;
    }

}

。。。
Set permutations=new HashSet（）；
公共void排列（int[]元素，int长度）{
如果（长度==1）{
for（int i=0；i

当N为偶数时，你如何定义镜像置换？我还没有为镜像置换定义任何东西，因为我不知道如何定义。不知怎的，我一直停留在这一点上。也许你指的是两个彼此相反的置换？所以1234和4321是“镜像的”？是的，这就是我的意思。我不想把这个排列打印出来。如果可以在清楚地知道排列将被镜像为

N

元素而不是

N！

排列的情况下取消交换，那将是很酷的/2这对于非平凡的

N

来说是无关紧要的。是否仍对此优化感兴趣？