Java 在二维阵列中查找连接的单元

编辑：已解决，请参阅下面的我的帖子。

我正在用Java实现一个棋盘游戏，需要开发一个算法来从2d数组中的单个单元格中查找“连接”单元格的数量

编辑：通过连接，我的意思是与我开始的单元格具有相同的值。如果该方法调用一个值为x的单元格，我需要找到所有与它共享一条边（不是对角线）的单元格

也就是说，如果我有一个由1和0组成的2d数组，我想找到我选择的单个单元格的最大连接单元格数：

[1][1][1][0]
[1][0][1][1]
[1][0][0][1]
[1][0][0][1]

在[0][0]上运行该算法将返回10，因为有6个1沿右路径连接，3沿左路径连接

---

有没有一种已知的方法来解决这个问题？如果没有，你将如何着手解决它？我在绞尽脑汁，似乎找不到摆脱困境的办法。任何建议都将不胜感激

您可能想看看一些路径查找算法

最常见和最快的是

concept易于理解和实现。您可以在正在搜索的区域周围找到连接的1或0，而不是查找路径

看看java中2D数组上Dijkstra算法的路径查找

---

通过查看周围的“节点”（1或0），您可以找到“连接”部分。

您可能需要了解一些路径查找算法

最常见和最快的是

concept易于理解和实现。您可以在正在搜索的区域周围找到连接的1或0，而不是查找路径

看看java中2D数组上Dijkstra算法的路径查找

---

通过查看周围的“节点”（1或0），您可以找到“连接”部分。

检查深度优先搜索。递归算法的思想如下：

创建空的单元格堆栈

添加到堆栈起始位置（例如0,0）

拉取堆栈中的单元格（这意味着-将其从堆栈中移除并准备查看），查看此单元格的相邻单元格，将符合条件（=1并共享边缘）的所有相邻单元格添加到同一堆栈中。如图所示，标记牵引单元

重复#3，直到您的表格中有未显示的单元格，或者您面对的相邻单元格集没有符合您条件的单元格，或者堆栈变为空

你应该记得你走过的路，选择最长的一条（包含更多的1）

这是一个非常简单和简短的算法。

---

祝你好运

检查深度优先搜索。递归算法的思想如下：

创建空的单元格堆栈

添加到堆栈起始位置（例如0,0）

拉取堆栈中的单元格（这意味着-将其从堆栈中移除并准备查看），查看此单元格的相邻单元格，将符合条件（=1并共享边缘）的所有相邻单元格添加到同一堆栈中。如图所示，标记牵引单元

重复#3，直到您的表格中有未显示的单元格，或者您面对的相邻单元格集没有符合您条件的单元格，或者堆栈变为空

你应该记得你走过的路，选择最长的一条（包含更多的1）

这是一个非常简单和简短的算法。

---

祝你好运

解决了这个问题，以下是我所做的：

// Java the board game: find connected spaces

public class findConnectedCells
{
    public static int findNumberConnected(int a, int b, int[][] z)
    {
        boolean canUp = (a - 1 >= 0);
        boolean canDown = (a + 1 < z.length);
        boolean canRight = (b + 1 < z[0].length);
        boolean canLeft = (b - 1 >= 0);

        int value = z[a][b];

        int up = 0;
        int down = 0;
        int right = 0;
        int left = 0;

        z[a][b] = 2;

        if (canUp && z[a-1][b] == value)
        {
            up = findNumberConnected(a-1,b,z);
        }
        if (canDown && z[a+1][b] == value)
        {
            down = findNumberConnected(a+1,b,z);
        }
        if (canLeft && z[a][b-1] == value)
        {
            left = findNumberConnected(a,b-1,z);
        }
        if (canRight && z[a][b+1] == value)
        {
            right = findNumberConnected(a,b+1,z);
        }

        return up + left + right + down + 1;
    }


    public static void main(String[] args) {
        System.out.println("Finding connections");

        int[][] z = new int[][]{

                      { 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
                      { 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
                      { 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
                      { 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
                      { 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },   
                    };
        int x = 0;
        int y = 0;

        System.out.println("Number of connected cells from "+x+","+y+" is: "+findNumberConnected(x,y,z));
    }
}

//Java棋盘游戏：查找连通空间
公共类findConnectedCells
{
公共静态int findNumberConnected（int a、int b、int[]z）
{
布尔值canUp=（a-1>=0）；
布尔值canDown=（a+1=0）；
整数值=z[a][b]；
int up=0；
int-down=0；
int right=0；
int左=0；
z[a][b]=2；
if（canUp&&z[a-1][b]==值）
{
向上=已连接的FindNumber（a-1、b、z）；
}
if（canDown&z[a+1][b]==值）
{
向下=已连接的FindNumber（a+1、b、z）；
}
if（canLeft&&z[a][b-1]==值）
{
左=FindNumber连接（a、b-1、z）；
}
if（canRight&&z[a][b+1]==值）
{
右=已连接的FindNumber（a、b+1、z）；
}
返回上+左+右+下+1；
}
公共静态void main（字符串[]args）{
System.out.println（“查找连接”）；
int[][]z=新int[][]{
{ 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
{ 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
{ 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
{ 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
{ 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },   
};
int x=0；
int y=0；
System.out.println（“从“+x+”，“+y+”连接的单元数为：“+findNumberConnected（x，y，z））；
}
}

解决了这个问题，以下是我所做的：

// Java the board game: find connected spaces

public class findConnectedCells
{
    public static int findNumberConnected(int a, int b, int[][] z)
    {
        boolean canUp = (a - 1 >= 0);
        boolean canDown = (a + 1 < z.length);
        boolean canRight = (b + 1 < z[0].length);
        boolean canLeft = (b - 1 >= 0);

        int value = z[a][b];

        int up = 0;
        int down = 0;
        int right = 0;
        int left = 0;

        z[a][b] = 2;

        if (canUp && z[a-1][b] == value)
        {
            up = findNumberConnected(a-1,b,z);
        }
        if (canDown && z[a+1][b] == value)
        {
            down = findNumberConnected(a+1,b,z);
        }
        if (canLeft && z[a][b-1] == value)
        {
            left = findNumberConnected(a,b-1,z);
        }
        if (canRight && z[a][b+1] == value)
        {
            right = findNumberConnected(a,b+1,z);
        }

        return up + left + right + down + 1;
    }


    public static void main(String[] args) {
        System.out.println("Finding connections");

        int[][] z = new int[][]{

                      { 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
                      { 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
                      { 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
                      { 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },
                      { 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1 },   
                    };
        int x = 0;
        int y = 0;

        System.out.println("Number of connected cells from "+x+","+y+" is: "+findNumberConnected(x,y,z));
    }
}

//Java棋盘游戏：查找连通空间
公共类findConnectedCells
{
公共静态int findNumberConnected（int a、int b、int[]z）
{
布尔值canUp=（a-1>=0）；
布尔值canDown=（a+1=0）；
整数值=z[a][b]；
int up=0；
int-down=0；
int right=0；
int左=0；
z[a][b]=2；
if（canUp&&z[a-1][b]==值）
{
向上=已连接的FindNumber（a-1、b、z）；
}
if（canDown&z[a+1][b]==值）
{
向下=已连接的FindNumber（a+1、b、z）；
}
if（canLeft&&z[a][b-1]==值）
{
左=FindNumber连接（a、b-1、z）；
}
if（canRight&&z[a][b+1]==值）
{
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
import java.util.Stack;
import java.util.stream.Stream;

public class SolutionNoRecursion {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);        
        int row = Integer.valueOf(in.nextLine());
        Node[][] matrix = new Node[row][Integer.valueOf(in.nextLine())];

        int count = 0;

        LinkedList<Node> nodes = new LinkedList<>();

        while(row-->0){            
            int[] numbers = Stream.of(in.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

            for (int column = 0; column < numbers.length; column++) {
                if(numbers[column] == 1){                    
                    Node node = new Node();
                    nodes.add(node);
                    matrix[count][column] = node;
                    if(count > 0 && count <= matrix.length){
                        Node upperNode = matrix[count-1][column];
                        connectNodesToEachOther(node, upperNode);
                        if(column < numbers.length-1){
                            Node upperRightNode = matrix[count-1][column+1];
                            connectNodesToEachOther(node, upperRightNode);
                        }
                    }

                    if(column > 0){
                        Node leftNode = matrix[count][column-1];
                        connectNodesToEachOther(node, leftNode);
                    }

                    if(column>0 && count>0){
                        Node upperLeftNode = matrix[count-1][column-1];
                        connectNodesToEachOther(node, upperLeftNode);
                    }                                        
                }                
            }
            count++;
        }
        in.close();


        int maxSoFar = 0;
        for (Node node : nodes) {
            if(node.visited){
                continue;
            }
            node.visited = true;
            int regionCount = 1;
            Stack<Node> stack = new Stack<>();
            stack.push(node);
            while(!stack.empty()){
                Node connection = stack.pop();
                if(!connection.visited){
                    connection.visited = true;
                    regionCount++;
                }
                for(Node nodeCon : connection.connections){
                    if(!nodeCon.visited){
                        stack.push(nodeCon);                        
                    }
                }
            }
            maxSoFar = regionCount > maxSoFar ? regionCount : maxSoFar;
        }

        System.out.println(maxSoFar);
    }

    protected static void connectNodesToEachOther(Node node, Node upperNode) {
        if(upperNode != null){
            node.connections.add(upperNode);
            upperNode.connections.add(node);
        }
    }

}

class Node{
    boolean visited = false;
    List<Node> connections = new LinkedList<>();
}