Java 算法没有显示正确的输出

问题是：

您将得到一个大小为n×n的二进制矩阵（即矩阵的每个元素为0或1）。您希望重新排列1，使其形成一个矩形区域。请注意，矩形区域应仅由1组成，整个矩阵的所有1均应位于该矩形区域中

为了获得矩形区域，可以交换矩阵的任意两个元素。请找出所需的最低掉期数量。如果无法按所需方式重新排列1，请打印-1

输入

输入的第一行包含一个表示测试用例数量的整数T。 T测试用例的描述如下。 每个测试用例的第一行将包含一个表示矩阵维数的整数n。 接下来的n行中的每一行将包含n个表示矩阵第i行的空间分隔整数

输出

对于每个测试用例，打印一行，其中包含一个整数，表示所需的最小交换数或-1，具体取决于情况

示例

输入：

2

2

0 1

1 0

2

1 1 

1 0

输出：

1 

-1

解释

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Main {

    static long startTime;

    public static void main(String[] args) {


Scanner scanner = new Scanner(System.in);
            int numberOfOnes = 0;
            int T = scanner.nextInt();

            for (int t = 1; t <= T; t++) {
                int n = scanner.nextInt();

                int loopCounter, swapCounter = 0;
                boolean rowContainsZero = false;
                int array[][] = new int[n][n];
                boolean reject = true;
                //Worst and the most simpler conditions
                if (n == 1) {
                    System.out.print("0");
                    exitingSystem();
                }
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < n; j++) {
                        array[i][j] = scanner.nextInt();
                        if (array[i][j] == 1) {
                            numberOfOnes++;
                        }
                    }
                }
                if (n % 2 == 0 && numberOfOnes % 2 != 0) {
                    System.out.println("-1");
                    if (t == T) {
                        exitingSystem();
                    }
                    continue;

                } else if (n % 2 != 0 && numberOfOnes % 2 == 0) {
                    System.out.println("-1");
                    if (t == T) {
                        exitingSystem();
                    }
                    continue;
                }
                //     System.out.println("Here i am");
                //From here swaping processes will take the place
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < n; j++) {
                        if (array[i][j] == 1) {
                            continue;
                        } else if (array[i][j] == 0) {
                            loopCounter = i;
                            reject = true;
                            while (loopCounter < n) {
                                if (array[loopCounter][j] == 1) {
                                    int temp = array[loopCounter][j];
                                    array[loopCounter][j] = array[i][j];
                                    array[i][j] = temp;
                                    reject = false;
                                    swapCounter += 1;
                                    break;
                                }
                                loopCounter++;
                            }
                             if (rowContainsZero) {
                                System.out.println("" + swapCounter);
                                    break;
                            }
                            if (reject == true) {
                                System.out.println("-1");
                                break;
                            } else {
                                for (int m = i + 1; m < n; m++) {
                                    for (int k = 0; k < n; k++) {
                                        if (array[m][k] == 0) {
                                            rowContainsZero = true;
                                        } else {
                                            rowContainsZero = false;
                                            break;
                                        }
                                    }
                                }
                            }

                        } else {
                            System.out.println("0's and 1's were Expected :(");
                            exitingSystem();
                        }
                    }
                    if (reject == true) {
                        break;
                    }
                }
            }

    }

    public static void exitingSystem() {
        System.exit(0);
    }

}

例1。可以将第二行第一列的1与第一行第一列的0交换。 交换后，矩阵将如下所示

1 1 
0 0

这里所有的1形成一个尺寸为1×2的矩形区域。在这种情况下，需要进行1次互换

请注意，您也可以将第一行第二列的1与第二行第二列的0交换。 交换后的矩阵如下

0 0
1 1 

所以在这种情况下你也需要1次交换

因此，总体而言，您需要1次交换

例2。无法在2×2的矩阵中创建包含3个1的矩形区域，因此答案为-1

我的算法[编辑]

首先，我从用户那里获取案例数量

那么矩阵的阶数[将是nxn阶]

所以逻辑是，若矩阵是1x1，那个么它只会打印0

否则，当从用户处获取输入时[这将仅为1或0]，我计算1，因为我开发的逻辑是，当在奇数阶矩阵中时，1将为偶数，则不能以矩形形式排列。对于偶数阶矩阵，如果1为奇数，则无法排列

接下来我遍历每个索引，如果我找到一个，然后我移动到下一个元素，否则我尝试在同一列中找到1，如果找不到，那么我打破循环，显示-1，它不能以矩形形式排列

在安排好一行之后，我检查下一行是否已经安排好了，如果已经安排好了，我会打破一切并转到下一个案例

n矩形

我的解决方案

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Main {

    static long startTime;

    public static void main(String[] args) {


Scanner scanner = new Scanner(System.in);
            int numberOfOnes = 0;
            int T = scanner.nextInt();

            for (int t = 1; t <= T; t++) {
                int n = scanner.nextInt();

                int loopCounter, swapCounter = 0;
                boolean rowContainsZero = false;
                int array[][] = new int[n][n];
                boolean reject = true;
                //Worst and the most simpler conditions
                if (n == 1) {
                    System.out.print("0");
                    exitingSystem();
                }
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < n; j++) {
                        array[i][j] = scanner.nextInt();
                        if (array[i][j] == 1) {
                            numberOfOnes++;
                        }
                    }
                }
                if (n % 2 == 0 && numberOfOnes % 2 != 0) {
                    System.out.println("-1");
                    if (t == T) {
                        exitingSystem();
                    }
                    continue;

                } else if (n % 2 != 0 && numberOfOnes % 2 == 0) {
                    System.out.println("-1");
                    if (t == T) {
                        exitingSystem();
                    }
                    continue;
                }
                //     System.out.println("Here i am");
                //From here swaping processes will take the place
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < n; j++) {
                        if (array[i][j] == 1) {
                            continue;
                        } else if (array[i][j] == 0) {
                            loopCounter = i;
                            reject = true;
                            while (loopCounter < n) {
                                if (array[loopCounter][j] == 1) {
                                    int temp = array[loopCounter][j];
                                    array[loopCounter][j] = array[i][j];
                                    array[i][j] = temp;
                                    reject = false;
                                    swapCounter += 1;
                                    break;
                                }
                                loopCounter++;
                            }
                             if (rowContainsZero) {
                                System.out.println("" + swapCounter);
                                    break;
                            }
                            if (reject == true) {
                                System.out.println("-1");
                                break;
                            } else {
                                for (int m = i + 1; m < n; m++) {
                                    for (int k = 0; k < n; k++) {
                                        if (array[m][k] == 0) {
                                            rowContainsZero = true;
                                        } else {
                                            rowContainsZero = false;
                                            break;
                                        }
                                    }
                                }
                            }

                        } else {
                            System.out.println("0's and 1's were Expected :(");
                            exitingSystem();
                        }
                    }
                    if (reject == true) {
                        break;
                    }
                }
            }

    }

    public static void exitingSystem() {
        System.exit(0);
    }

}

导入java.io.File；
导入java.io.FileNotFoundException；
导入java.util.Scanner；
导入java.util.logging.Level；
导入java.util.logging.Logger；
公共班机{
静态长启动时间；
公共静态void main（字符串[]args）{
扫描仪=新的扫描仪（System.in）；
int numberOfOnes=0；
int T=scanner.nextInt（）；
对于（int t=1；t我认为你的算法不完全正确

我认为以下是步骤4/奇数顺序（n=3）和偶数顺序（numberofone=4）的反例：

这应该是0。
n=4和numberOfOnes=3时类似：

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

这也应该为0

我还没有深入分析你的第5步和第6步

以下是更多的例子：

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

这应该是-1，从10个你只能形成2*5或1*10的矩形，这两者都不适合4*4的框架

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

这应该是1，因为通过将左下角向上和向右移动两个位置，可以得到一个3*3的矩形。
我认为您的算法不完全正确

我认为以下是步骤4/奇数顺序（n=3）和偶数顺序（numberofone=4）的反例：

这应该是0。
n=4和numberOfOnes=3时类似：

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

这也应该为0

我还没有深入分析你的第5步和第6步

以下是更多的例子：

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

这应该是-1，从10个你只能形成2*5或1*10的矩形，这两者都不适合4*4的框架

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

这应该是1，因为通过向上和向右移动左下角1两个位置，可以得到一个3*3的矩形。
这不是您试图解决问题的方式。假设您有

                                                                 0 0 1
                                                                 0 1 1
                                                                 0 0 1            

这是一个可解矩阵的完美例子，但您不能简单地使用随机交换然后获取结果。您需要使用带有manhatten距离的
a*
搜索算法


设置优先级队列
定义曼哈坦距离

创建一个函数，该函数创建每个板的成功者。例如，如果我有板上，它将返回一组板：

01
0 1 1==>collection
01

011
0 0 1
01

01
0 0 1
0 1 1

0110
0 1 1
01

01
0 1 1
0 1 0

A.说明：*

最初的lis存储访问过的野猪，这样您就不会再次访问它们

我将把MinPriority队列称为pq
`在pq中插入初始_板
而（！pq.isEmpty（）&&！foundGoal（pq.min））//当
曼哈坦距离为0
board=pq.delMin（）；//您必须重写中的距离方法
优先级队列，以便它将返回给您manhatten的董事会
距离最小
对于（boards b:board.GetSuccessors（）；//提供板的集合
if（notvisitoredlist）（b，vistiedList））//这样您就不会再次处于相同的状态
再说一遍

pq.插入（b）；
访问列表。添加（b）`


在第一年，我必须解决8字谜，你们可以用这种方法解决，但你们也可以使用汉明距离，但这不是有效的，这里的代码（wi）