Dijstra_优先队列_前向星

Dijstra算法求最短路径

具体实现方式

1. 设置源点，将源点从原集u{}中取出并放入新建集s{}
2. 找出至源点最近的点q从原集取出放入新集s{}
3. 由q点出发，更新所有由q点能到达的仍处于原集的点到源点的距离（取最短）
4. 选择距离源点最近的唯有原集的点，并重复步骤3
5. 直至原集中仅存一点的存在

---

优先队列

定义与重载运算符

1. 默认优先级
   • 借助<操作符，整数元素中，大的优先级高
2. 传入比较结构体
   • 通过传入不同类型的数据来定义不同类型的优先级,重载（）运算符
   • 优先队列第三个参数代表！cmp，来判断队列优先级

struct cmp{
    bool operator()( int a, int b){
        return a>b;
    }
}

priority_queue< int, vector<int>, cmp > q;

3. 通过自定义数据结构定义优先级，在结构体中重载<运算符

struct Node{
    int v;
    int w;
    int next;
    bool operator < (const Node &a ) const{
        return a.w<w;    //按w从小到大排序
    }
}edge[maxn];

priority_queue<Node>q;

---

前向星

链接在此→链式前向星

---

综合

最短路

HDU 2544

Problem Description

在每年的校赛里，所有进入决赛的同学都会获得一件很漂亮的t-shirt。但是每当我们的工作人员把上百件的衣服从商店运回到赛场的时候，却是非常累的！所以现在他们想要寻找最短的从商店到赛场的路线，你可以帮助他们吗？

Input

输入包括多组数据。每组数据第一行是两个整数N、M（N<=100，M<=10000），N表示成都的大街上有几个路口，标号为1的路口是商店所在地，标号为N的路口是赛场所在地，M则表示在成都有几条路。N=M=0表示输入结束。接下来M行，每行包括3个整数A，B，C（1<=A,B<=N,1<=C<=1000）,表示在路口A与路口B之间有一条路，我们的工作人员需要C分钟的时间走过这条路。

输入保证至少存在1条商店到赛场的路线。

Output

对于每组输入，输出一行，表示工作人员从商店走到赛场的最短时间

Sample Input

2 1

1 2 3

3 3

1 2 5

2 3 5

3 1 2

0 0

Sample Output

3

2

#include<cstdio>
#include<cstring>
#include<queue>
#define Inf 0x3f3f3f
using namespace std;
int cnt;
const int maxn=20010;
int head[maxn];
int dis[maxn];
bool vis[maxn];
struct Edge{
    int v;
    int w;
    int next;
    bool operator < ( const Edge &a) const{
        return a.w<w;
    }
}edge[maxn];
priority_queue<Edge>q;
void init(){
    cnt=0;
    memset(head,-1,sizeof(head));
}
void add_edge( int u, int v, int w){
    edge[cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].next=head[u];
    head[u]=cnt++;
}
void fr( void ){
    while( !q.empty() ){
        q.pop();
    }
}
int Dijstra( int v, int n){
    Edge p,t;
    int u;

    memset(vis,false,sizeof(vis));
    memset(dis,Inf,sizeof(dis));
    p.v=v;
    //p.w=0;
    dis[v]=0;
    //vis[v]=true;   致命错误，打标记的操作在循环体内进行
    q.push(p);
    while( !q.empty() ){
        p=q.top();
        q.pop();
        u=p.v;
        if( vis[u] )
            continue;
        vis[u]=true;
       for( int i=head[u]; ~i; i=edge[i].next){
            if( !vis[edge[i].v] && dis[edge[i].v]>dis[u]+edge[i].w ){
                dis[edge[i].v]=dis[u]+edge[i].w;
            //不使用优先队列时便将该点直接放入队列即可
                //q.push(edge[i]);
                t.v=edge[i].v;
            //查找过某点后将其放入集合中，该边(连接当前点与目标点)的边权w不再具有意义
            //因为dis[目标点]不再会被w[当前点,目标点]更新
            //而有优先队列是依照结构体中的边权进行的排序
            //下一步中需要找到离源点最近的点(步骤3)
            //故可将边权转为距源点的距离，以直接更新距源点最近的点↓
                t.w=dis[edge[i].v];
                q.push(t);
            }
        }
    }
    fr();

    return dis[n];
}
int main()
{
    int n,m;
    int u,v,w;

    while(~scanf("%d%d",&n,&m)){
        if( n==0 && m==0 )
            break;
        init();
        for( int i=0; i<m; i++){
            scanf("%d%d%d",&u,&v,&w);
            add_edge(u,v,w);
            add_edge(v,u,w);
        }
        printf("%d\n",Dijstra(1,n));
    }

    return 0;
}

---

• memset(data, 1, sizeof(data)); // wrong, data[x] would be 0x0101 instead of 1
• 可以借此初始化dis[]数组