朴素版dijkstra和朴素版prim算法比较

1.dijkstra

时间复杂度：O(n^2)
n次迭代，每次找到距离集合S最短的点
每次迭代要用找到的点t来更新其他点到S的最短距离。

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N=510;

int g[N][N];
int dis[N],n,m;//dis[i]表示节点i到初始点的最短距离
bool st[N];

int dijkstra()
{
    memset(dis,0x3f,sizeof dis);
    dis[1]=0;
    for(int i=1;i<=n;i++)//n次迭代，没次找到距离集合S的最短的点
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(!st[j]&&(t==-1||dis[j]<dis[t]))
            {
                t=j;
            }
        }
        st[t]=1;
        //找到节点t是距离集合S的最短距离的点之后
        //用t来更新其他点到s的距离
        for(int j=i;j<=n;j++)
        {
            dis[j]=min(dis[j],dis[t]+g[t][j]);
        }
    }
    if(dis[n]==0x3f3f3f3f)return -1;
    else 
        return dis[n];
}

int main()
{
    memset(g,0x3f,sizeof g);
    /*
    初始化成0会比较好，但不初始化也没关系。因为题目中说所有边权都是正的，
    所以 dist[i] + g[i][i] 一定大于 dist[i]，所以i->i这条边一定不会被用到。
    */
    cin>>n>>m;
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=min(g[a][b],c);
    }
    
    cout<<dijkstra()<<endl;
    return 0;
}

2.prim

时间复杂度：O(n^2)
同dijkstra算法

#include<iostream>
#include<cstring>
#include<algorithm>
//稠密图
using namespace std;

const int N=510,M=1e5+10;
//Prim算法给出最小生成树的权重和
int g[N][N],dis[N];
//dis[i]表示第i个点到已经纳入最小生成树集合S的最小距离
int n,m,res;
bool st[N];

int prim()
{
    memset(dis,0x3f,sizeof dis);

    for(int i=0;i<n;i++)
    {
        int t=-1;//那个点是哪个点？
        for(int j=1;j<=n;j++)//在n个点中寻找不到集合S中距离
        //S最近的点的标号
        {
            if(!st[j]&&(t==-1||dis[j]<dis[t]))
                t=j;
        }
        //找到了那个点t
        st[t]=1;
        //中间关于i==0时的几个判断
        //cout<<dis[t]<<endl;
        if(i)
        {
            res+=dis[t];
            //cout<<res<<endl;
        }

        //在n次迭代中的判断，如果该图是一个不连通图，不存在最小生成树
        if(i&&dis[t]==0x3f3f3f3f)return 0x3f3f3f;
        //用t点来更新其他点到S的距离
        for(int j=1;j<=n;j++)
            dis[j]=min(dis[j],g[t][j]);

    }
    return res;

}

int main()
{
    cin>>n>>m;
    memset(g,0x3f,sizeof g);
    while(m--)
    {
        int a,b,c;cin>>a>>b>>c;
        g[a][b]=g[b][a]=min(g[a][b],c);
    }
    int t=prim();
    if(t==0x3f3f3f)
        cout<<"impossible"<<endl;
    else
        cout<<t;


    return 0;
}

标签：0x3f,prim,int,dijkstra,include,朴素,dis
来源： https://www.cnblogs.com/forward-985/p/13693068.html