Java 检查二维矩阵上选定的分幅是否全部连接

我正在创建一个带有地图的游戏，它是一个[100平铺x 100平铺]矩阵。玩家可以通过组合4个瓷砖来创建“公爵领地”。游戏将允许玩家选择4个瓷砖，并检查这些瓷砖是否都相互连接，并允许玩家创建公爵领地，前提是它们是相互连接的

因此，我的

isConnected（）

方法将接受一个

ArrayList

，平铺有

getX（）

和

getY（）

方法，它们返回网格上的X和Y坐标。如果磁贴彼此连接，则将返回true，否则返回false。请注意，瓷砖不能对角连接

值得一提的是，该方法需要适用于具有4个以上瓷砖的ArrayList，因为它需要检查更大的瓷砖列表，而Duchy场景就是如何使用该方法的一个示例

---

只是想象一下整个事情

示例输入1（X是选定的分幅）：

示例输出1：

true

---

示例输入2（X是选定的分幅）：

示例输出2：

false

---

我曾想过将所有磁贴逐个与所有其他磁贴进行比较，并假设如果所有磁贴都连接到至少一个其他磁贴，则所有磁贴都是连接的，但我意识到这不起作用，因为对于类似这样的情况，它将返回真值：

[X][X][ ][ ][ ]
[ ][ ][ ][ ][ ]
[ ][ ][ ][ ][ ]
[ ][ ][X][X][ ]
[ ][ ][ ][ ][ ]

---

---

我想不出一种方法来解决这个问题，也找不到在线解决这个问题的方法。

类似于洪水填充算法；获取其中一个分幅并递归使用选择中的相邻分幅。如果选择中的所有磁贴都是以这种方式使用的，则所有选定的磁贴都将连接起来

boolean isConnected(List<Tile> selection) {

    if (selection.isEmpty())
        return true; // ?????

    Queue<Tile> toConsume = new LinkedList<>(selection);
    Queue<Tile> queue = new LinkedList<>();
    queue.add(toConsume.remove());

    while (!queue.isEmpty() && !toConsume.isEmpty()) {
        Tile tile = queue.remove();
        findNeighbours(tile, toConsume)
        .forEach(n -> {
            toConsume.remove(n);
            queue.add(n);
        });
    }
    return toConsume.isEmpty();
}

List<Tile> findNeighbours(Tile tile, Collection<Tile> tiles) {
    return tiles.stream()
        .filter(t -> distance(t, tile) == 1)
        .collect(Collectors.toList());
}

int distance(Tile a, Tile b) {
    int dx = a.getX() - b.getX();
    int dy = a.getY() - b.getY();
    return Math.abs(dx) + Math.abs(dy);
}

boolean未连接（列表选择）{
if（selection.isEmpty（））
返回true；//？？？？？
Queue toConsume=新建链接列表（选择）；
Queue Queue=new LinkedList（）；
add（toConsume.remove（））；
而（！queue.isEmpty（）&&！toConsume.isEmpty（））{
Tile Tile=queue.remove（）；
findNeighbours（瓷砖，用于消费）
.forEach（n->{
删除（n）；
添加（n）；
});
}
返回到consume.isEmpty（）；
}
列表findNeighbours（瓷砖、收藏瓷砖）{
返回tiles.stream（）
.filter（t->distance（t，tile）==1）
.collect（Collectors.toList（））；
}
内部距离（瓷砖a、瓷砖b）{
int dx=a.getX（）-b.getX（）；
int dy=a.getY（）-b.getY（）；
返回Math.abs（dx）+Math.abs（dy）；
}

一种洪水填充算法；获取其中一个分幅并递归使用选择中的相邻分幅。如果选择中的所有磁贴都是以这种方式使用的，则所有选定的磁贴都将连接起来

boolean isConnected(List<Tile> selection) {

    if (selection.isEmpty())
        return true; // ?????

    Queue<Tile> toConsume = new LinkedList<>(selection);
    Queue<Tile> queue = new LinkedList<>();
    queue.add(toConsume.remove());

    while (!queue.isEmpty() && !toConsume.isEmpty()) {
        Tile tile = queue.remove();
        findNeighbours(tile, toConsume)
        .forEach(n -> {
            toConsume.remove(n);
            queue.add(n);
        });
    }
    return toConsume.isEmpty();
}

List<Tile> findNeighbours(Tile tile, Collection<Tile> tiles) {
    return tiles.stream()
        .filter(t -> distance(t, tile) == 1)
        .collect(Collectors.toList());
}

int distance(Tile a, Tile b) {
    int dx = a.getX() - b.getX();
    int dy = a.getY() - b.getY();
    return Math.abs(dx) + Math.abs(dy);
}

boolean未连接（列表选择）{
if（selection.isEmpty（））
返回true；//？？？？？
Queue toConsume=新建链接列表（选择）；
Queue Queue=new LinkedList（）；
add（toConsume.remove（））；
而（！queue.isEmpty（）&&！toConsume.isEmpty（））{
Tile Tile=queue.remove（）；
findNeighbours（瓷砖，用于消费）
.forEach（n->{
删除（n）；
添加（n）；
});
}
返回到consume.isEmpty（）；
}
列表findNeighbours（瓷砖、收藏瓷砖）{
返回tiles.stream（）
.filter（t->distance（t，tile）==1）
.collect（Collectors.toList（））；
}
内部距离（瓷砖a、瓷砖b）{
int dx=a.getX（）-b.getX（）；
int dy=a.getY（）-b.getY（）；
返回Math.abs（dx）+Math.abs（dy）；
}

boolean isConnected(List<Tile> selection) {

    if (selection.isEmpty())
        return true; // ?????

    Queue<Tile> toConsume = new LinkedList<>(selection);
    Queue<Tile> queue = new LinkedList<>();
    queue.add(toConsume.remove());

    while (!queue.isEmpty() && !toConsume.isEmpty()) {
        Tile tile = queue.remove();
        findNeighbours(tile, toConsume)
        .forEach(n -> {
            toConsume.remove(n);
            queue.add(n);
        });
    }
    return toConsume.isEmpty();
}

List<Tile> findNeighbours(Tile tile, Collection<Tile> tiles) {
    return tiles.stream()
        .filter(t -> distance(t, tile) == 1)
        .collect(Collectors.toList());
}

int distance(Tile a, Tile b) {
    int dx = a.getX() - b.getX();
    int dy = a.getY() - b.getY();
    return Math.abs(dx) + Math.abs(dy);
}