java广度优先求解最短路径_java – 广度优先搜索不返回最短路径

我正在尝试使用Java的广度优先搜索算法.考虑到10×10网格,我试图找到最后一个单元9×9(网格从0,0开始).到达9×9时,它已遍历网格中的所有单元格.我听说BFS会给我最短的路径.但实际上它给了我最长的路径.

>请告诉我这是否是预期的行为？

>如果这是BFS的工作方式,那么获得到9×9单元的最短路径的最佳方法是什么？

请指教.

码

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 visited = new ArrayList();

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 q = new LinkedList();

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