Question

我已经在这方面挣扎了一段时间，我对如何解决这个问题感到很困惑。我找到了适用于 MatLab 的内容，但这不是我需要的。

这是我的情景：

private int[][] c = {{1,1,1,1,1,1,1},
                     {0,0,0,0,0,0,0},
                     {0,0,0,0,0,0,0}
                    };

c是一个矩阵，在每个列中我只能将一个值设置为 1 。这意味着像

这样的配置

private int[][] c = {{0,1,0,1,1,0,0},
                     {1,0,0,0,0,1,1},
                     {0,0,1,0,0,0,0}
                    };

有效，而

private int[][] c = {{1,0,1,1,0,1,1},
                     {0,0,1,0,0,0,0},
                     {0,0,0,0,1,0,0}
                    };

不是。我需要的是生成一个Set，其中包含此矩阵的所有有效组合，但我不知道如何开始。我不知道是不是因为它已经晚了而且我已经半睡半醒了，但是我无法想到这样做的好方法。

你有什么想法吗？

Answer 1

实际实现这一点有很多种可能的方法。但你基本上必须从0到3 ⁷计数，并为每个数字创建一个矩阵。

想象一下矩阵的每个可能列都是一个数字：

然后，矩阵可以用3-ary形式的数字表示。数字0000000将对应矩阵

1 1 1 1 1 1 1
0 0 0 0 0 0 0
0 0 0 0 0 0 0

数字0000001将对应矩阵

1 1 1 1 1 1 0
0 0 0 0 0 0 1
0 0 0 0 0 0 0

等等。

然后，您可以计算矩阵的总数，从0到这个数字的计数，将每个数字转换为3-ary形式的字符串，并根据此字符串填充矩阵。

第895个矩阵的数字为1020011，这是您的示例矩阵之一：

 0 1 0 1 1 0 0
 1 0 0 0 0 1 1
 0 0 1 0 0 0 0

一个简单的实现：

public class MatrixCombinations
{
    public static void main(String[] args)
    {
        int cols = 7;
        int rows = 3;
        int count = (int)Math.pow(rows, cols);
        for (int i=0; i<count; i++)
        {
            String s = String.format("%"+cols+"s", 
                Integer.toString(i, rows)).replaceAll(" ", "0");
            int[][] matrix = createMatrix(rows, cols, s);
            System.out.println("Matrix "+i+", string "+s);
            printMatrix(matrix);
        }
    }

    private static int[][] createMatrix(int rows, int cols, String s)
    {
        int result[][] = new int[rows][cols];
        for (int c=0; c<cols; c++)
        {
            int r = s.charAt(c) - '0';
            result[r][c] = 1;
        }
        return result;
    }

    private static void printMatrix(int matrix[][])
    {
        for (int r=0; r<matrix.length; r++)
        {
            for (int c=0; c<matrix[r].length; c++)
            {
                System.out.printf("%2d", matrix[r][c]);
            }
            System.out.println();
        }
    }
}

生成具有一些限制的矩阵的所有可能配置

1 个答案: