Question

这个程序的第一部分是随机生成一个尺寸在2到6之间的矩阵。然后我不得不随机地用1和0填充这个矩阵。使用这个矩阵，我制作了2个一维数组，每行和每列包含1个数。表示行号的矩阵的索引，以及表示计数的单元格中的数字。我制作了两个这样的数组：一个用于行计数，另一个用于列计数。这是我的代码。

    public static void count(int[][] matrix, int[] rowcount, int[] colcount)
  {
     for(int x = 0; x < rowcount.length; x++)
        for(int y = 0; y < colcount.length; y++)
        {
           if (matrix[x][y] == 1)
           {
              rowcount[x] = rowcount[x] + 1;
              colcount[y] = colcount[y] + 1;
           }
        }
  }

现在我遇到的问题是使用这些计数重新创建这个矩阵。 通过重新创建，我的意思是创建另一个满足1-D数组计数的矩阵，不必生成这些计数的精确矩阵。 这是我的代码到目前为止，我已经为程序工作了2天，我找不到算法来为所有情况生成矩阵。

以下是

的方法

    public static void re_create(int[] rowcount, int[] colcount)
  {
     int[][] recreated = new int[rowcount.length][colcount.length];
     recur(recreated, rowcount, colcount, 0, 0);
  }
  private static void recur(int[][] m, int[] rowcount, int[] colcount, int r, int c) //recursive helper method
  {
     if(compare(m, rowcount, colcount))    //base case: if new matrix works
     {
        System.out.println();
        System.out.println("RECREATED");
        display(m, rowcount, colcount);    //we're done!
        System.exit(0);
     }
     else
     { 
        int[] temp_r = new int[m.length];
        int[] temp_c = new int[m[0].length];
        count(m, temp_r, temp_c);
        if(rowcount[r] > temp_r[r] && colcount[c] > temp_c[c])
           m[r][c] = 1;
        if(r+1 < m.length)
           recur(m,rowcount,colcount,r+1,c);
        if(rowcount[r] < temp_r[r] || colcount[c] < temp_c[c])
           m[r][c] = 0;
        if(c+1 < m[0].length)
           recur(m,rowcount,colcount,r,c+1);     
     }
  }
  private static boolean compare(int[][] m, int[] rowcount, int[] colcount)
  {
     int[] temp_r = new int[m.length];
     int[] temp_c = new int[m[0].length];
     count(m, temp_r, temp_c);

     for (int x = 0; x < temp_r.length; x++)
     {
        if(temp_r[x] != rowcount[x])
           return false;
     }

     for (int y = 0; y < temp_c.length; y++)
     {
        if(temp_c[y] != colcount[y])
           return false;
     }

     return true; 
  }

该程序来自学校，所以我已经给出了方法标题和递归方法的基本情况，所以这些必须保持不变。其他一切都是我写的。我只是找不到一个好的算法来生成这些矩阵。我想我应该在矩阵中生成1和0的每个排列，直到一个匹配基本情况，但我不明白如果给出recur方法中的参数将如何工作。

Answer 1

没有适合所有情况的解决方案。考虑：

0 1 0 0 | 1    0 0 1 0 | 1
1 0 1 0 | 2    0 1 0 1 | 2
0 1 0 1 | 2    1 0 1 0 | 2
0 0 1 0 | 1    0 1 0 0 | 1
-------        -------
1 2 2 1        1 2 2 1

Answer 2

这是我提出的解决方案。对我来说似乎是对的，但我没有给它提供很多测试数据。

public static void re_create(int[] rowcount, int[] colcount) {
    int[][] recreated = new int[rowcount.length][colcount.length];
    for (int y = 0; y < rowcount.length; y++) {
        for (int x = 0; x < colcount.length; x++) {
            if (rowcount[y] > 0 && colcount[x] > 0) {
                recreated[x][y] = 1;
                rowcount[y]--;
                colcount[x]--;
            } else {
                recreated[x][y] = 0;
            }
        }
        if (rowcount[y] != 0) {
            throw new IllegalArgumentException("Impossible! y = " + y);
        }
    }
    for (int x = 0; x < colcount.length; x++) {
        if (colcount[x] != 0) {
            throw new IllegalArgumentException("Impossible! x = " + x);
        }
    }
    System.out.println(Arrays.deepToString(recreated));
}

如果给定每行和每列1的数量，如何重建（0-1）矩阵？

2 个答案: