Java 使用深度优先搜索遍历矩阵以找出渗流

我试图写一个布尔方法，如果矩阵是“满的”或不是，它将返回

（完整站点是一个开放站点，可以通过相邻（左、右、上、下）开放站点链连接到顶层的开放站点。）

对于网格，true=开放站点

我还在学习递归，我在某个地方读到DFS是用来解决迷宫的，所以我正在尝试这条路线

现在，我只是添加了一个相同大小的矩阵来跟踪该地点是否被访问过。我在想办法。给定一个初始点，看看是否可以使用递归遍历到最上面一行

我知道这是错误的，有人的帮助可以指导我。我现在陷入困境，有点沮丧。这就是我目前得到的

private boolean [][] grid;
private boolean [][] visited;
private int size;

public boolean isFull(int i, int j)
{
    int row = i-1;
    int col = j-1;


    //base cases        
    if(row < 0 || row > size || col < 0 || col > size) {
        throw new IndexOutOfBoundsException("Out of Bounds Exception");
    }

    if(row == 0) {
        return true;
    }

    if(visited[row][col]) {
        return false;
    }

    visited[row][col] = true;

    //top
    isFull(row, col-1);
    //bot
    isFull(row, col+1);
    //left
    isFull(row-1, col);
    //right
    isFull(row+1, col);

    return false;
}

private boolean[][]网格；
访问的私有布尔值[][]；
私有整数大小；
公共布尔值isFull（int i，int j）
{
int行=i-1；
int col=j-1；
//基本情况
如果（行<0 | |行>大小| |列<0 | |列>大小）{
抛出新的IndexOutOfBoundsException（“越界异常”）；
}
如果（行==0）{
返回true；
}
如果（访问[行][列]）{
返回false；
}
访问[行][列]=真；
//顶
isFull（行，列1）；
//机器人
isFull（行、列+1）；
//左
isFull（第1行，列）；
//对
isFull（行+1，列）；
返回false；
}

有一种方法使用java和递归方法来检查网格是否渗透。使用“联合查找”算法还有另一种检查方法：

/*
    To start and for convenience, set each elements's
    id to its own index value
*/

//number of elements to test
int n; 

int[] treeSize = new int[n];
int[] id = new int[n];
for(int i = 0; i < n; i++){
    id[i] = i;
    treeSize[i] = 1;
}

void makeUnion(int p, int q){
    /*
       Connect smaller tree to the bigger one by
       making root of the smaller tree the child of
       the root of the bigger tree.
    */
    int pRoot = getRoot(p);
    int qRoot = getRoot(q);

    treeSize[pRoot] < treeSize[qRoot] ?
      id[pRoot] = qRoot, treeSize[qRoot] += treeSize[pRoot] :
      id[qRoot] = pRoot, treeSize[pRoot] += treeSize[qRoot] ;
}

bool connected(int p, int q){
  return getRoot(p) == getRoot(q);
 }

int getRoot(int i){
   /*
     Transverse through parent
     pointers in the tree
     until root is reached
   */
   while(i != id[i]){         //check if root
      id[i] = id[ id[i] ];  //flatten tree a bit(path compression by 1/2) points to grand-parent now
      i = id[i];                          //move up one level
   }
   return i;
}

/*
为方便起见，设置每个元素的
将id设置为其自己的索引值
*/
//要测试的元素数
int n；
int[]treeSize=新的int[n]；
int[]id=新的int[n]；
对于（int i=0；i

---

您迭代整个网格，使用

makeUnion

连接两个点（如果它们是开放的和相邻的），并使用

connected

检查底部和顶部是否连接。

您不需要为第一个基本情况抛出异常，只需返回false即可。