C 查找二维阵列中的所有相邻元素

我正在做一个项目，在某一点上我被卡住了

我的问题是，例如，我有一个包含3个不同整数的2D数组

2 2 2 2 1 
1 2 2 2 1 
3 3 2 3 2 
3 1 3 3 1 
1 1 2 3 1 
1 3 1 3 3 

我想要的是找到数组中包含的任意数的最长相邻元素链

与上面的数组一样，最长的链是数字2

2 2 2 2
  2 2 2
    2

---

有人能告诉我如何才能达到这个目标吗？

假设你的矩阵是一个图，元素是顶点。如果两个顶点相邻且具有相同的值，则它们是连接的。如果您在该图中执行任何搜索，无论是或，您都会得到您想要的结果。画起来容易，解释起来难

2 2 2 2 1 => A A A A B => (A: 4, B: 1)
1 2 2 2 1 => C A A A B => (A: 3 + 4, B: 1 + 1, C: 1)
3 3 2 3 2 => D D A E F => (A: 1 + 7, B: 2, C: 1, D: 2, E: 1, F: 1)
3 1 3 3 1 => D G E E G => (A: 8, B: 2, C: 1, D: 2 + 1, E: 2 + 1, F: 1, G: 1)
1 1 2 3 1 => ...
1 3 1 3 3 => ...

更新：

现在，用一些真实的代码：

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#define ROWS 6
#define COLS 5

unsigned char eles[ROWS][COLS] = { { 2, 2, 2, 2, 1 }, 
                                   { 1, 2, 2, 2, 1 }, 
                                   { 3, 3, 2, 3, 2 }, 
                                   { 3, 1, 3, 3, 1 }, 
                                   { 1, 1, 2, 3, 1 }, 
                                   { 1, 3, 1, 3, 3 } };

struct zone {
  int acu;
  int row, col;
  int refs;
};

typedef struct zone zone;

zone *
new_zone(int row, int col) {
  zone *z = (zone *)malloc(sizeof(zone));
  z->col = col;
  z->row = row;
  z->refs = 1;
  z->acu = 0;
}

void croak (const char *str) {
  fprintf(stderr, "error: %s\n", str);
  exit(1);
}

void
free_zone(zone *z) {
  if (z->refs != 0) croak("free_zone: reference count is not cero");
  free(z);
}

zone *
ref_zone(zone *z) {
  z->refs++;
  return z;
}

void
unref_zone(zone *z) {
  z->refs--;
  if (!z->refs) free_zone(z);
}

int
main() {
  zone *last[COLS];
  zone *current[COLS];
  zone *best = new_zone(0, 0);
  int i, j;
  memset(last, 0, sizeof(last));

  for (j = 0; j < ROWS; j++) {
    for (i = 0; i < COLS; i++) {
      unsigned int ele = eles[j][i];
      zone *z;
      /* printf("analyzing ele: %d at row %d, col: %d\n", ele, j, i); */
      if (i && (ele == eles[j][i-1])) {
        /* printf("  equal to left element\n"); */
        z = ref_zone(current[i-1]);
        if (j && (ele == eles[j-1][i])) {
          zone *z1 = last[i];
          /* printf("  equal to upper element\n"); */
          if (z != z1) {
            int k;
            /* printf("  collapsing zone %p\n", z1); */
            z->acu += z1->acu;
            for (k = 0; k < COLS; k++) {
              if (last[k] == z1) {
                last[k] = ref_zone(z);
                unref_zone(z1);
              }
            }
            for (k = 0; k < i; k++) {
              if (current[k] == z1) {
                current[k] = ref_zone(z);
                unref_zone(z1);
              }
            }
          }
        }
      }
      else if (j && (ele == eles[j-1][i])) {
        /* printf("  equal to upper element\n"); */
        z = ref_zone(last[i]);
      }
      else {
        /* printf("  new element\n"); */
        z = new_zone(j, i);
      }
      z->acu++;
      current[i] = z;
      /* printf("  element zone: %p\n", z); */
    }
    for (i = 0; i < COLS; i++) {
      if (j) unref_zone(last[i]);
      last[i] = current[i];
      if (best->acu < current[i]->acu) {
        unref_zone(best);
        best = ref_zone(current[i]);
        /* printf("best zone changed to %p at row; %d, col: %d, acu: %d\n", best, best->row, best->col, best->acu); */
      }
    }
  }
  printf("best zone is at row: %d, col: %d, ele: %d, size: %d\n", best->row, best->col, eles[best->row][best->col], best->acu);
}

#包括
#包括
#包括
#定义第6行
#定义COLS 5
无符号字符元素[行][COLS]={{2,2,2,2,1}，
{ 1, 2, 2, 2, 1 }, 
{ 3, 3, 2, 3, 2 }, 
{ 3, 1, 3, 3, 1 }, 
{ 1, 1, 2, 3, 1 }, 
{ 1, 3, 1, 3, 3 } };
结构区{
int acu；
int row，col；
参考文献；
};
类型定义结构区；
地带*
新_区（国际行、国际列）{
分区*z=（分区*）malloc（分区大小）；
z->col=col；
z->行=行；
z->refs=1；
z->acu=0；
}
void croak（常量字符*str）{
fprintf（strderr，“错误：%s\n”，str）；
出口（1）；
}
无效的
自由区（z区）{
如果（z->refs！=0）croak（“自由区：参考计数不是cero”）；
自由（z）；
}
地带*
参考分区（分区*z）{
z->refs++；
返回z；
}
无效的
unref_区（z区）{
z->参考文献--；
如果（！z->refs）自由区（z）；
}
int
main（）{
区域*最后一个[COLS]；
区域*电流[COLS]；
分区*最佳=新分区（0,0）；
int i，j；
memset（last，0，sizeof（last））；
对于（j=0；jacu+=z1->acu；
对于（k=0；kacu++；
电流[i]=z；
/*printf（“元素区域：%p\n”，z）*/
}
对于（i=0；iacu<当前[i]>acu）{
unref_区（最佳）；
最佳=参考区（当前[i]）；
/*printf（“最佳区域在第行更改为%p；%d，列：%d，acu:%d\n”，最佳，最佳->行，最佳->列，最佳->acu）*/
}
}
}
printf（“最佳区域位于行：%d，列：%d，元素：%d，大小：%d\n”，最佳->行，最佳->列，元素[最佳->行][最佳->列]，最佳->acu）；
}

定义另一个相同大小的二维数组，将所有单元格初始化为0

将maxval设置为0

如果helper数组中满是1，请转到5，否则请查找包含0和do的单元格：
3.1将单元格的值更改为1
3.2将计数器设置为1
3.3检查所有相邻单元格，如果它们在助手数组中为0，并且与输入数组中的当前单元格值相同，则使用计数器++并使用新坐标转到2.1

maxval=max（maxval，计数器），转到3

返回最大值

---

步骤3.1-3.3应实现为一个递归函数，该函数将坐标和两个数组作为参数，并返回1+递归调用返回值的总和。

您可以将其视为绘画应用程序中的图片。对2D数组中的每个元素执行一次扫描（除非其已被其他元素填充），并跟踪在每个步骤中填充的像素数

如果数组声明为

int elements[5][5];

然后引入第二个数组，它告诉你是否已经填充了一个元素（如果你愿意，在你的C程序中可以使用另一种类型，比如

bool

）：

接下来，编写一个递归函数，该函数执行泛洪填充并返回填充的元素数（我是从头开始写的，不保证该函数按原样工作）：

int泛洪填充（int x，int y）{
int filledPixels=0；
如果（！pixelFilled[x][y]）{
++填充像素；
像素填充[x][y]=1；
}否则{
返回0；
}
if（x<4&&元素[x+1][y]==元素[x][y]）
填充像素+=泛光填充（x+1，y）；
如果（x>0&&elements[x-1][y]==elements[x][y]）
填充像素+=泛光填充（x-1，y）；
if（y<4&&elements[x][y+1]==elements[x][y]）
填充像素+=泛光填充（x，y+1）；
如果（y>0&&elements[x][y-1]==elements[x][y]）
填充像素+=泛光填充（x，y-1）；
返回填充像素；
}

最后，迭代数组并尝试完全填充它。跟踪最大的填充阵列：

int thisArea = 0;
int largestArea = 0;
int x, y;
for ( y = 0; y < 5; ++y ) {
  for ( x = 0; x < 5; ++x ) {
    thisArea = floodFill( x, y );
    if (thisArea > largestArea ) {
      largestArea = thisArea;
    }
  }
}

int thisrea=0；
int largestrea=0；
int x，y；
对于（y=0；y<5；++y）{
对于（x=0；x<5；++x）{
该区域=洪水填充（x，y）；
如果（该区域>大面积）{
大面积=该区域；
}
}
}

现在，

largestrea

应该包含相邻元素最长链的大小。

int floodFill( int x, int y ) { int filledPixels = 0; if ( !pixelFilled[x][y] ) { ++filledPixels; pixelFilled[x][y] = 1; } else { return 0; } if ( x < 4 && elements[x+1][y] == elements[x][y] ) filledPixels += floodFill( x + 1, y ); if ( x > 0 && elements[x-1][y] == elements[x][y] ) filledPixels += floodFill( x - 1, y ); if ( y < 4 && elements[x][y+1] == elements[x][y] ) filledPixels += floodFill( x, y + 1 ); if ( y > 0 && elements[x][y-1] == elements[x][y] ) filledPixels += floodFill( x, y - 1 ); return filledPixels; }

int thisArea = 0;
int largestArea = 0;
int x, y;
for ( y = 0; y < 5; ++y ) {
  for ( x = 0; x < 5; ++x ) {
    thisArea = floodFill( x, y );
    if (thisArea > largestArea ) {
      largestArea = thisArea;
    }
  }
}

typedef struct Point {
   int x;
   int y;
} Point;

int areaOfBiggestContiguousRegion(int* mat,int nRows, int nCols) {
  int maxArea = 0;
  int currValue, queueSize, queueIndex;  
  int* aux;
  Point queue[1000]; //Stores the points I need to label
  Point newPoint, currentPoint;
  int x,y,x2,y2;
  //Code: allocate support array aux of same size of mat
  //Code: fill aux of zeros

  for (y = 0; y < nRows; y++)
    for (x = 0; x < nCols; x++)
      if (aux[y * nCols + x] == 0) {//I find a pixel not yet labeled, my seed for the next flood fill
        queueIndex = 0; //Contains the index to the next element in the queue
        queueSize = 0;

        currValue = mat[y * nCols + x]; //The "color" of the current spot
        aux[y * nCols + x] = 1;
        newPoint.x = x;
        newPoint.y = y;
        queue[queueSize] = newPoint;
        queueSize++; 

        while(queueIndex != queueSize) {
          currPoint = queue[queueIndex];
          queueIndex++;

          //Look left, right, up, down

          x2 = currPoint.x - 1;
          y2 = currPoint.y;
          //Some copy & paste, sorry I have been too long on C++ to remember correctly about C functions
          if (x2 >= 0 && aux[y2 * nCols + x2] == 0 && mat[y2 * nCols + x2] == currValue) {
            aux[y2 * nCols + x2] = 1;
            newPoint.x = x2;
            newPoint.y = y2;
            queue[queueSize] = newPoint;
            queueSize++; 
          }

          x2 = currPoint.x + 1;
          y2 = currPoint.y;
          //Some copy & paste, sorry I have been too long on C++ to remember correctly about C functions
          if (x2 < nCols && aux[y2 * nCols + x2] == 0 && mat[y2 * nCols + x2] == currValue) {
            aux[y2 * nCols + x2] = 1;
            newPoint.x = x2;
            newPoint.y = y2;
            queue[queueSize] = newPoint;
            queueSize++; 
          }

          x2 = currPoint.x;
          y2 = currPoint.y - 1;
          //Some copy & paste, sorry I have been too long on C++ to remember correctly about C functions
          if (y2 >= 0 && aux[y2 * nCols + x2] == 0 && mat[y2 * nCols + x2] == currValue) {
            aux[y2 * nCols + x2] = 1;
            newPoint.x = x2;
            newPoint.y = y2;
            queue[queueSize] = newPoint;
            queueSize++; 
          }

          x2 = currPoint.x;
          y2 = currPoint.y + 1;
          //Some copy & paste, sorry I have been too long on C++ to remember correctly about C functions
          if (y2 < nRows && aux[y2 * nCols + x2] == 0 && mat[y2 * nCols + x2] == currValue) {
            aux[y2 * nCols + x2] = 1;
            newPoint.x = x2;
            newPoint.y = y2;
            queue[queueSize] = newPoint;
            queueSize++; 
          }
        } //while

      if (queueSize > maxArea)
        maxArea = queueSize; //If necessary we could store other details like currentValue
      }//if (aux...

return maxArea;
}