Question

我想使用递归生成矩阵的所有可能排列。例如，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);
}
}

Answer 1

这是使用与您相同的逻辑的1d数组的递归函数。 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);
}

Answer 2

我的伪方法是：

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

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

置换列表：

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

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

要添加第三个元素，您需要将元素添加到所有位置例如permute（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）

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

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

2 个答案: