Openharmony 軍棋工兵尋徑算法的實現(xiàn)

作者：陳浩南xxx 2022-12-14 17:42:48

在軌道上自由移動,怎樣走都行,只要不超過軌道的區(qū)域,想走多遠就走多遠，但是如果有個棋子(不論敵我)堵住路線，你就不能按照那個路線行進；同時我們還要尋找到最近的路徑。

??https://ost.51cto.com??

一、引言

工兵可在鐵路線上任意行走,其它棋子在鐵路線上只能直走或經過弧形線,不能轉直角彎; 工兵在普通路線上跟其他棋子一樣,走一格。但是在軌道上,就如入無人之地了?？梢栽谲壍郎献杂梢苿?怎樣走都行,只要不超過軌道的區(qū)域,想走多遠就走多遠,但是如果有個棋子(不論敵我)堵住路線,你就不能按照那個路線行進；同時我們還要尋找到最近的路徑。

openharmony 軍棋工兵尋徑算法的實現(xiàn)-開源基礎軟件社區(qū)

二、算法分析

大體要求

1、工兵從起點到終點過程中不能有障礙物阻擋。

2、如何尋求到路徑最短？且是否用時最快。

3、也有可能起點到終點是死路。

軍旗的工兵走法特別像迷宮走法。

迷宮算法

1、深度優(yōu)先搜索（DFS）

它和遞歸的探測思路是基本一致的，可以看成是遞歸方式的非遞歸版本。

2、廣度優(yōu)先搜索（BFS）

廣度優(yōu)先搜索法利用隊列的特點，一層層向外擴展查找可走的方塊，直到找到出口為止，最先找到的這個答案就必然是最短的。

3、根據(jù)特點我們希望最先找到最短的距離故采用bfs的方式。

采用隊列來記錄探測點；當前探測點的四個方向，可以通過的點，保存到這個隊列中，并移除當前探測點。

openharmony 軍棋工兵尋徑算法的實現(xiàn)-開源基礎軟件社區(qū)

右下左上的四個方向探測。

openharmony 軍棋工兵尋徑算法的實現(xiàn)-開源基礎軟件社區(qū)

采用一個二維數(shù)組來存儲 x,y上的障礙物，和探測的點。

let noChessBoard: number[][] = [ // a[j][h]代表j行h列數(shù)據(jù)  // 1,行：row 2、列：column  export const ROW = 12  export const COLUMN = 4
    [1, 1, 1, 1, 1],
    [0, 0, 0, 0, 0],
    [0, 1, 1, 1, 0],
    [0, 1, 1, 1, 0],
    [0, 1, 1, 1, 0],
    [0, 0, 0, 0, 0],
    [0, 1, 0, 1, 0],
    [0, 0, 0, 0, 0],
    [0, 1, 1, 1, 0],
    [0, 1, 1, 1, 0],
    [0, 1, 1, 1, 0],
    [0, 0, 0, 0, 0],
    [1, 1, 1, 1, 1]]

代碼實現(xiàn)

（1）獲取到起點和終點坐標。

this.routeNode = this.engineerRoute(firstChess, moveChess);

（2）獲取二維數(shù)組迷宮標記。

二維數(shù)組是記錄棋盤上 0 是表示可通狀態(tài)，1表示不可通。默認是棋盤鐵路都為0可通。

然后，敵方和友方其中全部設置為不可通1。

// 工兵路徑尋找 （bfs 廣度優(yōu)先搜索）
private engineerRoute(start: Chess, end: Chess): RouteNode {
    let noChessBoard: number[][] = [ // a[j][h]代表j行h列數(shù)據(jù)  // 1,行：row 2、列：column  export const ROW = 12  export const COLUMN = 4
        [1, 1, 1, 1, 1],
        [0, 0, 0, 0, 0],
        [0, 1, 1, 1, 0],
        [0, 1, 1, 1, 0],
        [0, 1, 1, 1, 0],
        [0, 0, 0, 0, 0],
        [0, 1, 0, 1, 0],
        [0, 0, 0, 0, 0],
        [0, 1, 1, 1, 0],
        [0, 1, 1, 1, 0],
        [0, 1, 1, 1, 0],
        [0, 0, 0, 0, 0],
        [1, 1, 1, 1, 1]]

    for (let i = 0;i < this.aList.length; i++) {
        let a = this.aList[i]
        noChessBoard[a.y][a.x] = 1
    }
    for (let i = 0;i < this.bList.length; i++) {
        let b = this.bList[i]
        noChessBoard[b.y][b.x] = 1
    }

    return this.bfs(start, end, noChessBoard)
}

（3）進行廣度優(yōu)先搜索。

private bfs(start: Chess, end: Chess, roads: number[][]): RouteNode{
    Logger.d(TAG, `bfs roads:${JSON.stringify(roads)}`)
    Logger.d(TAG, `bfs start:${JSON.stringify(start)}`)
    Logger.d(TAG, `bfs end:${JSON.stringify(end)}`)
    let routeQueue = new MyArrayQueue()
    let first = new RouteNode(start.x, start.y, 0)
    routeQueue.push(first)
    while (routeQueue.size() != 0) {
        Logger.d(TAG, `bfs scan while routeQueue:${JSON.stringify(routeQueue)}`)
        let node = routeQueue.pop()
        Logger.d(TAG, `bfs scan pop node:${JSON.stringify(node)}`)
        let x = node.x
        let y = node.y
        if (x === end.x && y === end.y) {
            return node
            // break
        }
        for (var i = 0; i < 4; i++) {
            let tx = x + this.dx[i]
            let ty = y + this.dy[i]
            Logger.d(TAG, `bfs scan tx:${tx} ty:${ty}`)
            if (tx >= 0 && tx <= COLUMN && ty >= 0 && ty <= ROW && roads[ty][tx] === 0) { // 如果該位置可以走動
                // 入隊
                Logger.d(TAG, `bfs add tx:${tx} ty:${ty}`)
                let temp = new RouteNode(tx, ty, node.step + 1)
                temp.prev = node
                routeQueue.push(temp)
                Logger.d(TAG, `bfs scan push :${JSON.stringify(routeQueue)}`)
                roads[ty][tx] = 1
            }
        }
        // 擴展完
        Logger.d(TAG, `bfs scan one end...`)
    }
    return null
}

（4）本案例還記錄路徑，采用的是鏈表數(shù)據(jù)結構。

每次把prev給記錄下來。這下就可以追溯到整個完整的探測路線。

export class RouteNode extends Point {
    prev: RouteNode ; //前一個節(jié)點
    next: RouteNode  ; //下一個節(jié)點
    step: number
    constructor(x: number, y: number, step: number) {
        super(x, y)
        this.step = step
    }
}

（5）隊列是自己利用數(shù)組改成的。

openharmony 目前 Deque、Queue 有bug，沒法用；只能用數(shù)組，然后數(shù)組的pop是最后一個，就把探測順序插入第一個。

export class MyArrayQueue {
    nodes: RouteNode[]
    constructor() {
        this.nodes = new Array
    }

    push(node: RouteNode) {
        Logger.d(TAG, `push ...:${JSON.stringify(node)}`)
        this.nodes.unshift(node)
        Logger.d(TAG, `push end.:${JSON.stringify(this.nodes.length)}`)
    }

    pop(): RouteNode{
        return this.nodes.pop()
    }

    size() {
        return this.nodes.length
    }
}