在c+中查找二维数组中的最大面积+； 我需要编写C++中的递归函数，它在2D数组中找到最多的“1”区域，只包含1或0个。

例如：

int Arr[5][8] =
{
{ 0, 0, 0, 0, 1, 1, 0, 0, },
{ 1, 0, 0, 1, 1, 1, 0, 0, },
{ 1, 1, 0, 1, 0, 1, 1, 0, },
{ 0, 0, 0, 1, 1, 1, 1, 0, },
{ 0, 1, 1, 0, 0, 0, 0, 0, },
};

可视示例：

该阵列的最大面积为12，第二大面积为3，第三大面积为2

我想用类似于洪水填充算法的方法来实现这一点，但就是不知道如何实现

我想用类似于洪水填充算法的方法来实现这一点

我认为这是一个很好的方法。对任何

1

应用泛洪填充，计算1并将其替换为0

重复此操作，直到网格完全由零组成

以下内容将不按特定顺序打印连接部件的尺寸：

#include <iostream>

constexpr int N = 5;
constexpr int M = 8;

int arr[N][M] =
{
{ 0, 0, 0, 0, 1, 1, 0, 0, },
{ 1, 0, 0, 1, 1, 1, 0, 0, },
{ 1, 1, 0, 1, 0, 1, 1, 0, },
{ 0, 0, 0, 1, 1, 1, 1, 0, },
{ 0, 1, 1, 0, 0, 0, 0, 0, },
};

int fill(int arr[N][M], int r, int c) {
  int count = 0;
  if (r < N && arr[r][c]) {
    for (int i = c; i >= 0 && arr[r][i]; --i) {
      arr[r][i] = 0;
      count += fill(arr, r + 1, i) + 1;
    }
    for (int i = c + 1; i < M && arr[r][i]; ++i) {
      arr[r][i] = 0;
      count += fill(arr, r + 1, i) + 1;
    }
  }
  return count;
}

int print_components(int arr[N][M]) {
  for (int r = 0; r < N; ++r) {
    for (int c = 0; c < M; ++c) {
      if (arr[r][c]) {
        std::cout << fill(arr, r, c) << std::endl;
      }
    }
  }
}

int main() {
  print_components(arr);
}

#包括
constexpr int N=5；
constexpr int M=8；
国际航空公司[N][M]=
{
{ 0, 0, 0, 0, 1, 1, 0, 0, },
{ 1, 0, 0, 1, 1, 1, 0, 0, },
{ 1, 1, 0, 1, 0, 1, 1, 0, },
{ 0, 0, 0, 1, 1, 1, 1, 0, },
{ 0, 1, 1, 0, 0, 0, 0, 0, },
};
整数填充（整数arr[N][M]，整数r，整数c）{
整数计数=0；
if（r=0&&arr[r][i]；--i）{
arr[r][i]=0；
计数+=填充（arr，r+1，i）+1；
}
对于（int i=c+1；i
int max_area = 0;

foreach y
    foreach x
        if (pos[y][x] == 1  &&  !visited[y][x])
        {
            int area = 0;
            Queue queue = new Queue();
            queue.push(new Point(x, y));
            visited[y][x] = true;

            while (!queue.empty())
            {
                Point pt = queue.pop();
                area++;

                foreach neightboor of pt (pt.x±1, pt.y±1)
                    if (pos[neightboor.y][neightboor.x] == 1  &&  !visited[neightboor.y][neightboor.x])
                    {
                        visited[neightboor.y][neightboor.x] = true;
                        queue.push(new Point(neightboor.x, neightboor.y));
                    }
            }

            if (area > max_area)
                max_area = area;
        }

快速的方法，但我不知道是否有一种方法可以以一种理智的方式（递归的）做到这一点
调用每个元素不缩放C++，因为调用堆栈是有限的）

int maxy=5
int max=8
整数区域大小（整数x，整数y）{
if（x<0 | | y<0 | | x>maxx | | y>maxy | |！Arr[y][x]）
返回0；
Arr[y][x]=0；
返回1
+面积大小（x+1，y）
+面积大小（x-1，y）
+面积大小（x，y+1）
+面积（x，y-1）；
}
最大面积=0；
对于（int y=0；y
bool访问[5][8]；
int i，j；
//区域变量：
int当前_面积=0，最大_面积=0；
int Arr[5][8]={//在此处键入您的值映射
}
//功能
无效准备已访问的地图（）{
对于（i=0；iFood fill可以工作。如果你在某个地方卡住了，你应该发布你的尝试并描述你的问题。也许对于每个等于1的元素，检查北、东南和西，然后递增并再次检查。另外，将递增的数组索引添加到忽略列表中。有太多的泛洪填充算法，知道哪一个i这是最好的。一个相关的问题是，我不知道你想怎么做，但是如果你要用
0
替换
1
，你必须小心。否则你可以将一个连接的曲面切成两个，并且不再认识到它们在一开始就属于一起。顺便说一句：OP要求递归解决方案，所以flood fill和backtracking应该可以一起工作谢谢你的提示，我忘记插入erase语句了。
int maxy = 5
int maxx = 8

int areasize(int x, int y) {
    if (x < 0 || y < 0 || x > maxx || y > maxy || !Arr[y][x])
        return 0;

    Arr[y][x] = 0;

    return 1
           + areasize(x + 1, y)
           + areasize(x - 1, y)
           + areasize(x, y + 1)
           + areasize(x, y - 1);
}

maxarea = 0;

for (int y = 0; y < maxy; y++) {
    for (int x = 0; x < maxx; x++) {
        maxarea = std::max(maxarea, areasize(x, y));
    }
}

bool visited[5][8];
int i,j;
// variables for the area:
int current_area = 0, max_area = 0;
int Arr[5][8]={ // type your map of values here
}

// functions

void prepare_visited_map() {
    for(i=0;i<5;i++) {
        for(j=0;j<8;j++) visited[i][j] = false;
    }
}

// recursive function to calculate the area around (x,y)
void calculate_largest_area(int x, int y) {
    if(visited[x][y]) return;
    // check if out of boundaries
    if(x<0 || y<0 || x>=5 || y>=8) return;
    // check if the cell is 0
    if(!Arr[x][y]) {
        visited[x][y] = true;
        return;
    }

    // found a propper cell, proceed
    current_area++;
    visited[x][y] = true;
    // call recursive function for the adjacent cells (north, east, south, west)
    calculate_largest_area(x,y-1);
    calculate_largest_area(x+1,y);
    calculate_largest_area(x,y+1);
    calculate_largest_area(x-1,y);
    // by the end of the recursion current_area will hold the area around the initial    cell
}

// main procedure where the above functions are used
int mian() {
    // calculate the sorrounding area of each cell, and pick up the largest of all results
    for(i=0;i<5;i++) {
        for(j=0;j<8;j++) {
            prepare_visited_map();
            calculate_largest_area(i,j);
            if(current_area > max_area)   max_area = current_area;
        }
    }
    printf("Max area is %d",max_area");
}