Dijkstra[两种邻接表+优先队列优化]

Dijksta算法中，如果我们采用的是邻接矩阵来存的，第一点浪费的空间比较多，第二点我们知道算法的时间复杂度在O（n*n），这样的算法可以说并不是很好，所以我们考虑优化它首先我们可以优化存储结构，采用邻接表来存储，其次我们可以用优先队列来排序大小，其时间复杂度大大降低。

需要注意的是pair是按照第一个元素的大小排序，如果相同才按照第二个，所以我们要把d[i]包装在第一个元素上。

vector实现邻接表+优先队列 (假设边一开始是字符型的，这么假设是为了加点难度)

#include
#include
#include
#include

输入数据：

1
6 9
D E 13
B C 9
A B 1
A C 12
B D 3
E C 5
D C 4
D F 15
E F 4
A F
输出数据：

17
0 1 8 4 13 17

数组实现邻接表+优先队列

#include
#include
#include
#include
#define inf 0x7fffffff
using namespace std;
const int MAXN = 205;
int dis[MAXN];
int u[MAXN],v[MAXN],w[MAXN];
int first[MAXN],next[MAXN];
int n,m;
int src,ed;
typedef pair pii;
void init()
{
    scanf("%d%d",&n,&m);
    memset(first,-1,sizeof(first));
    for(int i=1;i<=m;i++){
        scanf("%d%d%d",&u[i],&v[i],&w[i]);
        next[i]=first[u[i]];
        first[u[i] ]=i;
        u[i+m]=v[i],v[i+m]=u[i],w[i+m]=w[i];  //无向边，所以加一条反向边
        next[i+m]=first[u[i+m] ];
        first[u[i+m] ]=i+m;
    }
    cin>>src>>ed;
    for(int i=1;i<=n;i++) dis[i]= (i==src? 0:inf);//不要把dis[i]初始化成源点到各点的直接距离，否则会有点没入队。
}
void dijkstra()
{
    priority_queue,greater >que;
    que.push(pii(0,src));
    while(!que.empty()){
        pii tmp=que.top();
        que.pop();
        int x = tmp.second;
        if(tmp.first!=dis[x]) continue;  //如果出队的这个元素,他带的dis,和当前的dis不相同，证明这个结点是被处理过的已确定了最短路，
        for(int e=first[x];e!=-1;e=next[e]){   //这种数组式邻接表的遍历
            if(dis[v[e]]>dis[x]+w[e]){
                 dis[v[e] ]=dis[x]+w[e];
                 que.push(pii(dis[v[e] ],v[e]));
            }
        }
    }

}
int main()
{
 //   freopen("1.in","r",stdin);
    int _;
    scanf("%d",&_);
    while(_--){
        init();
        dijkstra();
        if(dis[ed]==inf) cout<<"-1"<


测试数据：

1
6 9
1 2 1
1 3 12
2 3 9
2 4 3
5 3 5
4 3 4
4 5 13
4 6 15
5 6 4
1 6

输出：

17
0 1 8 4 13 17