Java中NxN矩阵的所有可能排列答案

【问题标题】：All possible permutations of a NxN matrix in JavaJava中NxN矩阵的所有可能排列
【发布时间】：2014-10-24 14:14:12
【问题描述】：

我想使用递归生成矩阵的所有可能排列。例如 2x2 矩阵将有 24 种可能性。

1 2  1 2  1 3  1 4
3 4, 4 3, 2 4, 2 3....24 possibilities.

这是我的代码。逻辑看起来不错，但我只能得到四种不同的可能性。我希望有人可以帮助我解决这个问题。

public class NewClass 
{
public static int LENGTH=2,count=0;

public static int check_if_array_is_fully_filled(int[][] a)
{
    for(int i=0;i<a.length;i++)
    {
        for(int j=0;j<a.length;j++)
        {
            if(a[i][j]==0)
            {
                return 0;
            }
        }
    }
    return 1;
}

public static int[][] initialize_all_zeros(int[][] a)
{
    for(int i=0;i<a.length;i++)
    {
        for(int j=0;j<a.length;j++)
        {
            a[i][j]=0;
        }
    }
    return a;
}
public static void display(int[][] a)
{
    for(int i=0;i<a.length;i++)
    {
        for(int j=0;j<a.length;j++)
        {
            System.out.print(a[i][j] + " ");
        }
        System.out.println();
    }
    System.out.println("********");
    count++;
}

public static void generate(int[][] a, int value_to_enter, int done)
{        
    if(done == 0)
    {
        for(int i=0;i<a.length;i++)
        {
            for(int j=0;j<a.length;j++)
            {
                if(a[i][j] == 0)
                {
                    a[i][j]=value_to_enter;
                    value_to_enter++;
                    int v = check_if_array_is_fully_filled(a);
                    if(v == 1)
                    {
                        done = 1;
                    }
                    else
                    {
                        generate(a,value_to_enter,0);
                    }                        
                }
            }
        }                        
    }
    if(done == 1)
    {
        display(a);
    }
}
public static void main(String[] agrs)
{
    int[][] a;
    for(int i=0;i<LENGTH;i++)
    {
        for(int j=0;j<LENGTH;j++)
        {
            a = new int[LENGTH][LENGTH];
            a = initialize_all_zeros(a);
            a[i][j]=1;
            generate(a,2,0);
        }
    }
    System.out.println(count);
}
}

【问题讨论】：

请先给你的变量和函数起有意义的名字，这样代码才能被阅读。
2x2 = 4. 4！ = 24. 排列(n) = n!
这个问题似乎是题外话，因为它主要是关于组合和排列
对 generate 的递归调用不起作用，因为由于调用修改了矩阵，所以只调用了一次。要观察这一点，请查看generate 方法内第一次调用generate 后的矩阵内容。
您需要在 generate 函数结束时回滚（记住您设置值并将其设置回 0 的点），或者复制您的矩阵。此外，您正在递增 value_to_enter，这意味着您对 generate 的第二次迭代将跳过一个值。

标签： java recursion matrix permutation

【解决方案1】：

这里是一维数组的递归函数，使用与您相同的逻辑。 2d 或多或少是一回事。

private static void generate(int[] values, int currentValue) {
    if (currentValue == values.length + 1) {
        System.out.println(Arrays.toString(values));
        return;
    }
    for (int i = 0; i < values.length; i++) {
        if (values[i] == 0) {
            values[i] = currentValue;
            generate(values, currentValue + 1);
            values[i] = 0;
        }
    }
}

这样调用：

generate(new int[3], 1);

输出

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

应该封装在一个

public static void generate(int size) {
    generate(new int[size], 1);
}

【讨论】：

【解决方案2】：

我的伪方法是：

将矩阵转换为列表
置换列表
对于列表的每个排列，将列表转换回矩阵。

您没有提到矩阵中的所有元素是否都是唯一的。如果不是，那么您还需要从排列中删除重复列表（需要在 2 之后、3 之前进行过滤。

置换列表：

理解这一点的最简单方法是递归。

基本步骤是当您有两个数字时，排列很容易。它是（a，b）和（b，a）

要添加第三个元素，您需要将该元素添加到所有位置例如置换(c,{(a,b), (b,a)}) = { (c,a,b), (a,c,b),(a,b,c), (c,b,a), (b,c,a), (b,a,c) }

所以，你的递归将是 permute(a,permutedlist)

对于 permutedlist 中的每个 b，将 a 添加到列表中的所有可能位置。

【讨论】：