The first part to this program was randomly generating a matrix with dimensions between 2 and 6. Then I had to fill this matrix up with 1s and 0s randomly. Using this matrix, I made 2 one-dimensional arrays containing the number of 1's in each row and column. The index of the matrix representing the row number, and the number in the cell representing the count. I made 2 of these arrays: one for row count and one for column count. Here was my code for that.

```
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;
}
}
}
```

Now the problem I'm facing is to recreate this matrix using these counts. **By recreate, I mean just create another matrix that satisfies the the counts of the 1-D arrays, it is not necessary to generate the exact matrix that these counts were derived from.** Here is my code for that so far, I've been working on this for program for 2 days and I can't find an algorithm to generate a matrix for all cases.

Here are the methods for that

```
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;
}
```

The program is from school, so I was already given the method header and the base case for the recursive method, so those must stay the same. Everything else was written by me. I just can't find a good algorithm to generate these matrices. I think I'm supposed to generate every permutation of 1s and 0s in the matrix until one matches the base case, but I don't understand how that would work given the arguments in the recur method.

There is no solution that will work for all cases. Consider:

```
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
```