java – 广度优先搜索不返回最短路径
作者：互联网
我正在尝试使用Java的广度优先搜索算法.考虑到10×10网格,我试图找到最后一个单元9×9(网格从0,0开始).到达9×9时,它已遍历网格中的所有单元格.我听说BFS会给我最短的路径.但实际上它给了我最长的路径.
>请告诉我这是否是预期的行为？
>如果这是BFS的工作方式,那么获得到9×9单元的最短路径的最佳方法是什么？
请指教.
编辑 – 我已经使用了这个逻辑并完成了我的游戏.如果您想参考,请查看https://play.google.com/store/apps/details?id=com.game.puzzle.game.ballmania.android
码
package com.example.game.bfs.alogrithm;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
public class BFS {
static class Cell {
private int x;
private int y;
private String value;
private boolean visitStatus;
public Cell(int x, int y, String value,boolean visitStatus) {
this.x = x;
this.y = y;
this.value = value;
this.visitStatus=visitStatus;
}
}
private Cell[][] board;
private List<Cell> visited = new ArrayList<Cell>();
private boolean testDone;
public void setBoard(Cell[][] board) {
this.board = board;
}
public Cell getAdjacentUnvisitedCell(Cell cell)
{
int moves[][] = { { -1, 0 }, { 0, -1 }, { 1, 0 }, { 0, 1 } };
for (int n = 0; n < 4 /* moves.length */; ++n) {
int ti = cell.x + moves[n][0];
int tj = cell.y + moves[n][1];
// System.out.println("ti,tj" + ti +"," + tj );
if (ti >= 0 && ti < board.length && tj >= 0 && tj < board[0].length) {
// System.out.println("getAdjacentUnvisitedCell : " + "[" + board[ti][tj].x + "," + board[ti][tj].y + "]" );
// System.out.println("getAdjacentUnvisitedCell : board[ti][tj].visitStatus " + board[ti][tj].visitStatus );
if(!board[ti][tj].visitStatus) {
return board[ti][tj];
}
}
}
return null;
}
public void BFSearch(Cell start, Cell end) {
// BFS uses Queue data structure
Queue<Cell> q = new LinkedList<Cell>();
q.add(start);
visited.add(start);
board[start.x][start.y].visitStatus = true;
//printNode(start);
while( !q.isEmpty() )
{
Cell c;
c = q.peek();
Cell unVisitedadjCell = getAdjacentUnvisitedCell(c);
if(!testDone){
testDone=true;
}
if ( unVisitedadjCell != null )
{ visited.add(unVisitedadjCell);
board[unVisitedadjCell.x][unVisitedadjCell.y].visitStatus = true;
printNode(unVisitedadjCell,c);
q.add(unVisitedadjCell);
}
else
{
q.remove();
}
}
visited.clear(); //Clear visited property of nodes
}
private void printNode(Cell c,Cell node) {
System.out.println("For Node " + node.x +"," + node.y + ", " + "Just Visited : " + "[" + c.x + "," + c.y + "]" );
}
public static void main(String[] args) {
Cell[][] cells = new Cell[10][10];
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
cells[i][j] = new Cell(i, j, "defaultvalue",false);
}
}
BFS board = new BFS();
board.setBoard(cells);
board.BFSearch(cells[0][0], cells[1][4]);
}
}
}
记录：
For Node 0,0, Just Visited : [1,0]
For Node 0,0, Just Visited : [0,1]
For Node 1,0, Just Visited : [2,0]
For Node 1,0, Just Visited : [1,1]
For Node 0,1, Just Visited : [0,2]
For Node 2,0, Just Visited : [3,0]
For Node 2,0, Just Visited : [2,1]
For Node 1,1, Just Visited : [1,2]
For Node 0,2, Just Visited : [0,3]
For Node 3,0, Just Visited : [4,0]
For Node 3,0, Just Visited : [3,1]
For Node 2,1, Just Visited : [2,2]
For Node 1,2, Just Visited : [1,3]
For Node 0,3, Just Visited : [0,4]
For Node 4,0, Just Visited : [5,0]
For Node 4,0, Just Visited : [4,1]
For Node 3,1, Just Visited : [3,2]
For Node 2,2, Just Visited : [2,3]
For Node 1,3, Just Visited : [1,4]
For Node 0,4, Just Visited : [0,5]
For Node 5,0, Just Visited : [6,0]
For Node 5,0, Just Visited : [5,1]
For Node 4,1, Just Visited : [4,2]
For Node 3,2, Just Visited : [3,3]
For Node 2,3, Just Visited : [2,4]
For Node 1,4, Just Visited : [1,5]
For Node 0,5, Just Visited : [0,6]
For Node 6,0, Just Visited : [7,0]
For Node 6,0, Just Visited : [6,1]
For Node 5,1, Just Visited : [5,2]
For Node 4,2, Just Visited : [4,3]
For Node 3,3, Just Visited : [3,4]
For Node 2,4, Just Visited : [2,5]
For Node 1,5, Just Visited : [1,6]
For Node 0,6, Just Visited : [0,7]
For Node 7,0, Just Visited : [8,0]
For Node 7,0, Just Visited : [7,1]
For Node 6,1, Just Visited : [6,2]
For Node 5,2, Just Visited : [5,3]
For Node 4,3, Just Visited : [4,4]
For Node 3,4, Just Visited : [3,5]
For Node 2,5, Just Visited : [2,6]
For Node 1,6, Just Visited : [1,7]
For Node 0,7, Just Visited : [0,8]
For Node 8,0, Just Visited : [9,0]
For Node 8,0, Just Visited : [8,1]
For Node 7,1, Just Visited : [7,2]
For Node 6,2, Just Visited : [6,3]
For Node 5,3, Just Visited : [5,4]
For Node 4,4, Just Visited : [4,5]
For Node 3,5, Just Visited : [3,6]
For Node 2,6, Just Visited : [2,7]
For Node 1,7, Just Visited : [1,8]
For Node 0,8, Just Visited : [0,9]
For Node 9,0, Just Visited : [9,1]
For Node 8,1, Just Visited : [8,2]
For Node 7,2, Just Visited : [7,3]
For Node 6,3, Just Visited : [6,4]
For Node 5,4, Just Visited : [5,5]
For Node 4,5, Just Visited : [4,6]
For Node 3,6, Just Visited : [3,7]
For Node 2,7, Just Visited : [2,8]
For Node 1,8, Just Visited : [1,9]
For Node 9,1, Just Visited : [9,2]
For Node 8,2, Just Visited : [8,3]
For Node 7,3, Just Visited : [7,4]
For Node 6,4, Just Visited : [6,5]
For Node 5,5, Just Visited : [5,6]
For Node 4,6, Just Visited : [4,7]
For Node 3,7, Just Visited : [3,8]
For Node 2,8, Just Visited : [2,9]
For Node 9,2, Just Visited : [9,3]
For Node 8,3, Just Visited : [8,4]
For Node 7,4, Just Visited : [7,5]
For Node 6,5, Just Visited : [6,6]
For Node 5,6, Just Visited : [5,7]
For Node 4,7, Just Visited : [4,8]
For Node 3,8, Just Visited : [3,9]
For Node 9,3, Just Visited : [9,4]
For Node 8,4, Just Visited : [8,5]
For Node 7,5, Just Visited : [7,6]
For Node 6,6, Just Visited : [6,7]
For Node 5,7, Just Visited : [5,8]
For Node 4,8, Just Visited : [4,9]
For Node 9,4, Just Visited : [9,5]
For Node 8,5, Just Visited : [8,6]
For Node 7,6, Just Visited : [7,7]
For Node 6,7, Just Visited : [6,8]
For Node 5,8, Just Visited : [5,9]
For Node 9,5, Just Visited : [9,6]
For Node 8,6, Just Visited : [8,7]
For Node 7,7, Just Visited : [7,8]
For Node 6,8, Just Visited : [6,9]
For Node 9,6, Just Visited : [9,7]
For Node 8,7, Just Visited : [8,8]
For Node 7,8, Just Visited : [7,9]
For Node 9,7, Just Visited : [9,8]
For Node 8,8, Just Visited : [8,9]
For Node 9,8, Just Visited : [9,9]
访问单元格的模式.
解决方法:
从末尾到开头追溯日志.你会发现它实际上找到了最短的路径 – 沿着网格的边缘.不幸的是,在网格中,如果你不允许通过对角线(在这种情况下BFS离开窗口,因为对角线应该具有不同的权重),所有只有“向右”和“向下”操作的路径都是最短的.
你可以通过简单的逻辑看到它 – 从0到9,你必须进行9次移动.你有2个坐标,你从(0,0)到(9,9),你只能在一个操作中改变一个坐标,所以最短路径有9 9 = 18步.追溯并看到此路径有18个步骤.类似地,从开始到结束只有向右和向下操作的任何路径将具有18个步骤,因此任何这样的路径将是最短的.决定路径本身的只是将相邻坐标放入队列的顺序.尝试以随机顺序执行此操作.
编辑：这是如何计算最短路径的数量.
我们之前已经注意到有18个操作;其中9个在右边,9个在向下.这些操作的顺序无关紧要,因为最后你已经将(9,9)添加到初始(0,0),所以你实际上到达了最后.我们如何算他们？让我们为每个操作分配一个标识符：a_1,a_2,… a_18.我们现在要选择其中的9个操作.所以我们选择第一个下行操作点,我们可以用18种方式做(因为有18种操作可供选择),然后是第二种(17种方式),依此类推,直到我们完成下行操作.我们本可以用18 * 17 * …… * 10种方式做到这一点.现在我们为正确的操作选择点.我们可以通过9 * 8 * … * 1种方式(通过神学)这样做.但是现在我们并没有真正区分每个下行指令,对吗？我们可以用9种方式选择第一次向下操作,在8种方式中选择第二种,依此类推.同样,我们可以选择正确的操作.最后我们推断出有(18 * 17 * … * 1)/((9 * 8 * … * 1)*(9 * 8 * … * 1))= 48 620这样做的方式(我们除以操作的区别是无意义的).这也是您可以选择18个中的9个点的方式.
如果我的解释对你来说太乱了,我可以推荐看看Richard A. Brualdi的Introductory combinatorics.关于某些离散数学领域的有趣事情,这是一本非常酷的书.这很容易阅读.
标签：java,a-star,depth-first-search,breadth-first-search 来源： https://codeday.me/bug/20190624/1276035.html