数学建模模型4——Dijkstra和Floyd算法

Dijkstra和Floyd算法

二者均为计算最短路径算法
Dijkstra为贪心算法，不能够计算含有负权的图，每次选取路径值最小的顶点最为k
Floyd为动态规划，对k从1开始进行遍历

Dijkstra代码

function [min,path]=dijkstra(w,start,terminal)
n=size(w,1); label(start)=0; f(start)=start;
for i=1:n
   if i~=start
       label(i)=inf;
   end
end
s(1)=start; u=start;
while length(s)<n
   for i=1:n
      ins=0;
      for j=1:length(s)
         if i==s(j)
            ins=1;
         end
      end
      if ins==0
         v=i;
         if label(v)>(label(u)+w(u,v))
            label(v)=(label(u)+w(u,v)); 
         f(v)=u;
         end
      end
   end   
v1=0;
   k=inf;
   for i=1:n
       ins=0;
       for j=1:length(s)
           if i==s(j)
               ins=1;
           end
       end
       if ins==0
           v=i;
           if k>label(v)
               k=label(v);
               v1=v;
           end
       end
   end
   s(length(s)+1)=v1;
   u=v1;
end
min=label(terminal); 
path(1)=terminal;
i=1; 
while path(i)~=start
      path(i+1)=f(path(i));
      i=i+1 ;
end
path(i)=start;
L=length(path);
path=path(L:-1:1);

Floyd代码

function [D,path,min1,path1]=floyd(a,start,terminal)
D=a;n=size(D,1);path=zeros(n,n);
for i=1:n
   for j=1:n
      if D(i,j)~=inf
         path(i,j)=j;
      end
   end
end
for k=1:n
   for i=1:n
      for j=1:n
         if D(i,k)+D(k,j)<D(i,j)
            D(i,j)=D(i,k)+D(k,j);
            path(i,j)=path(i,k);
         end
      end 
   end
end
if nargin==3
   min1=D(start,terminal);
   m(1)=start;
   i=1;
   path1=[ ];   
   while   path(m(i),terminal)~=terminal
      k=i+1;                                
      m(k)=path(m(i),terminal);
      i=i+1;
   end
   m(i+1)=terminal;
   path1=m;
end   

来源：CSDN

作者：qq_43585318

链接：https://blog.csdn.net/qq_43585318/article/details/104114696