Question

我的编程竞争存在问题。这个问题在某些方面很容易。我写的解决方案效果不好。我想要你对这个问题的看法，你将如何设法解决这个问题更多＆＃34; good＆＃34;编程。

问题：

编写一个程序，将N * N数组作为输入。这个数组   包含整数。你应该找到多少个不同的数字   是否有以下条件：不同的数字也是：

A）相同但接下来是其他的数字。例如1 1可以   被认为是一个数字，因为是相同的数字，并在每个数字旁边   其他

B）（A）为真，如果你有例如1号，那么任何   左，右，上，下的相同数字也相同。

E.g

因此，对于上述情况，有8个不同的数字。这是因为，在数组[0,0] [0,1]和[1,0]可以认为是一个数而不是3个不同。 [1,1]，[2,1]因此[2,0]也是相同的数字。因此，你可以看到最后的数字，[1,1]，[2,1]确实意味着条件，然后[2,0]，[2,1]也暗示条件，但因为[2,1] ]也暗示条件为[1,1]，因此所有[1,1]，[2,1]和[2,0]都是一个数。

我的代码：

public class matrix
{
   public static void main(String[] args)
   {
      int[][] arr = 
      { 
          {1, 2, 3, 4}, 
          {1, 1, 2, 4},
          {5, 6, 2, 2},
      };

      for(int row = 0; row < arr.length; ++row)
      {
         for(int col = 0; col < arr[row].length; ++col)
         {
            //top
            if(row!=0)
            {
               if((arr[row][col] == arr[row-1][col]) || (Math.abs(arr[row][col]) == arr[row-1][col]) || (arr[row][col] == Math.abs(arr[row-1][col])))
               {
                  arr[row-1][col] = -arr[row-1][col];
               }
            }

            //botom
            if(row!=arr.length-1)
            {
               if(arr[row][col] == arr[row+1][col] || Math.abs(arr[row][col]) == arr[row+1][col] || arr[row][col] == Math.abs(arr[row+1][col]))
               {
                  arr[row+1][col] = -arr[row+1][col];
               }
            }

            //left
            if(col!=0)
            {
               if(arr[row][col] == arr[row][col-1] || Math.abs(arr[row][col]) == arr[row][col-1] || arr[row][col] == Math.abs(arr[row][col-1]))
               {
                  arr[row][col-1] = -arr[row][col-1];
               }
            }

            //right
            if(col!=arr[0].length-1)
            {
               if(arr[row][col] == arr[row][col+1] || Math.abs(arr[row][col]) == arr[row][col+1] || arr[row][col] == Math.abs(arr[row][col+1]))
               {
                  arr[row][col+1] = -arr[row][col+1];
               }
            }
         }
      }


      for(int row = 0; row < arr.length; ++row)
      {
         for(int col = 0; col < arr[row].length; ++col)
         {
            System.out.print(arr[row][col] + " ");
         }

         System.out.println();
      }
   }
}

我的逻辑是将相同的数字设置为负数，然后只计算正数以找到不同的数字我想要一种不同的算法，它会产生更小的Big-O复杂性。

感谢。

Answer 1

如果我正确理解您的问题，您可以将其视为图形问题，计算连接组件的数量。

例如，使矩阵中的每个条目成为顶点（由行列标记），因此（0,0）是顶点（值为1）。然后，如果两个顶点直接在彼此的上方，下方，右侧或左侧并且具有相同的值，则它们是相邻的。例如，（0,0）与（0,1）相邻，因为它们都具有值1.（0,1）不与（0,2）相邻，因为第一个具有值1而第二个值为2.然后您计数图表中已连接组件的数量。每个连接的组件代表一个＆＃34;不同的＆＃34;号。

有很多方法可以快速计算连接组件的数量。例如，从顶点（0,0）开始并进行广度优先搜索。您找到的任何顶点都与（0,0）在同一个组件中。然后从尚未找到的任何顶点开始重复。广度优先搜索是线性时间，但您必须多次运行（授予运行次数越多，每次运行的速度越快），因此确定精确的渐近运行时间有点复杂。您的输入大小为n ^ 2（顶点数）。它不会比n ^ 3差，并且可能更接近n ^ 2（请记住n ^ 2表示＆＃34;输入大小为线性＆＃34;）。

在某些条件下在矩阵中查找相同的数字

1 个答案: