Question

对数字进行计数和分组

假设我们有一个二维数组，例如，

a = [
          [5,4,4],
          [4,3,4],
          [3,2,4]
    ]

我的目标是计算附近的数字组

对于这种情况 a [0] [0] = 5附近没有相同的数字（a [0] [1]，a [1] [0]不是5） 1组

a [0] [1] = 4在[0] [2]，a [1] [2]，a [2] [2]中具有相同的数字 2组

最后，在这种情况下，

在这个例子中将有6组二维数组。

测验（a）= 6 - ＆gt;预期

编程语言并不重要。

有人可以为此提供一个很棒的算法吗？：（

Answer 1

将数组位置的值作为变量，即阵列[i] [j]; 然后循环检查

public void onClick(View v) {

        int buttonId = v.getId();

        if (buttonId == R.id.buttonViewPrevious)
            if (currentBoothArrayIndex < boothArrayList.size() - 1) {
                displayBoothInformation(--currentBoothArrayIndex);
            } else if (buttonId == R.id.buttonViewNext)
                if (currentBoothArrayIndex < boothArrayList.size() - 1) {
                    displayBoothInformation(++currentBoothArrayIndex);
                } 
    }

可能不是最有效的，但非常简单。

Answer 2

您可以使用广度优先搜索（BFS）。对于数组中的每个元素，将其标记为未访问。然后迭代每个元素，如果没有访问，则执行以下操作：

将此元素添加到队列并将其标记为已访问
表示当前组编号的增量变量
队列不为空
- 将当前组变量值分配给队列中的第一个元素并将其从队列中删除
- 对于此数组中具有相同值的每个未访问过的邻居，将其添加到队列并将其标记为已访问

最后，您将获得每个元素的组号。

Answer 3

DFS足以解决这个问题：

这是非常简单的递归函数：我的伪代码在这里：

function DFS(x, y, regionId)
{
  if (region[x,y] == regionId) return;
  region[x,y] = regionId;
  if (Inside(x-1, y) && (map[x-1,y] == map[x,y])) DFS(x-1, y, regionId);
  if (Inside(x+1, y) && (map[x+1,y] == map[x,y])) DFS(x+1, y, regionId);
  if (Inside(x, y-1) && (map[x,y-1] == map[x,y])) DFS(x, y-1, regionId);
  if (Inside(x, y+1) && (map[x,y+1] == map[x,y])) DFS(x, y+1, regionId);
}

Populate() 
{
  int regionId = 0;
  for(int i=0;i<maxX;i++)
    for(int j=0;j<maxY;j++)
      if (region[x,y] == 0)
      {
        DFS(i, j, ++regionId);
      }

  Console.Write("Total regions = " + regionId);
}

Answer 4

正如Толя提到的，DFS是上述问题的解决方案。我们使用DFS＆amp; amp;将它们视为一个元素。我们为每个元素执行此过程。

以下是Java中的示例代码..

public void test(){
    int[][] arr = new int[][]{ {5,4,4},
               {4,3,4},
               {3,2,4} };
    int cols = arr[0].length;
    int rows = arr.length;

    int count=0;

    //Iterate thru each element of the matrix
    for(int i=0;i<rows;i++){
        for(int j=0;j<cols;j++){

            if(arr[i][j]==Integer.MIN_VALUE)  
                continue;

            dfs(arr,arr[i][j],i,j);
            count++;

         // Printing after every iteration ( code not required, hence commented )
         /* for(int i1=0;i1<rows;i1++){
                for(int j1=0;j1<cols;j1++)
                    System.out.print(" "+arr[i1][j1]);
                System.out.println();
            }
            System.out.println();*/

        }
    }

    System.out.println("No.of.groups = "+count);
}

这是DFS功能

public void dfs(int[][] arr, int key,int row,int col){

        if(row>=arr.length || row<0)
            return;
        if(col>=arr[0].length || col<0)
            return;

        if(arr[row][col]!=key || arr[row][col]==Integer.MIN_VALUE)
            return;

        // Marking the visited element as 'MIN_VALUE'
        arr[row][col] = Integer.MIN_VALUE; 

        dfs(arr,key,row+1,col);
        dfs(arr,key,row-1,col);
        dfs(arr,key,row,col+1);
        dfs(arr,key,row,col-1);

    }

这个二维数组测验有什么好的算法吗？

4 个答案: