當前位置:首頁 » 操作系統 » a星演算法代碼

a星演算法代碼

發布時間: 2023-07-06 03:43:50

A. 人工智慧 A*演算法原理

A 演算法是啟發式演算法重要的一種,主要是用於在兩點之間選擇一個最優路徑,而A 的實現也是通過一個估值函數

上圖中這個熊到樹葉的 曼哈頓距離 就是藍色線所表示的距離,這其中不考慮障礙物,假如上圖每一個方格長度為1,那麼此時的熊的曼哈頓距離就為9.
起點(X1,Y1),終點(X2,Y2),H=|X2-X1|+|Y2-Y1|
我們也可以通過幾何坐標點來算出曼哈頓距離,還是以上圖為例,左下角為(0,0)點,熊的位置為(1,4),樹葉的位置為(7,1),那麼H=|7-1|+|1-4|=9。

還是以上圖為例,比如剛開始熊位置我們會加入到CLOSE列表中,而熊四周它可以移動到的點位我們會加入到OPEN列表中,並對熊四周的8個節點進行F=G+H這樣的估值運算,然後在這8個節點中選中一個F值為最小的節點,然後把再把這個節點從OPEN列表中刪除,加入到Close列表中,從接著在對這個節點的四周8個節點進行一個估值運算,再接著依次運算,這樣說大家可能不是太理解,我會在下邊做詳細解釋。

從起點到終點,我們通過A星演算法來找出最優路徑

我們把每一個方格的長度定義為1,那從起始點到5位置的代價就是1,到3的代價為1.41,定義好了我們接著看上圖,接著運算

第一步我們會把起始點四周的點加入OPEN列表中然後進行一個估值運算,運算結果如上圖,這其中大家看到一個小箭頭都指向了起點,這個箭頭就是指向父節點,而open列表的G值都是根據這個進行計算的,意思就是我從上一個父節點運行到此處時所需要的總代價,如果指向不一樣可能G值就不一樣,上圖中我們經過計算發現1點F值是7.41是最小的,那我們就選中這個點,並把1點從OPEN列表中刪除,加入到CLOSE列表中,但是我們在往下運算的時候發現1點的四周,2點,3點和起始點這三個要怎麼處理,首先起始點已經加入到了CLOSE,他就不需要再進行這種運算,這就是CLOSE列表的作用,而2點和3點我們也可以對他進行運算,2點的運算,我們從1移動到2點的時候,他需要的代價也就是G值會變成2.41,而H值是不會變的F=2.41+7=9.41,這個值我們發現大於原來的的F值,那我們就不能對他進行改變(把父節點指向1,把F值改為9.41,因為我們一直追求的是F值最小化),3點也同理。

在對1點四周進行運算後整個OPEN列表中有兩個點2點和3點的F值都是7.41,此時我們系統就可能隨機選擇一個點然後進行下一步運算,現在我們選中的是3點,然後對3點的四周進行運算,結果是四周的OPEN點位如果把父節點指向3點值時F值都比原來的大,所以不發生改變。我們在看整個OPEN列表中,也就2點的7.41值是最小的,那我們就選中2點接著運算。

我們在上一部運算中選中的是1點,上圖沒有把2點加入OPEN列表,因為有障礙物的阻擋從1點他移動不到2點,所以沒有把2點加入到OPEN列表中,整個OPEN列表中3的F=8是最小的,我們就選中3,我們對3點四周進行運算是我們發現4點經過計算G=1+1=2,F=2+6=8所以此時4點要進行改變,F變為8並把箭頭指向3點(就是把4點的父節點變為3),如下圖

我們就按照這種方法一直進行運算,最後 的運算結果如下圖

而我們通過目標點位根據箭頭(父節點),一步一步向前尋找最後我們發現了一條指向起點的路徑,這個就是我們所需要的最優路徑。 如下圖的白色選中區域

但是我們還要注意幾點

最優路徑有2個

這是我對A*演算法的一些理解,有些地方可能有BUG,歡迎大家指出,共同學習。

B. A*演算法用於路徑規劃,有什麼缺點

缺點:A*演算法通過比較當前路徑柵格的8個鄰居的啟發式函數值F來逐步確定下一個路徑柵格,當存在多個最小值時A*演算法不能保證搜索的路徑最優。
A*演算法;A*(A-Star)演算法是一種靜態路網中求解最短路徑最有效的直接搜索方法。估價值與實際值越接近,估價函數取得就越好。A*[1] (A-Star)演算法是一種靜態路網中求解最短路最有效的直接搜索方法。注意是最有效的直接搜索演算法。之後涌現了很多預處理演算法(ALT,CH,HL等等),在線查詢效率是A*演算法的數千甚至上萬倍。公式表示為: f(n)=g(n)+h(n),其中 f(n) 是從初始點經由節點n到目標點的估價函數,g(n) 是在狀態空間中從初始節點到n節點的實際代價,h(n) 是從n到目標節點最佳路徑的估計代價。保證找到最短路徑(最優解的)條件,關鍵在於估價函數f(n)的選取:估價值h(n)<= n到目標節點的距離實際值,這種情況下,搜索的點數多,搜索范圍大,效率低。但能得到最優解。並且如果h(n)=d(n),即距離估計h(n)等於最短距離,那麼搜索將嚴格沿著最短路徑進行, 此時的搜索效率是最高的。如果 估價值>實際值,搜索的點數少,搜索范圍小,效率高,但不能保證得到最優解。

C. A星搜索演算法

A星演算法是定義了一個函數f,公式為:
f = g + h
其中g函數代表目前為止從出發地到達該節點的成本,h函數是預估的當前節點到到目的地的成本,即
g(path) = path cost
h(path) = h(s) = estimated distance to goal
朝著使函數f具有最小值的路徑拓展,該演算法可以找到消耗最小消耗的路徑

注意A星演算法並不是總能找到最優解,能否找到最優解依賴於h函數,條件是

D. 如何基於Cocos2d-x v3.x實現A星尋路演算法

實現A星演算法
根據演算法,第一步是添加當前坐標到open列表。還需要三個輔助方法:
- 一個方法用來插入一個ShortestPathStep對象到適當的位置(有序的F值)
- 一個方法用來計算從一個方塊到相鄰方塊的移動數值
- 一個方法是根據"曼哈頓距離"演算法,計算方塊的H值

打開CatSprite.cpp文件,添加如下方法:

void CatSprite::insertInOpenSteps(CatSprite::ShortestPathStep *step)
{
int stepFScore = step->getFScore();
ssize_t count = _spOpenSteps.size();
ssize_t i = 0;
for (; i < count; ++i)
{
if (stepFScore <= _spOpenSteps.at(i)->getFScore())
{
break;
}
}
_spOpenSteps.insert(i, step);
}
int CatSprite::computeHScoreFromCoordToCoord(const Point &fromCoord, const Point &toCoord)
{
// 這里使用曼哈頓方法,計算從當前步驟到達目標步驟,在水平和垂直方向總的步數
// 忽略了可能在路上的各種障礙
return abs(toCoord.x - fromCoord.x) + abs(toCoord.y - fromCoord.y);
}
int CatSprite::(const ShortestPathStep *fromStep, const ShortestPathStep *toStep)
{
// 因為不能斜著走,而且由於地形就是可行走和不可行走的成本都是一樣的
// 如果能夠對角移動,或者有沼澤、山丘等等,那麼它必須是不同的
return 1;
}

接下來,需要一個方法去獲取給定方塊的所有相鄰可行走方塊。因為在這個游戲中,HelloWorld管理著地圖,所以在那裡添加方法。打開HelloWorldScene.cpp文件,添加如下方法:

PointArray *HelloWorld::(const Point &tileCoord) const
{
PointArray *tmp = PointArray::create(4);
// 上
Point p(tileCoord.x, tileCoord.y - 1);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
// 左
p.setPoint(tileCoord.x - 1, tileCoord.y);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
// 下
p.setPoint(tileCoord.x, tileCoord.y + 1);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
// 右
p.setPoint(tileCoord.x + 1, tileCoord.y);
if (this->isValidTileCoord(p) && !this->isWallAtTileCoord(p))
{
tmp->addControlPoint(p);
}
return tmp;
}

可以繼續CatSprite.cpp中的moveToward方法了,在moveToward方法的後面,添加如下代碼:

bool pathFound = false;
_spOpenSteps.clear();
_spClosedSteps.clear();
// 首先,添加貓的方塊坐標到open列表
this->insertInOpenSteps(ShortestPathStep::createWithPosition(fromTileCoord));
do
{
// 得到最小的F值步驟
// 因為是有序列表,第一個步驟總是最小的F值
ShortestPathStep *currentStep = _spOpenSteps.at(0);
// 添加當前步驟到closed列表
_spClosedSteps.pushBack(currentStep);
// 將它從open列表裡面移除
// 需要注意的是,如果想要先從open列表裡面移除,應小心對象的內存
_spOpenSteps.erase(0);
// 如果當前步驟是目標方塊坐標,那麼就完成了
if (currentStep->getPosition() == toTileCoord)
{
pathFound = true;
ShortestPathStep *tmpStep = currentStep;
CCLOG("PATH FOUND :");
do
{
CCLOG("%s", tmpStep->getDescription().c_str());
tmpStep = tmpStep->getParent(); // 倒退
} while (tmpStep); // 直到沒有上一步
_spOpenSteps.clear();
_spClosedSteps.clear();
break;
}
// 得到當前步驟的相鄰方塊坐標
PointArray *adjSteps = _layer->(currentStep->getPosition());
for (ssize_t i = 0; i < adjSteps->count(); ++i)
{
ShortestPathStep *step = ShortestPathStep::createWithPosition(adjSteps->getControlPointAtIndex(i));
// 檢查步驟是不是已經在closed列表
if (this->getStepIndex(_spClosedSteps, step) != -1)
{
continue;
}
// 計算從當前步驟到此步驟的成本
int moveCost = this->(currentStep, step);
// 檢查此步驟是否已經在open列表
ssize_t index = this->getStepIndex(_spOpenSteps, step);
// 不在open列表,添加它
if (index == -1)
{
// 設置當前步驟作為上一步操作
step->setParent(currentStep);
// G值等同於上一步的G值 + 從上一步到這里的成本
step->setGScore(currentStep->getGScore() + moveCost);
// H值即是從此步驟到目標方塊坐標的移動量估算值
step->setHScore(this->computeHScoreFromCoordToCoord(step->getPosition(), toTileCoord));
// 按序添加到open列表
this->insertInOpenSteps(step);
}
else
{
// 獲取舊的步驟,其值已經計算過
step = _spOpenSteps.at(index);
// 檢查G值是否低於當前步驟到此步驟的值
if ((currentStep->getGScore() + moveCost) < step->getGScore())
{
// G值等同於上一步的G值 + 從上一步到這里的成本
step->setGScore(currentStep->getGScore() + moveCost);
// 因為G值改變了,F值也會跟著改變
// 所以為了保持open列表有序,需要將此步驟移除,再重新按序插入
// 在移除之前,需要先保持引用
step->retain();
// 現在可以放心移除,不用擔心被釋放
_spOpenSteps.erase(index);
// 重新按序插入
this->insertInOpenSteps(step);
// 現在可以釋放它了,因為open列表應該持有它
step->release();
}
}
}
} while (_spOpenSteps.size() > 0);
if (!pathFound)
{
SimpleAudioEngine::getInstance()->playEffect("hitWall.wav");
}

添加以下方法:

ssize_t CatSprite::getStepIndex(const cocos2d::Vector<CatSprite::ShortestPathStep *> &steps, const CatSprite::ShortestPathStep *step)
{
for (ssize_t i = 0; i < steps.size(); ++i)
{
if (steps.at(i)->isEqual(step))
{
return i;
}
}
return -1;
}

E. lua語言a星尋路演算法路徑怎麼平滑

在項目中遇到了自動尋路的需求,於是決定開始學習一下A星,對於A星我也沒有深究,只能說是勉強搞定了需求,在這和大家分享一下,相互進步,

A星有個公式 f(x) = g(x) + h(x)
,搞清楚這個公式就好辦了,f(x)就是當前位置到下一個位置的總價值,g(x)表示實際價,這是說這一部分代價是確定的,h(x)表示估價值,就是說我
從下一個位置到到終點的代價是未知的,所以叫估價值,如圖中所示,黑色格子表示當前位置,綠色格子表示下一步可能到達的位置,即上、下、左、右這幾個方
向,紅色格子表示終點,褐色表示障礙物,現在要從黑色格子到達紅色格子,那麼黑色格子的下一步肯定是綠色格子當中的一個,黑色格子到綠色格子之間是相挨著
的,所以我們可以很明確的知道它的實際代價為1(移動一步的代價)即g(x),綠色格子到紅色格子之間隔著很長的距離,中間還有障礙物,所以這個代價是未
知的,即h(x),所以總的代價就為f(x) = g(x) +
h(x),我們看到周圍有4個綠色的格子,到底走那一步比較好呢,所以我們要把這4個格子的f(x)值都求出來,然後進行排序,選擇f(x)值最小的,即
總代價最少的那個格子,以此方法繼續下去,直到到達終點 或者 地圖上沒有綠色格子了

下面來看一下這個工具類,g(x)和h(x)要選的比較合適,一般就是採用的曼哈頓演算法,即兩點在x方向和y方向的距離之和,
-- Filename: PathUtil.lua
-- Author: bzx
-- Date: 2014-07-01
-- Purpose: 尋路

mole("PathUtil", package.seeall)

local _map_data -- 地圖數據
local _open_list -- 開放節點
local _open_map -- 開放節點,為了提高性能而加
local _close_map -- 關閉節點
local _deleget -- 代理
local _dest_point -- 目標點
local _start_point -- 起點
local _path -- 路徑

-- 尋找路徑
--[[
deleget = {
g = function(point1, point2)
-- add your code
-- 返回點point1到點point2的實際代價
end
h = function(point1, point2)
-- add your code
-- 返回點point1到點point2的估算代價
end
getValue = function(j, i)
-- 返回地圖中第i行,第j列的數據 1為障礙物,0為非障礙物
end
width -- 地圖寬度
height -- 地圖高度
}
--]]
function findPath(deleget, start_point, dest_point)
_deleget = deleget
_dest_point = dest_point
_start_point = start_point
init()
while not table.isEmpty(_open_list) do
local cur_point = _open_list[1]
table.remove(_open_list, 1)
_open_map[cur_point.key] = nil
if isEqual(cur_point, dest_point) then
return makePath(cur_point)
else
_close_map[cur_point.key] = cur_point
local next_points = getNextPoints(cur_point)
for i = 1, #next_points do
local next_point = next_points[i]
if _open_map[next_point.key] == nil and _close_map[next_point.key] == nil and isObstacle(next_point) == false then
_open_map[next_point.key] = next_point
table.insert(_open_list, next_point)
end
end
table.sort(_open_list, compareF)
end
end
return nil
end

function init()
_open_list = {}
_open_map = {}
_close_map = {}
_path = {}
_map_data = {}
for i = 1, _deleget.height do
_map_data[i] = {}
for j = 1, _deleget.width do
local value = _deleget.getValue(j, i)
_map_data[i][j] = value
end
end
_open_map[getKey(_start_point)] = _start_point
table.insert(_open_list, _start_point)
end

function createPoint(x, y)
local point = {
["x"] = x,
["y"] = y,
["last"] = nil,
["g_value"] = 0,
["h_value"] = 0,
["f_value"] = 0
}
point["key"] = getKey(point)
return point
end

-- 得到下一個可以移動的點
-- @param point 當前所在點
function getNextPoints(point)
local next_points = {}
for i = 1, #_deleget.directions do
local offset = _deleget.directions[i]
local next_point = createPoint(point.x + offset[1], point.y + offset[2])
next_point["last"] = point
if next_point.x >= 1 and next_point.x <= _deleget.width and next_point.y >= 1 and next_point.y <= _deleget.height then
next_point["g_value"] = _deleget.g(point, next_point)
next_point["h_value"] = _deleget.h(point, _dest_point)--math.abs(next_points.x - _dest_point.x) + math.abs(next_points.y - _dest_point.y)
next_point["f_value"] = next_point.g_value + next_point.h_value
table.insert(next_points, next_point)
end
end
return next_points
end

-- 得到路徑
-- @param end_point 目標點
function makePath(end_point)
_path = {}
local point = end_point
while point.last ~= nil do
table.insert(_path, createPoint(point.x, point.y))
point = point.last
end
local start_point = point
table.insert(_path, start_point)
return _path
end

-- 兩個點的代價比較器
function compareF(point1, point2)
return point1.f_value < point2.f_value
end

-- 是否是障礙物
function isObstacle(point)
local value = _map_data[point.y][point.x]
if value == 1 then
return true
end
return false
end

-- 兩個點是否是同一個點
function isEqual(point1, point2)
return point1.key == point2.key
end

-- 根據點得到點的key
function getKey(point)
local key = string.format("%d,%d", point.x, point.y)
return key
end

下面是工具類PathUtil的用法
local deleget = {}
deleget.g = function(point1, point2)
return math.abs(point1.x - point2.x) + math.abs(point1.y - point2.y)
end
deleget.h = deleget.g
deleget.getValue = function(j, i)
local index = FindTreasureUtil.getIndex(j, i)
local map_info = _map_info.map[index]
if map_info.display == 0 and map_info.eid ~= 1 then
return 0
end
return 1
end
deleget.directions = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}} -- 左,上,下,右
deleget.width = _cols
deleget.height = _rows

local dest_row, dest_col = FindTreasureUtil.getMapPosition(tag)
local dest_point = PathUtil.createPoint(dest_col, dest_row)
local start_row, start_col = FindTreasureUtil.getMapPosition(_player_index)
local start_point = PathUtil.createPoint(start_col, start_row)
_path = PathUtil.findPath(deleget, start_point, dest_point)

_path就是我們找到的路徑,起點為最後一個元素,終點為第一個元素

F. 矩陣a*演算法是什麼

矩陣A*表示A矩陣的伴隨矩陣。

伴隨矩陣的定義:某矩陣A各元素的代數餘子式,組成一個新的矩陣後再進行一下轉置,叫做A的伴隨矩陣。

某元素代數餘子式就是去掉矩陣中某元素所在行和列元素後的形成矩陣的行列式,再乘上-1的(行數+列數)次方。

伴隨矩陣的求發:當矩陣是大於等於二階時:

主對角元素是將原矩陣該元素所在行列去掉再求行列式。

非主對角元素是原矩陣該元素的共軛位置的元素去掉所在行列求行列式乘以(-1)^(x+y) x,y為該元素的共軛位置的元素的行和列的序號,序號從1開始的。

主對角元素實際上是非主對角元素的特殊情況,因為x=y,所以(-1)^(x+y)=(-1)^(2x)=1,一直是正數,沒必要考慮主對角元素的符號問題。

G. 百度地圖的路徑搜索演算法

這個還是要問程序猿,現在比較流行A*演算法,至於網路是否開發出了新的演算法不得而知,畢竟沒有完全相同的程序。
給你看一篇文獻:
地圖中最短路徑的搜索演算法研究
學生:李小坤 導師:董巒
摘要:目前為止, 國內外大量專家學者對「最短路徑問題」進行了深入的研究。本文通過理論分析, 結合實際應用,從各個方面較系統的比較廣度優先搜索演算法(BFS)、深度優先搜索演算法(DFS)、A* 演算法的優缺點。
關鍵詞:最短路徑演算法;廣度優先演算法;深度優先演算法;A*演算法;
The shortest path of map's search algorithm
Abstract:So far, a large number of domestic and foreign experts and scholars on the" shortest path problem" in-depth study. In this paper, through theoretical analysis and practical application, comprise with the breadth-first search algorithm ( BFS ), depth-first search algorithm ( DFS ) and the A * algorithms from any aspects of systematic.
Key words: shortest path algorithm; breadth-first algorithm; algorithm; A * algorithm;
前言:
最短路徑問題是地理信息系統(GIS)網路分析的重要內容之一,而且在圖論中也有著重要的意義。實際生活中許多問題都與「最短路徑問題」有關, 比如: 網路路由選擇, 集成電路設計、布線問題、電子導航、交通旅遊等。本文應用深度優先演算法,廣度優先演算法和A*演算法,對一具體問題進行討論和分析,比較三種算的的優缺點。

在地圖中最短路徑的搜索演算法研究中,每種演算法的優劣的比較原則主要遵循以下三點:[1]
(1)演算法的完全性:提出一個問題,該問題存在答案,該演算法能夠保證找到相應的答案。演算法的完全性強是演算法性能優秀的指標之一。
(2)演算法的時間復雜性: 提出一個問題,該演算法需要多長時間可以找到相應的答案。演算法速度的快慢是演算法優劣的重要體現。
(3)演算法的空間復雜性:演算法在執行搜索問題答案的同時,需要多少存儲空間。演算法佔用資源越少,演算法的性能越好。
地圖中最短路徑的搜索演算法:
1、廣度優先演算法
廣度優先演算法(Breadth-First-Search),又稱作寬度優先搜索,或橫向優先搜索,是最簡便的圖的搜索演算法之一,這一演算法也是很多重要的圖的演算法的原型,Dijkstra單源最短路徑演算法和Prim最小生成樹演算法都採用了和寬度優先搜索類似的思想。廣度優先演算法其別名又叫BFS,屬於一種盲目搜尋法,目的是系統地展開並檢查圖中的所有節點,以找尋結果。換句話說,它並不考慮結果的可能位址,徹底地搜索整張圖,直到找到結果為止。BFS並不使用經驗法則演算法。
廣度優先搜索演算法偽代碼如下:[2-3]
BFS(v)//廣度優先搜索G,從頂點v開始執行
//所有已搜索的頂點i都標記為Visited(i)=1.
//Visited的初始分量值全為0
Visited(v)=1;
Q=[];//將Q初始化為只含有一個元素v的隊列
while Q not null do
u=DelHead(Q);
for 鄰接於u的所有頂點w do
if Visited(w)=0 then
AddQ(w,Q); //將w放於隊列Q之尾
Visited(w)=1;
endif
endfor
endwhile
end BFS
這里調用了兩個函數:AddQ(w,Q)是將w放於隊列Q之尾;DelHead(Q)是從隊列Q取第一個頂點,並將其從Q中刪除。重復DelHead(Q)過程,直到隊列Q空為止。
完全性:廣度優先搜索演算法具有完全性。這意指無論圖形的種類如何,只要目標存在,則BFS一定會找到。然而,若目標不存在,且圖為無限大,則BFS將不收斂(不會結束)。
時間復雜度:最差情形下,BFS必須尋找所有到可能節點的所有路徑,因此其時間復雜度為,其中|V|是節點的數目,而 |E| 是圖中邊的數目。
空間復雜度:因為所有節點都必須被儲存,因此BFS的空間復雜度為,其中|V|是節點的數目,而|E|是圖中邊的數目。另一種說法稱BFS的空間復雜度為O(B),其中B是最大分支系數,而M是樹的最長路徑長度。由於對空間的大量需求,因此BFS並不適合解非常大的問題。[4-5]
2、深度優先演算法
深度優先搜索演算法(Depth First Search)英文縮寫為DFS,屬於一種回溯演算法,正如演算法名稱那樣,深度優先搜索所遵循的搜索策略是盡可能「深」地搜索圖。[6]其過程簡要來說是沿著頂點的鄰點一直搜索下去,直到當前被搜索的頂點不再有未被訪問的鄰點為止,此時,從當前輩搜索的頂點原路返回到在它之前被搜索的訪問的頂點,並以此頂點作為當前被搜索頂點。繼續這樣的過程,直至不能執行為止。
深度優先搜索演算法的偽代碼如下:[7]
DFS(v) //訪問由v到達的所有頂點
Visited(v)=1;
for鄰接於v的每個頂點w do
if Visited(w)=0 then
DFS(w);
endif
endfor
end DFS
作為搜索演算法的一種,DFS對於尋找一個解的NP(包括NPC)問題作用很大。但是,搜索演算法畢竟是時間復雜度是O(n!)的階乘級演算法,它的效率比較低,在數據規模變大時,這種演算法就顯得力不從心了。[8]關於深度優先搜索的效率問題,有多種解決方法。最具有通用性的是剪枝,也就是去除沒有用的搜索分支。有可行性剪枝和最優性剪枝兩種。
BFS:對於解決最短或最少問題特別有效,而且尋找深度小,但缺點是內存耗費量大(需要開大量的數組單元用來存儲狀態)。
DFS:對於解決遍歷和求所有問題有效,對於問題搜索深度小的時候處理速度迅速,然而在深度很大的情況下效率不高。
3、A*演算法
1968年的一篇論文,「P. E. Hart, N. J. Nilsson, and B. Raphael. A formal basis for the heuristic determination of minimum cost paths in graphs. IEEE Trans. Syst. Sci. and Cybernetics, SSC-4(2):100-107, 1968」。[9]從此,一種精巧、高效的演算法——A*演算法問世了,並在相關領域得到了廣泛的應用。A* 演算法其實是在寬度優先搜索的基礎上引入了一個估價函數,每次並不是把所有可擴展的結點展開,而是利用估價函數對所有未展開的結點進行估價, 從而找出最應該被展開的結點,將其展開,直到找到目標節點為止。
A*演算法主要搜索過程偽代碼如下:[10]
創建兩個表,OPEN表保存所有已生成而未考察的節點,CLOSED表中記錄已訪問過的節點。
算起點的估價值;
將起點放入OPEN表;
while(OPEN!=NULL) //從OPEN表中取估價值f最小的節點n;
if(n節點==目標節點) break;
endif
for(當前節點n 的每個子節點X)
算X的估價值;
if(X in OPEN)
if(X的估價值小於OPEN表的估價值)
把n設置為X的父親;
更新OPEN表中的估價值; //取最小路徑的估價值;
endif
endif
if(X inCLOSE)
if( X的估價值小於CLOSE表的估價值)
把n設置為X的父親;
更新CLOSE表中的估價值;
把X節點放入OPEN //取最小路徑的估價值
endif
endif
if(X not inboth)
把n設置為X的父親;
求X的估價值;
並將X插入OPEN表中; //還沒有排序
endif
end for
將n節點插入CLOSE表中;
按照估價值將OPEN表中的節點排序; //實際上是比較OPEN表內節點f的大小,從最小路徑的節點向下進行。
end while(OPEN!=NULL)
保存路徑,即 從終點開始,每個節點沿著父節點移動直至起點,這就是你的路徑;
A *演算法分析:
DFS和BFS在展開子結點時均屬於盲目型搜索,也就是說,它不會選擇哪個結點在下一次搜索中更優而去跳轉到該結點進行下一步的搜索。在運氣不好的情形中,均需要試探完整個解集空間, 顯然,只能適用於問題規模不大的搜索問題中。而A*演算法與DFS和BFS這類盲目型搜索最大的不同,就在於當前搜索結點往下選擇下一步結點時,可以通過一個啟發函數來進行選擇,選擇代價最少的結點作為下一步搜索結點而跳轉其上。[11]A *演算法就是利用對問題的了解和對問題求解過程的了解, 尋求某種有利於問題求解的啟發信息, 從而利用這些啟發信息去搜索最優路徑.它不用遍歷整個地圖, 而是每一步搜索都根據啟發函數朝著某個方向搜索.當地圖很大很復雜時, 它的計算復雜度大大優於D ijks tr a演算法, 是一種搜索速度非常快、效率非常高的演算法.但是, 相應的A*演算法也有它的缺點.啟發性信息是人為加入的, 有很大的主觀性, 直接取決於操作者的經驗, 對於不同的情形要用不同的啟發信息和啟發函數, 且他們的選取難度比較大,很大程度上找不到最優路徑。
總結:
本文描述了最短路徑演算法的一些步驟,總結了每個演算法的一些優缺點,以及演算法之間的一些關系。對於BFS還是DFS,它們雖然好用,但由於時間和空間的局限性,以至於它們只能解決規模不大的問題,而最短或最少問題應該選用BFS,遍歷和求所有問題時候則應該選用DFS。至於A*演算法,它是一種啟發式搜索演算法,也是一種最好優先的演算法,它適合於小規模、大規模以及超大規模的問題,但啟發式搜索演算法具有很大的主觀性,它的優劣取決於編程者的經驗,以及選用的啟發式函數,所以用A*演算法編寫一個優秀的程序,難度相應是比較大的。每種演算法都有自己的優缺點,對於不同的問題選擇合理的演算法,才是最好的方法。
參考文獻:
[1]陳聖群,滕忠堅,洪親,陳清華.四種最短路徑演算法實例分析[J].電腦知識與技術(學術交流),2007(16):1030-1032
[2]劉樹林,尹玉妹.圖的最短路徑演算法及其在網路中的應用[J].軟體導刊,2011(07):51-53
[3]劉文海,徐榮聰.幾種最短路徑的演算法及比較[J].福建電腦,2008(02):9-12
[4]鄧春燕.兩種最短路徑演算法的比較[J].電腦知識與技術,2008(12):511-513
[5]王蘇男,宋偉,姜文生.最短路徑演算法的比較[J].系統工程與電子技術,1994(05):43-49
[6]徐鳳生,李天志.所有最短路徑的求解演算法[J].計算機工程與科學,2006(12):83-84
[7]李臣波,劉潤濤.一種基於Dijkstra的最短路徑演算法[J].哈爾濱理工大學學報,2008(03):35-37
[8]徐鳳生.求最短路徑的新演算法[J].計算機工程與科學,2006(02).
[9] YanchunShen . An improved Graph-based Depth-First algorithm and Dijkstra algorithm program of police patrol [J] . 2010 International Conference on Electrical Engineering and Automatic Control , 2010(3) : 73-77
[10]部亞松.VC++實現基於Dijkstra演算法的最短路徑[J].科技信息(科學教研),2008(18):36-37
[11] 楊長保,王開義,馬生忠.一種最短路徑分析優化演算法的實現[J]. 吉林大學學報(信息科學版),2002(02):70-74

熱點內容
x3000r存儲卡 發布:2025-03-19 00:12:22 瀏覽:220
ie不顯示腳本錯誤 發布:2025-03-19 00:09:53 瀏覽:957
免費網頁源碼 發布:2025-03-19 00:09:00 瀏覽:261
工業企業資料庫 發布:2025-03-18 23:51:44 瀏覽:94
寶馬車的配置主要看哪些 發布:2025-03-18 23:50:09 瀏覽:484
esxi虛擬存儲 發布:2025-03-18 23:49:59 瀏覽:771
mc自己開伺服器地址 發布:2025-03-18 23:47:10 瀏覽:701
藍凌關聯配置什麼意思 發布:2025-03-18 23:46:16 瀏覽:347
雲存儲vmware 發布:2025-03-18 23:41:51 瀏覽:890
怎麼從配置模式轉到用戶模式 發布:2025-03-18 23:36:07 瀏覽:334