类似于扫雷游戏的回溯递归，二维布尔数组

Question

基本上这是一个家庭作业，如果你回答我的问题，我更愿意得到答案而不是代码和答案本身。

这必须是一种递归方法，在给定的二维布尔数组中，它必须返回数组中真实区域的数量 - 数组中的行数和列数将始终相同。

真正的区域是在至少有一个真正的元素时定义的，如果它有一个相邻的另一个元素也是如此，它们仍然算作 1。 对角线元素不被视为邻居。

例如，在这个矩阵中，当 1 代表真，0 代表假时，有 3 个真区域 - 左侧的两个单元格，右侧的三个单元格，最后一行的一个单元格，一个人。

1 0 0 1
1 0 1 1
0 1 0 0

我不知道如何递归处理这个问题，我认为在简单的迭代中它会很简单，但似乎不可能使用调用自身的方法检查数组。

有人有线索吗？

Answer 1

既不优雅也不高效，我的第一次尝试是尝试通过递归模拟所有字段的迭代，如果每个字段是一个真正的区域，则返回 1。还传递一个数组来跟踪已检查的字段。对子调用的结果求和。

// spoiler alert 

















































public class Minefield {
  public static void main(String[] args) throws Exception {
    int[][] field = { //
        { 1, 0, 0, 1 }, //
        { 1, 0, 1, 1 }, //
        { 0, 1, 0, 0 }, //
    };
    int w = field[0].length;
    int h = field.length;

    int count = count(0, 0, w, h, true, field, new int[h][w]);
    System.out.println("true zones: " + count);
  }

  private static int count(int x, int y, int w, int h, boolean checkForNewZone /* false: mark zone */, int[][] field, int[][] marked) {
    if(x < 0 || x >= w || y < 0 || y >= h) {
      return /* out of bounds */ 0;
    }

    if(checkForNewZone) {
      int count = 0;
      if(field[y][x] == 1 && marked[y][x] == 0) {
        // a new true zone -> count it
        count++;
        // and mark it
        count(x, y, w, h, false, field, marked);
      }

      // iterate to the next field
      // x++;
      // if(x >= w) {
      //   x = 0;
      //   y++;
      // }
      // count += count(x, y, w, h, true, field, marked);

      // check neighboring fields (right & down should cover everything, assuming the starting point is the top left)
      count += count(x + 1, y, w, h, true, field, marked);
      count += count(x, y + 1, w, h, true, field, marked);
      return count;
    }
    else {
      // mark zone
      if(field[y][x] == 1 && marked[y][x] == 0) {
        marked[y][x] = 1;
        count(x + 1, y, w, h, false, field, marked);
        count(x - 1, y, w, h, false, field, marked);
        count(x, y + 1, w, h, false, field, marked);
        count(x, y - 1, w, h, false, field, marked);
      }

      return 0;
    }
  }
}

Answer 2

典型的递归算法由两部分组成：

1. 基本案例
2. “归纳步骤”

首先确定基本情况。这些可能会通过输入数组的大小来识别。例如，0x0 数组没有真正的区域。 有时会有多个基本情况。

然后确定在给定较小输入版本的答案的情况下，您可以如何计算较大输入版本的答案。这可能看起来像考虑如何从一个具有 Z 个区域的 nxm 阵列转到一个具有 Z' 区域的 (n+1)xm 阵列和一个具有 Z'' 区域的 nx(m+1) 阵列。 通常需要解决稍微复杂的问题才能成功，因为您可以对较小输入的答案进行更多假设。

将这两种情况转换为递归程序通常很容易。

Answer 3

这些本质上是connected components，使用DFS。