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

对附近的数字进行计数和分组

比如说我们有一个二维数组

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

我的目标是数一数附近的人数

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

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

最后，在这种情况下

在这个二维数组示例中，将有6个组

测验（a）=6->预期

编程语言并不重要

---

有人能给出一个很棒的算法吗（

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

while (i < MAX_I){
    if (array[i+1] == array[i] || array[i-1] == array[i]){ Do Something}
    i += 2;
}
while (J < MAX_J){
    if (array[j+1] == array[j] || array[j-1] == array[j]){ Do Something}
    i += 2;
}

while（i

---

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

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

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

---

最后，每个元素都有一个组号。

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

函数DFS（x，y，regionId）
{
if（region[x，y]==regionId）返回；
区域[x，y]=区域ID；
if（在（x-1，y）内和&（map[x-1，y]==map[x，y]）DFS（x-1，y，regionId）；
if（在（x+1，y）和&（map[x+1，y]==map[x，y]）内）DFS（x+1，y，regionId）；
if（在（x，y-1）内部和&（map[x，y-1]==map[x，y]）DFS（x，y-1，regionId）；
if（在（x，y+1）和&（map[x，y+1]==map[x，y]））DFS（x，y+1，regionId）；
}
填充（）
{
int regionId=0；
对于（int i=0；i，如上所述，DFS是上述问题的解决方案。
我们使用DFS对元素进行分组，并将它们作为一个元素进行计数

下面是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);
}

公共无效测试（）{
int[][]arr=新的int[][{{5,4,4}，
{4,3,4},
{3,2,4} };
int cols=arr[0]。长度；
int行=arr.length；
整数计数=0；
//迭代矩阵的每个元素
对于（int i=0；它被称为计数岛。内部函数做什么？我不清楚这里的点是否在地图内部，只是检查数组范围。
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);

    }