【最短路-dijkstra】HDU 2544 最短路

dijkstra算法大致就是：

• 维护所有点到起点的距离dis[ i ]最小，进行持续的松弛操作。

1. 从起点开始，进行松弛操作，更新dis，标记该点（以后不再松弛，因为已经是最小。【因为我们是用最小路径的点来松弛别的点，你想，如果这个点是从别的点绕回来更新的话肯定要有多余的路径长度，所以标记过的点一定是最小路径】）
2. 选择未被标记的并且到起点路径成本最小的点，再从这个点开始，进行松弛操作，更新dis，标记该点
3. 重复上面步骤，直到更新完所有点的dis[ ]

上面是维护了每一个点到起点的距离都是最小值，如果我们只需要求一个点的最短路径，那么如果它从优先队列中取出来来松弛其他点的话，那么就可以直接return dis[ ed ]了

HDU 2544 最短路模板题为例

O(V^2)【邻接矩阵存边】

int dijkstra(int st,int ed)
{
    memset(vis, 0 , sizeof(vis));
    for(int i=1;i<=V;i++)//初始化dis[]
        dis[i]=(i==st ? 0 : INF);
    for(int i=1;i<V;i++)//从起始点的下一点开始松弛，要更新完所有的点，最多只有N-2个点需要松弛
    {
        int min_pos=0;
        int minn=INF;
        for(int j=1;j<=V;j++)//找到最短路径成本的点
            if(!vis[j])
                if(dis[j]<minn)
                {
                    min_pos=j;//标记该点的位置
                    minn=dis[j];
                }
        vis[min_pos]=1;
        for(int j=1;j<=V;j++)//将每点更新为从min_pos出发的最小的dis[]
        {
            dis[j]=min(dis[j],dis[min_pos]+mp[min_pos][j]);
        }
    }
    return dis[ed];
}

O(VlogV)【邻接矩阵存边_优先队列优化】

const int maxn=105;
int mp[maxn][maxn];
int dis[maxn],vis[maxn];//dis[i]：从起点到i点的最短距离
int V,E;

struct node{
    int to,w;//to:指向st的点
    node(int a=0,int b=0):to(a),w(b){}
    friend bool operator < (node n1,node n2)
    {
        return n1.w>n2.w;//小的在前（优先队列：优先级大的在前）
    }
};

int dijkstra(int st,int ed)
{
    memset(vis,0, sizeof(vis));
    priority_queue<node > q;//先进先出
    for(int i=1;i<=V;i++)
        dis[i]=(i==st ? 0 : INF);
    q.push(node(st,dis[st]));
    while(!q.empty())
    {
        node tmp=q.top();
        q.pop();
        if(vis[tmp.to])
            continue;
        for(int i=1;i<=V;i++)
        {
            if(dis[i]>tmp.w+mp[tmp.to][i])
            {
                dis[i]=tmp.w+mp[tmp.to][i];
                q.push(node(i,dis[i]));
            }
        }
        vis[tmp.to]=1;
    }
    return dis[ed];
}

void init()
{
    for(int i=1;i<=V;i++)
    {
        for(int j=1;j<=V;j++)
        {
            mp[i][j]=INF;
        }
    }
}

int main()
{
    while(~scanf("%d%d",&V,&E)&&(V||E))
    {
        init();
        for(int i=0;i<E;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            mp[a][b]=mp[b][a]=c;
        }
        printf("%d\n",dijkstra(1,V));
    }
    return 0;
}

O(VlogV)【链式前向星存边_优先队列优化】

const int maxV=105;
const int maxE=1e4+5;

int cnt,head[maxV];//cnt:当前是第几条边，head[i]:i指向的第几条边
int dis[maxV];//dis[i]：从起点到i点的最短距离
int vis[maxV];
int V,E;

struct EDGE{
    int pre,to,w;//edge[i].pre:(第i个点，假设为v)v结点发出的上一条边的标号，edge[i].to:v指向to，权值为edge[i].w
    EDGE(int a=0,int b=0,int c=0):pre(a),to(b),w(c){}
    friend bool operator < (EDGE e1,EDGE e2) {return e1.w>e2.w;}
}edge[2*maxE];//无向图，边开两倍

struct node{
    int point,val;
    node(int a=0,int b=0):point(a),val(b){}
    friend bool operator < (node n1,node n2) { return n1.val>n2.val; }
};

void add_edge(int u,int v,int val)
{
    edge[cnt]=EDGE(head[u],v,val);
    head[u]=cnt++;//更新head[u]为发出的最新的边的标号
}

int dijkstra(int st,int ed)
{
    memset(vis,0, sizeof(vis));
    for(int i=1;i<=V;i++)
        dis[i]=(i==st? 0 : INF);
    priority_queue<node>pq;
    pq.push(node(st,dis[st]));
    while(!pq.empty())
    {
        node tmp=pq.top();
        pq.pop();
        if(vis[tmp.point])
            continue;
        for(int i=head[tmp.point]; ~i ; i=edge[i].pre)
        {
            if(dis[edge[i].to]>dis[tmp.point]+edge[i].w)
            {
                dis[edge[i].to]=dis[tmp.point]+edge[i].w;
                pq.push(node(edge[i].to,dis[edge[i].to]));
            }
        }
        vis[tmp.point]=1;
    }
    return dis[ed];
}

void init()
{
    cnt=0;
    memset(head,-1, sizeof(head));
}

int main()
{
    while(~scanf("%d%d",&V,&E)&&(V||E))
    {
        init();
        for(int i=0;i<E;i++)
        {
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            add_edge(a,b,c);
            add_edge(b,a,c);
        }
        printf("%d\n",dijkstra(1,V));
    }
    return 0;
}