Prim算法和Dijkstra算法（个人感觉有一点相同）

最新推荐文章于 2025-04-15 17:03:20 发布

转载最新推荐文章于 2025-04-15 17:03:20 发布 · 1k 阅读

Dijkstra算法同时被 3 个专栏收录

10 篇文章

订阅专栏

kruskal

10 篇文章

订阅专栏

最小生成树

9 篇文章

订阅专栏

本文详细对比了Prim算法和Dijkstra算法的主要区别，Prim算法用于寻找最小生成树，而Dijkstra算法用于寻找最短路径。文章通过代码示例解释了两种算法的实现过程和关键步骤，包括初始化、迭代计算和更新操作。

https://www.cnblogs.com/CheeseZH/archive/2012/10/09/2717106.html

之前一直觉得Prim和Dijkstra很相似，但是没有仔细对比；

今天看了下，主要有以下几点：

1：

Prim是计算最小生成树的算法，比如为N个村庄修路，怎么修花销最少。

Dijkstra是计算最短路径的算法，比如从a村庄走到其他任意村庄的距离。

2：

Prim算法中有一个统计总len的变量，每次都要把到下一点的距离加到len中；

Dijkstra算法中却没有，只需要把到下一点的距离加到cls数组中即可；

3：

Prim算法的更新操作更新的cls是已访问集合到未访问集合中各点的距离；

23              for (j=0;j<n;j++)
24              {
25                  if (!visited[j] && map[j][nid]<adjset[j])//更新条件：j点未访问，加入新点后已访问集合到j的距离变小了
26                  {
27                      adjset[j] = map[j][nid];
28                  }
29              }

Dijkstra算法的更新操作更新的cls是源点到未访问集合中各点的距离，已经访问过的相当于已经找到源点到它的最短距离了；

20 for (j=1;j<=n;j++)
21 {

22             if(!vis[j]&&map[nxt][j]<MAX&&(min+map[nxt][j])<cls[j])//更新条件：j点未访问，新点与j点之间有路，
23                 cls[j]=cls[nxt]+map[nxt][j];
24         }

Prim算法

复制代码

 1          //初始化
 2          memset(visited,0,sizeof(visited));
 3          visited[0] = 1;
 4          len = 0;
 5          for (i=0;i<n;i++)    adjset[i] = map[i][0];
 6          //Begin
 7          for (i=1;i<n;i++)
 8          {
 9              //找到下一条符合条件的点
10              nlen = MAX;
11              for (j=0;j<n;j++)
12              {
13                  if (!visited[j] && adjset[j]<nlen)
14                  {
15                      nlen = adjset[j];
16                      nid = j;
17                  }
18              }
19              //访问找到的那个点
20              len += nlen;
21              visited[nid] = 1;
22              //更新邻接距离
23              for (j=0;j<n;j++)
24              {
25                  if (!visited[j] && map[j][nid]<adjset[j])
26                  {
27                      adjset[j] = map[j][nid];
28                  }
29              }

复制代码

Dijkstra算法

复制代码

 1 void Dijkstra(int v)
 2 {
 3     int i,j,min,nxt;
 4     for(i=1;i<=n;i++)    cls[i]=map[v][i];
 5     memset(vis,0,sizeof(vis));
 6     vis[v]=1;
 7     for (i=1;i<n;i++)
 8     {
 9         min=MAX;
10         nxt=v;
11         for (j=1;j<=n;j++)
12         {
13             if(!vis[j]&&cls[j]<min)
14             {
15                 nxt=j;
16                 min=cls[j];
17             }
18         }
19         vis[nxt]=1;
20         for (j=1;j<=n;j++)
21         {
22             if(!vis[j]&&map[nxt][j]<MAX&&(min+map[nxt][j])<cls[j])
23                 cls[j]=cls[nxt]+map[nxt][j];
24         }
25     }
26 }

http://lx.lanqiao.cn/problem.page?gpid=T32

转自 https://www.cnblogs.com/chensunrise/p/4367270.html

#include <bits/stdc++.h>

#define inf 0x3f3f3f3f
#define PI acos(-1.0)
#define eps 1e-8
#define LL long long
#define MEM(a,b) memset(a,b,sizeof(a))
#define PB push_back
#define MP make_pair
#define PQ priority_queue
#define MII map<int,int>::iterator
#define MLL map<LL,LL>::iterator
#define pii pair<int,int>
#define SI set<int>::iterator
#define SL set<LL>::iterator
#define MSI map<string,int>::iterator
#define M_SI multiset<int>::iterator
#define IN freopen("in.txt","r",stdin);
#define OUT freopen("out.txt","w",stdout);
#define BUG printf("bug************bug************bug\n");

using namespace std;

#define maxn 100000+10

struct node
{
    int id,cost;
    node(){}
    node(int id,int cost):id(id),cost(cost){}
};

vector<node>G[maxn];
LL ans[maxn];

void init()
{
    ans[0]=0;
    for (int i=1;i<maxn;i++) {G[i].clear();ans[i]=ans[i-1]+i+10; }
}

priority_queue<pii,vector<pii>,greater<pii> >q;

int d[maxn],n;
bool vis[maxn];

void dijkstra(int k)
{
    for(int i=0;i<=n;i++) d[i]=(i==k? 0 : inf);
    
    memset(vis,0,sizeof(vis));

    q.push(make_pair(d[k],k));
    
	while(!q.empty())
    {
        pii u=q.top();
    
	    q.pop();
    
	    int x=u.second;
    
	    if(!vis[x]) {
            vis[x]=true;
            for (int i=0;i<G[x].size();i++)
            {
                if(d[G[x][i].id]>d[x]+G[x][i].cost)
                {
                    d[G[x][i].id]=d[x]+G[x][i].cost;
                    q.push(make_pair(d[G[x][i].id],G[x][i].id));
                }
            }
        }
    }
}
int main()
{
    int n, x, y, c;

    while(scanf("%d", &n)!=EOF)
    {
        init();
        
        for (int i=1;i<=n;i++) 
			d[i]=inf;
			
        for (int i=1;i<n;i++)
        {
            scanf("%d%d%d", &x, &y, &c);
            G[x].PB(node(y,c));
            G[y].PB(node(x,c));
        }
        d[1] = 0;
        
        dijkstra(1);
        
		int dist=0,u;
        
		for (int i=1;i<=n;i++) 
			if (d[i]>dist) dist=d[i],u=i;
        
		for(int i=1;i<=n;i++) d[i]=inf;
        
		d[u]=0;
        
		dijkstra(u);
        
		dist=0;
        
		for (int i=1;i<=n;i++) dist=max(dist,d[i]);
        
		printf("%I64d\n",ans[dist]);
    }
    return 0;
}