优先队列实现dijkstra算法C++代码 c++优先队列怎么实现
\u4f7f\u7528\u4f18\u5148\u961f\u5217\u4f18\u5316\u7684 dijkstra\u7b97\u6cd5\u7a0b\u5e8f\uff0c\u7528\u90bb\u63a5\u8868\u5b58\u50a8\u6709\u5411\u56fe\uff0cC#\u4ee3\u7801\u6700\u597d\uff0cC++\u4e5f\u53ef\u73b0\u5728\u786e\u5b9a\u7684\u4f18\u5316\u65b9\u6cd5\u5c31\u662f\u7528\u90bb\u63a5\u8868\u4ee3\u66ff\u77e9\u9635\u5b58\u50a8\u6709\u5411\u56fe\uff0c\u7528\u4f18\u5148\u961f\u5217\u4f18\u5316\u7b97\u6cd5\u8fd0\u884c\u8fc7\u7a0b\u3002
#include using namespace std; int t,n; priority_queue heap; int main(){ scanf("%d",&n); for (int i=1;i<=n;i++){ scanf("%d",&t);heap.push(t); }while (!heap.empty()){ printf("%d\n",heap.top()); heap.pop();} }
#include<fstream>#define MaxNum 765432100
using namespace std;
ifstream fin("Dijkstra.in");
ofstream fout("Dijkstra.out");
int Map[501][501];
bool is_arrived[501];
int Dist[501],From[501],Stack[501];
int p,q,k,Path,Source,Vertex,Temp,SetCard;
int FindMin()
{
int p,Temp=0,Minm=MaxNum;
for(p=1;p<=Vertex;p++)
if ((Dist[p]<Minm)&&(!is_arrived[p]))
{
Minm=Dist[p];
Temp=p;
}
return Temp;
}
int main()
{
memset(is_arrived,0,sizeof(is_arrived));
fin >> Source >> Vertex;
for(p=1;p<=Vertex;p++)
for(q=1;q<=Vertex;q++)
{
fin >> Map[p][q];
if (Map[p][q]==0) Map[p][q]=MaxNum;
}
for(p=1;p<=Vertex;p++)
{
Dist[p]=Map[Source][p];
if (Dist[p]!=MaxNum)
From[p]=Source;
else
From[p]=p;
}
is_arrived[Source]=true;
SetCard=1;
do
{
Temp=FindMin();
if (Temp!=0)
{
SetCard=SetCard+1;
is_arrived[Temp]=true;
for(p=1;p<=Vertex;p++)
if ((Dist[p]>Dist[Temp]+Map[Temp][p])&&(!is_arrived[p]))
{
Dist[p]=Dist[Temp]+Map[Temp][p];
From[p]=Temp;
}
}
else
break;
}
while (SetCard!=Vertex);
for(p=1;p<=Vertex;p++)
if(p!=Source)
{
fout << "========================\n";
fout << "Source:" << Source << "\nTarget:" << p << '\n';
if (Dist[p]==MaxNum)
{
fout << "Distance:" << "Infinity\n";
fout << "Path:No Way!";
}
else
{
fout << "Distance:" << Dist[p] << '\n';
k=1;
Path=p;
while (From[Path]!=Path)
{
Stack[k]=Path;
Path=From[Path];
k=k+1;
}
fout << "Path:" << Source;
for(q=k-1;q>=1;q--)
fout << "-->" << Stack[q];
}
fout << "\n========================\n\n";
}
fin.close();
fout.close();
return 0;
}
Sample Input
2
7
00 20 50 30 00 00 00
20 00 25 00 00 70 00
50 25 00 40 25 50 00
30 00 40 00 55 00 00
00 00 25 55 00 10 00
00 70 50 00 10 00 00
00 00 00 00 00 00 00
Sample Output
========================
Source:2
Target:1
Distance:20
Path:2-->1
========================
========================
Source:2
Target:3
Distance:25
Path:2-->3
========================
========================
Source:2
Target:4
Distance:50
Path:2-->1-->4
========================
========================
Source:2
Target:5
Distance:50
Path:2-->3-->5
========================
========================
Source:2
Target:6
Distance:60
Path:2-->3-->5-->6
========================
========================
Source:2
Target:7
Distance:Infinity
Path:No Way!
========================
示例程序及相关子程序：
void Dijkstra(int n,int[] Distance,int[] iPath)
{
int MinDis,u;
int i,j;
//从邻接矩阵复制第n个顶点可以走出的路线，就是复制第n行到Distance[]
for(i=0;i<VerNum;i++)
{
Distance=Arc[n,i];
Visited=0;
}//第n个顶点被访问，因为第n个顶点是开始点
Visited[n]=1;
//找到该顶点能到其他顶点的路线、并且不是开始的顶点n、以前也没走过。
//相当于寻找u点，这个点不是开始点n
for(i=0;i<VerNum;i++)
{
u=0;
MinDis=No;
for(j=0;j<VerNum;j++)
if(Visited[j] == 0&&(Distance[j]<MinDis))
{
MinDis=Distance[j];
u=j;
}
//如范例P1871图G6，Distance=[No,No,10,No,30,100]，第一次找就是V2，所以u=2
//找完了，MinDis等于不连接，则返回。这种情况类似V5。
if(MinDis==No) return ;
//确立第u个顶点将被使用，相当于Arc[v,u]+Arc[u,w]中的第u顶点。
Visited[u]=1;
//寻找第u个顶点到其他所有顶点的最小路，实际就是找Arc[u,j]、j取值在[0，VerNum]。
//如果有Arc[i,u]+Arc[u,j]<Arc[i,j]，则Arc[i,j]=Arc[i,u]+Arc[u,j]<Arc[i,j]
//实际中，因为Distance[]是要的结果，对于起始点确定的情况下，就是：
//如果(Distance[u] + Arc[u,j]) <= Distance[j] 则：
//Distance[j] = Distance[u] + Arc[u, j]；
//而iPath[]保存了u点的编号；
//同理：对新找出的路线，要设置Visited[j]=0，以后再找其他路，这个路可能别利用到。例如V3
for(j=0;j<VerNum;j++)
if(Visited[j]==0&&Arc[u,j]<No&&u!= j)
{
if ((Distance[u] + Arc[u,j]) <= Distance[j])
{
Distance[j] = Distance[u] + Arc[u, j];
Visited[j]=0;
iPath[j] = u;
}
}
}
}
//辅助函数
void Prim()
{
int i,m,n=0;
for(i=0;i<VerNum;i++)
{
Visited=0;
T=new TreeNode();
T.Text =V;
}
Visited[n]++;
listBox1.Items.Add (V[n]);
while(Visit()>0)
{
if((m=MinAdjNode(n))!=-1)
{
T[n].Nodes.Add(T[m]);
n=m;
Visited[n]++;
}
else
{
n=MinNode(0);
if(n>0) T[Min2].Nodes.Add(T[Min1]);
Visited[n]++;
}
listBox1.Items.Add (V[n]);
}
treeView1.Nodes.Add(T[0]);
}
void TopoSort()
{
int i,n;
listBox1.Items.Clear();
Stack S=new Stack();
for(i=0;i<VerNum;i++)
Visited=0;
for(i=VerNum-1;i>=0;i--)
if(InDegree(i)==0)
{
S.Push(i);
Visited++;
}
while(S.Count!=0)
{
n=(int )S.Pop();
listBox1.Items.Add (V[n]);
ClearLink(n);
for(i=VerNum-1;i>=0;i--)
if(Visited==0&&InDegree(i)==0)
{
S.Push(i);
Visited++;
}
}
}
void AOETrave(int n,TreeNode TR,int w)
{
int i,w0;
if(OutDegree(n)==0) return;
for(i=0;i<VerNum;i++)
if((w0=Arc[n,i])!=0)
{
listBox1.Items.Add (V+"\t"+(w+w0).ToString()+"\t"+i.ToString()+"\t"+n.ToString());
TreeNode T1=new TreeNode();
T1.Text =V+" [W="+(w+w0).ToString()+"]";
TR.Nodes.Add(T1);
AOETrave(i,T1,w+w0);
}
}
void AOE()
{
int i,w=0,m=1;
TreeNode T1=new TreeNode();
for(i=0;i<VerNum;i++)
{
Visited=0;
}
T1.Text =V[0];
listBox1.Items.Add ("双亲表示法显示这个生成树：");
listBox1.Items.Add ("V\tW\tID\tPID");
for(i=0;i<VerNum;i++)
{
if((w=Arc[0,i])!=0)
{
listBox1.Items.Add (V+"\t"+w.ToString()+"\t"+i.ToString()+"\t0");
TreeNode T2=new TreeNode();
T2.Text=V+" [W="+w.ToString()+"]";
AOETrave(i,T2,w);
T1.Nodes.Add (T2);
listBox1.Items.Add("\t\t树"+m.ToString());
m++;
}
}
treeView1.Nodes.Clear();
treeView1.Nodes.Add (T1);
}
int IsZero()
{
int i;
for(i=0;i<VerNum;i++)
if(LineIsZero(i)>=0) return i;
return -1;
}
int LineIsZero(int n)
{
int i;
for(i=0;i<VerNum;i++)
if (Arc[n,i]!=0) return i;
return -1;
}
void DepthTraverse()
{
int i,m;
for(i=0;i<VerNum;i++)
{
Visited=0;
T=new TreeNode();
T.Text =V;
R=0;
}
while((m=IsZero())>=0)
{
if(Visited[m]==0)
{
listBox1.Items.Add (V[m]);
R[m]=1;
}
Visited[m]++;
DTrave(m);
}
for(i=0;i<VerNum;i++)
{
if(R==1)
treeView1.Nodes.Add (T);
}
}
void DTrave(int n)
{
int i;
if (LineIsZero(n)<0) return;
for(i=VerNum-1;i>=0;i--)
if(Arc[n,i]!=0)
{
Arc[n,i]=0;
Arc[i,n]=0;
if(Visited==0)
{
listBox1.Items.Add (V);
T[n].Nodes.Add (T);
R=0;
}
Visited++;
DTrave(i);
}
}
void BreadthTraverse()
{
int i,m;
for(i=0;i<VerNum;i++)
{
Visited=0;
T=new TreeNode();
T.Text =V;
R=0;
}
while((m=IsZero())>=0)
{
if(Visited[m]==0)
{
listBox1.Items.Add (V[m]);
R[m]=1;
}
Visited[m]++;
BTrave(m);
}
for(i=0;i<VerNum;i++)
{
if(R==1)
treeView1.Nodes.Add (T);
}
}
void BTrave(int n)
{
int i;
Queue Q=new Queue();
Q.Enqueue(n);
while(Q.Count!=0)
{
for(i=0;i<VerNum;i++)
{
if(Arc[n,i]!=0)
{
Arc[n,i]=0;
Arc[i,n]=0;
if(Visited==0)
{
listBox1.Items.Add(V);
T[n].Nodes.Add (T);
R=0;
}
Visited++;
Q.Enqueue(i);
}
}
n=(int )Q.Dequeue();
}
}
int MinNode(int vn)
{
int i,j,n,m,Min=No;
n=-1;m=-1;
for (i=vn;i<VerNum;i++)
for(j=0;j<VerNum;j++)
if(Arc[i,j]!=No&&Arc[i,j]<Min&&Visited==0&&Visited[j]==1)
{
Min=Arc[i,j];n=i;m=j;
}
Min1=n;Min2=m;
return n;
}
int MinAdjNode(int n)
{
int i,Min,m;
Min=No;m=-1;
for(i=0;i<VerNum;i++)
if(Arc[n,i]!=No&&Visited==0&&Min>Arc[n,i]&&Visited[n]==1)
{
Min=Arc[n,i];m=i;
}
return m;
}
int Visit()
{
int i,s=0;
for(i=0;i<VerNum;i++)
if(Visited==0) s++;
return s;
}
[编辑本段]dijkstra算法的Pascal实现：
program dijkstra;
var
a:array[1..100,1..100]of integer;
flag:array[1..100]of boolean;
w,x,n,i,j,min,minn:integer;
begin
readln(n);
for i:=1 to n do
begin
for j:=1 to n do read(a[i,j]);
readln;
end;
fillchar(flag,sizeof(flag),false);
flag[1]:=true;
minn:=1;
for x:=2 to n do
begin
min:=32767;
for i:=2 to n do
if (a[1,i]<min)and(flag=false) then
begin
min:=a[1,i];
minn:=i;
end;
flag[minn]:=true;
for j:=1 to n do
if (j<>minn) and (a[1,minn]+a[minn,j]<a[1,j]) and(flag[j]=false) then
a[1,j]:=a[1,minn]+a[minn,j];
end;
for i:=1 to n do
write(a[1,i],' ');
end.
4
0 100 30 999
100 0 99 10
30 99 0 99
999 10 99 0
程序输出：0 100 30 110
dijkstra算法的MATLAB实现：
clear;
clc;
M=10000;
a(1,:)=[0,50,M,40,25,10];
a(2,:)=[zeros(1,2),15,20,M,25];
a(3,:)=[zeros(1,3),10,20,M];
a(4,:)=[zeros(1,4),10,25];
a(5,:)=[zeros(1,5),55];
a(6,:)=zeros(1,6);
a=a+a';
pb(1:length(a))=0;pb(i)=1;index1=1;index2=ones(1,length(a));
d(1:length(a))=M;d(i)=0;temp=1;
while sum(pb)<length(a)
tb=find(pb==0);
d(tb)=min(d(tb),d(temp)+a(temp,tb));
tmpb=find(d(tb)==min(d(tb)));
temp=tb(tmpb(i));
pb(temp)=1;
index1=[index1,temp];
index=index1(find(d(index1)==d(temp)-a(temp,index1)));
if length(index)>=2
index=index(1);
end
index2(temp)=index;
end
d, index1, index2
matlab编程
function [s,d]=minroute(i,m,w,opt)
% 图与网络论中求最短路径的dijkstra算法M函数
% 格式[s,d]=minroute(i,m,w,opt)
if nargin<4,opt=0;end
dd=[];tt=[];ss=[];ss(1,1)=i;v=1:m;v(i)=[];
dd=[0;i];kk=2;[mdd,ndd]=size(dd);
while~isempty(v)
[tmpd,j]=min(w(i,v));tmpj=v(j);
for k=2:ndd
[tmp2,jj]=min(dd(1,k)+w(dd(2,k),v));
tmp2=v(jj);tt(k-1,:)=[tmp1,tmp2,jj];
end;
tmp=[tmpd,tmpj,j;tt];[tmp3,tmp4]=min(tmp(;,1));
if tmp3==tmpd
ss(1:2,kk)=[i;tmp(tmp4,2)];
else,tmp5=find(ss(:,tmp4)~=0);tmp6=length(tmp5);
if dd(2,tmp4)=ss(tmp6,tmp4)
ss(1:tmp6+1,kk)=[ss(tmp5,tmp4);tmp(tmp4,2)];
else,ss(1:3,kk)=[i;dd(2,tmp4);tmp(tmp4,2)];
end;end
dd=[dd,[tmp3,tmp(tmp4,2)]];v(tmp(tmp4,3))=[];
[mdd,ndd]=size(dd);kk=kk+1;
end;
if opt==1
[tmp,t]=sort(dd(2,:));s=ss(:t);d=dd(1,t);
else,s=ss;d=dd(1,:);
end
模板是HDOJ 2544
我写的是记录每个点在堆中的位置IncreaseKey，也可以Relax后直接往里插，用个bool数组记录一下
#include<cstdio>
#include<cstdlib>
int n,m;
int map[101][101],d[101];
class Heap
{
public:
int handle[101];
void Build(int n)
{
for(int i=1;i<=n;i++) a[i]=handle[i]=i;
size=n;
}
void Percup(int p)
{
int temp=a[p];
for(;d[temp]<d[a[p>>1]];p>>=1)
{
a[p]=a[p>>1];
handle[a[p]]=p;
}
a[p]=temp;
handle[a[p]]=p;
}
int DeleteMin()
{
int val=a[1];
a[1]=a[size--];
Percdown(1);
handle[val]=0;
return val;
}
bool Empty() {return size==0;}
private:
int a[101],size;
void Percdown(int p)
{
int temp=a[p],child;
for(;(p<<1)<=size;p=child)
{
child=p<<1;
if(child+1<=size && d[a[child+1]]<d[a[child]]) child++;
if(d[temp]<d[a[child]]) break;
a[p]=a[child];
handle[a[p]]=p;
}
a[p]=temp;
handle[a[p]]=p;
}
}h;
void init()
{
int i,j,c;
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++) map[i][j]=0x7fffffff;
d[i]=0x7fffffff;
}
d[1]=0;
while(m--)
{
scanf("%d%d%d",&i,&j,&c);
map[i][j]=map[j][i]=c;
}
}
void Relax(int num)
{
for(int i=1;i<=n;i++)
if(h.handle[i] && map[num][i]!=0x7fffffff && d[i]>d[num]+map[num][i])
{
d[i]=d[num]+map[num][i];
h.Percup(h.handle[i]);
}
}
void dijk()
{
h.Build(n);
while(!h.Empty()) Relax(h.DeleteMin());
}
int main()
{
while(scanf("%d%d",&n,&m) && n+m)
{
init();
dijk();
printf("%d\n",d[n]);
}
system("pause");
return 0;
}
#include<algorithm>
using namespace std;
#define MAXN 100
#define HEAP_SIZE 100
typedef int Graph[MAXN][MAXN];
//对于Heap中的每个元素，都对应一个<data,cost>
//表示这个元素的标号和实际的值，由于堆Heapify之后
//data的位置会移动，因此index[s]表示data值为s的元素实际所处的位置
template <class COST_TYPE>
class Heap
{
public:
int data[HEAP_SIZE],index[HEAP_SIZE],size;
COST_TYPE cost[HEAP_SIZE];
void shift_up(int i)
{
int j;
while(i>0)
{
j=(i-1)/2;
if(cost[data[i]]<cost[data[j]])
{
swap(index[data[i]],index[data[j]]);
swap(data[i],data[j]);
i=j;
}
else break;
}
}
void shift_down(int i)
{
int j,k;
while(2*i+1<size)
{
j=2*i+1;
k=j+1;
if(k<size&&cost[data[k]]<cost[data[j]]&&cost[data[k]]<cost[data[i]])
{
swap(index[data[k]],index[data[i]]);
swap(data[k],data[i]);
i=k;
}
else if(cost[data[j]]<cost[data[i]])
{
swap(index[data[j]],index[data[i]]);
swap(data[j],data[i]);
i=j;
}
else break;
}
}
void init()
{
size=0;
memset(index,-1,sizeof(index));
memset(cost,-1,sizeof(cost));
}
bool empty()
{
return(size==0);
}
int pop()
{
int res=data[0];
data[0]=data[size-1];
index[data[0]]=0;
size--;
shift_down(0);
return res;
}
int top()
{
return data[0];
}
void push(int x,COST_TYPE c)
{
if(index[x]==-1)
{
cost[x]=c;
data[size]=x;
index[x]=size;
size++;
shift_up(index[x]);
}
else
{
if(c<cost[x])
{
cost[x]=c;
shift_up(index[x]);
shift_down(index[x]);
}
}
}
};
//下面是利用该优先队列实现dijkstra算法的一个例子
int Dijkstra(Graph G,int n,int s,int t)
{
Heap<int> heap;
heap.init();
heap.push(s,0);
while(!heap.empty())
{
int u=heap.pop();
if(u==t)
return heap.cost[t];
for(int i=0;i<n;i++)
if(G[u][i]>=0)
heap.push(i,heap.cost[u]+G[u][i]);
}
return -1;
}
那你直接照着源码写不就OK了?
--------------------------------------------------
template<class _Ty,
class _Container = vector<_Ty>,
class _Pr = less<typename _Container::value_type> >
class priority_queue
{ // priority queue implemented with a _Container
public:
typedef _Container container_type;
typedef typename _Container::value_type value_type;
typedef typename _Container::size_type size_type;
typedef typename _Container::reference reference;
typedef typename _Container::const_reference const_reference;
priority_queue()
: c(), comp()
{ // construct with empty container, default comparator
}
explicit priority_queue(const _Pr& _Pred)
: c(), comp(_Pred)
{ // construct with empty container, specified comparator
}
priority_queue(const _Pr& _Pred, const _Container& _Cont)
: c(_Cont), comp(_Pred)
{ // construct by copying specified container, comparator
make_heap(c.begin(), c.end(), comp);
}
template<class _Iter>
priority_queue(_Iter _First, _Iter _Last)
: c(_First, _Last), comp()
{ // construct by copying [_First, _Last), default comparator
make_heap(c.begin(), c.end(), comp);
}
template<class _Iter>
priority_queue(_Iter _First, _Iter _Last, const _Pr& _Pred)
: c(_First, _Last), comp(_Pred)
{ // construct by copying [_First, _Last), specified comparator
make_heap(c.begin(), c.end(), comp);
}
template<class _Iter>
priority_queue(_Iter _First, _Iter _Last, const _Pr& _Pred,
const _Container& _Cont)
: c(_Cont), comp(_Pred)
{ // construct by copying [_First, _Last), container, and comparator
c.insert(c.end(), _First, _Last);
make_heap(c.begin(), c.end(), comp);
}
bool empty() const
{ // test if queue is empty
return (c.empty());
}
size_type size() const
{ // return length of queue
return (c.size());
}
const_reference top() const
{ // return highest-priority element
return (c.front());
}
reference top()
{ // return mutable highest-priority element (retained)
return (c.front());
}
void push(const value_type& _Pred)
{ // insert value in priority order
c.push_back(_Pred);
push_heap(c.begin(), c.end(), comp);
}
void pop()
{ // erase highest-priority element
pop_heap(c.begin(), c.end(), comp);
c.pop_back();
}
protected:
_Container c; // the underlying container
_Pr comp; // the comparator functor
};
为什么要优先队列呢？你是用来做什么的？直接一个数组，然后找最大或最小的数或char，实现时间复杂度0（n^2)不行？ 楼主的问题问的非常好，我也想看看比n^2还小的dijkstra算法哈，我只知道dijkstra算法，最好数组n^2，最差最小最大堆n^2logn，有高手做出来了，我也很想瞧瞧哈
补充一点，如果是稀疏矩阵，用最大最小堆做，虽然是n^2logn，但n相对就变小了，同样减少了时间复杂度，
绛旓細瀵逛簬杈规暟灏戜簬n2绋鐤忓浘鏉ヨ锛屾垜浠彲浠ョ敤閭绘帴琛ㄦ潵鏇存湁鏁堢殑瀹炵幇Dijkstra绠楁硶銆傚悓鏃堕渶瑕佸皢涓涓簩鍙夊爢鎴栬呮枑娉㈢撼濂戝爢鐢ㄤ綔浼樺厛闃熷垪鏉ュ鎵炬渶灏忕殑椤剁偣(Extract-Min)銆傚綋鐢ㄥ埌浜屽弶鍫嗙殑鏃跺欙紝绠楁硶鎵闇鐨勬椂闂翠负O((m+n)logn)锛屾枑娉㈢撼濂戝爢鑳界◢寰彁楂樹竴浜涙ц兘锛岃绠楁硶杩愯鏃堕棿杈惧埌O(m+nlogn)銆備簩銆佺浉鍏崇畻娉 鍦―ijkstra...
绛旓細Dijkstra閫氳繃浼樺厛闃熷垪锛堝灏忔牴鍫嗘垨鏂愭尝閭ｅ鍫嗭級鐨勫阀濡欒繍鐢紝灏嗘椂闂村鏉傚害闄嶄綆鍒癘((E+n)lgn)锛屽湪绋鐤忓浘涓〃鐜板嚭鑹层傚叾鏍稿績鎿嶄綔锛屽鎻掑叆鍜岃幏鍙栨渶灏忓硷紝浣撶幇浜嗗爢鐨勯珮鏁堟с傜劧鍚庯紝鎴戜滑闈㈠鐨勬槸Bellman-Ford鍜孲PFA杩欏闅惧厔闅惧紵銆侭ellman-Ford浠ュ叾鏃犵晱鐨勫媷姘旓紝...
绛旓細dijx鏄竴绉嶇畻娉曠殑缂╁啓锛屽叏绉颁负Dijkstra绠楁硶銆侱ijkstra绠楁硶鏄竴绉嶈В鍐冲崟婧愭渶鐭矾寰勯棶棰樼殑绠楁硶锛岄噰鐢ㄧ殑鏄竴绉嶈椽蹇冪殑绛栫暐锛屽悓鏃跺紩鍏ヤ簡涓绉浼樺厛闃熷垪鏉ュ瓨鍌ㄥ拰璁块棶姣忎釜椤剁偣鐨勮窛绂汇傝绠楁硶鏈鍒濈敱鑽峰叞璁＄畻鏈虹瀛﹀Edsger W. Dijkstra浜1956骞存彁鍑恒俤ijx 鍦ㄥ摢浜涘満鏅腑寰楀埌搴旂敤锛烡ijkstra绠楁硶甯哥敤浜庤绠椾竴涓妭鐐瑰埌鍏朵粬...
绛旓細Dijkstra绠楁硶鏄嵎鍏拌绠楁満绉戝瀹禘dsger W. Dijkstra浜1956骞存彁鍑虹殑锛屾槸涓绉嶈В鍐冲崟婧愭渶鐭矾寰勯棶棰樼殑璐績绠楁硶銆傚畠閫氳繃浼樺厛闃熷垪鏉ュ瓨鍌ㄥ拰璁块棶姣忎釜椤剁偣鐨勮窛绂伙紝浠庤屽揩閫熸壘鍒版渶鐭矾寰勩傝绠楁硶骞挎硾搴旂敤浜庡湴鍥惧簲鐢ㄣ佷氦閫氳矾绾胯绠椼佸浘褰㈡枃浠惰矾寰勬煡鎵惧拰缃戠粶璺敱绠楁硶绛夐鍩熴傚湪瀹為檯搴旂敤涓紝Dijkstra绠楁硶鍙互閫氳繃鍫嗕紭鍖栨垨闃熷垪...
绛旓細//涓嬮潰鏄埄鐢ㄨ浼樺厛闃熷垪瀹炵幇dijkstra绠楁硶鐨勪竴涓緥瀛恑nt Dijkstra(Graph G,int n,int s,int t){ Heap<int> heap; heap.init(); heap.push(s,0); while(!heap.empty()) { int u=heap.pop(); if(u==t) return heap.cost[t]; for(int i=0;i<n;i++) if(G[u][i]>=0) heap.push(i,...
绛旓細PriorityQueue + Dijkstra绠楁硶姹傚崟婧愭渶鐭矾寰 棣栨帹姝ゆ柟娉 铏界劧浼樺厛绾闃熷垪浼樺寲姣斿爢浼樺寲鎬ц兘宸竴鐐癸紝宸窛寰堝皬銆備絾鏄紭鍏堢骇闃熷垪鍙互鐩存帴浣跨敤java绫诲簱涓殑PriorityQueue鏉瀹炵幇锛岃屽爢浼樺寲瀹炵幇闈炲父澶嶆潅銆俛uthor DuXiangYu / public class DijKstra_link_Queue { static int nodeCount;static int edgeCount;// 閭绘帴...
绛旓細瀵逛簬杈规暟灏戜簬n2绋鐤忓浘鏉ヨ锛屾垜浠彲浠ョ敤閭绘帴琛ㄦ潵鏇存湁鏁堢殑瀹炵幇Dijkstra绠楁硶銆傚悓鏃堕渶瑕佸皢涓涓簩鍙夊爢鎴栬呮枑娉㈢撼濂戝爢鐢ㄤ綔浼樺厛闃熷垪鏉ュ鎵炬渶灏忕殑椤剁偣(Extract-Min)銆傚綋鐢ㄥ埌浜屽弶鍫嗙殑鏃跺欙紝绠楁硶鎵闇鐨勬椂闂翠负O((m+n)log n)锛屾枑娉㈢撼濂戝爢鑳界◢寰彁楂樹竴浜涙ц兘锛岃绠楁硶杩愯鏃堕棿杈惧埌O(m + n log n)銆傜浉鍏抽棶棰樺拰绠楁硶...
绛旓細姣斿锛宎dd_vertex鏂规硶鐢ㄤ簬鐢熸垚鏂伴《鐐瑰苟瀛樺叆瀛楀吀锛宎dd_edge鍒欓氳繃閫掑綊璋冪敤椤剁偣鐨刟dd_neighbor鏂规硶澶勭悊杈圭殑杩炴帴銆傝礉灏旀浖-绂忕壒鐨勫吀鍨嬫祦绋嬫槸杩欐牱鐨勶細棣栧厛锛屽皢璧峰鐐规潈閲嶈涓0骞舵斁鍏闃熷垪銆傛帴鐫锛岃繘琛屽箍搴浼樺厛鎼滅储锛屾洿鏂扮浉閭婚《鐐圭殑鏉冮噸銆傜劧鍚庯紝妫鏌ユ槸鍚﹁繕鏈夋洿鏂帮紝濡傛湁锛岄噸澶嶆洿鏂拌繃绋嬨傛瘡娆℃洿鏂板悗锛屽皢鏈闂殑鐩搁偦椤剁偣...
绛旓細Dijkstra锛氭眰鍗曟簮銆佹棤璐熸潈鐨勬渶鐭矾銆傛椂鏁堟ц緝濂斤紝鏃堕棿澶嶆潅搴︿负O锛圴*V+E锛夈傛簮鐐瑰彲杈剧殑璇濓紝O锛圴*lgV+E*lgV锛=>O锛圗*lgV锛夈傚綋鏄█鐤忓浘鐨勬儏鍐垫椂锛屾鏃禘=V*V/lgV锛屾墍浠ョ畻娉曠殑鏃堕棿澶嶆潅搴﹀彲涓篛锛圴^2锛夈傝嫢鏄枑娉㈤偅濂戝爢浣浼樺厛闃熷垪鐨勮瘽锛岀畻娉曟椂闂村鏉傚害锛屽垯涓篛锛圴*lgV + E锛夈備互涓婂唴瀹...
绛旓細A*绠楁硶锛欰*绠楁硶鏄竴绉嶅惎鍙戝紡鎼滅储绠楁硶锛岀敤浜庡湪鍏锋湁鍚彂寮忓嚱鏁扮殑鍥句腑瀵绘壘鍗曟簮鏈鐭矾寰勩傝绠楁硶缁撳悎浜嗚矾寰勬垚鏈拰鍚彂寮忎及璁★紝閫氳繃浼樺厛闃熷垪閫夋嫨鏈鏈夊笇鏈涜揪鍒扮洰鏍囩殑鑺傜偣锛屼互鎻愰珮鎼滅储鏁堢巼銆傛渶鐭矾寰勭畻娉曠殑搴旂敤棰嗗煙鍖呮嫭锛1. 瀵艰埅绯荤粺锛氬湪瀵艰埅绯荤粺涓紝鏈鐭矾寰勭畻娉曞府鍔╃敤鎴锋壘鍒颁粠璧风偣鍒扮洰鏍囩殑鏈鐭矾寰勶紝搴旂敤浜庨┚杞...
