对于迪杰斯特拉算法的学习

7-1 单源最短路径

本题目要求一有向有权图（以边列表的形式读入），一个起点和一个终点。输出源点到终点的最短路径。

输入格式:

输入三个整数n（100000<n<10000000）,s和d，其中n表示边数目，s为起点，d为终点。然后依次输入n条边：v1 v2 w（v1为出度端点，v2为入度端点，w为权值，三者均为非负整数，其中w不超过20，v1和v2不超过1000000且节点序号不一定连续）

输出格式:

一个整数，表示s到d的最短距离。如果不可达，则输出-1.

输入样例:

在这里给出一组输入。例如：

11 0 8
0 1 6
0 2 4
0 3 5
1 4 1
2 4 1
3 5 2
4 6 9
4 7 7
5 7 4
6 8 2
7 8 4

输出样例:

在这里给出相应的输出。例如：

因为实验隐藏的测试用例很大，故采用邻接表结构存储边权图；

为了解决内存超限问题，故将数据保存在堆中，即通过new创建数组

为了解决超时问题，故采用了优先队列

段错误可能原因：终点给小了，用例中可能有超过了终点的大小的节点出现

解决办法：直接开一个MAX大小的数组（MAX=1000000），省略不需要的节点信息，例如Path


#include<iostream>
#include<algorithm>
#include<queue>#define MAX 1000000
#define MAXInt 31245
using namespace std;
typedef pair<int,int> Pair;//用优先队列选取权重最小的节点
int arc,s,e;
priority_queue<Pair,vector<Pair>,greater<Pair> >que;typedef struct ArcNode{int adjvex;int weight;struct ArcNode* nextarc;
}ArcNode;
typedef struct VNode{
//  int data;//数组下标即节点名称，不需要data信息bool vis;int wei;
//  int path;//用pair存的值<weight,该权重的节点> ，不需要路径，故path不需要 ArcNode *firstarc;
}VNode;
typedef struct{VNode* vertice;int vexnum,arcnum;
}ALGraph;void Creat(ALGraph &G);
void Dij(ALGraph &G,int s);
int main(){ALGraph G;Creat(G);#if 0 //此处为测试段，测试是否成功创建邻接表for(int i=0;i<MAX;i++){ArcNode* p=G.vertice[i].firstarc;while(p!=NULL){//!p是不正确的 cout<<p->adjvex<<" ";p=p->nextarc;}cout<<endl;}#endif
/*以下为控制结果的输出，若未找到，输出-1*/Dij(G,s);if(G.vertice[e].wei!=MAXInt)cout<<G.vertice[e].wei<<endl;elsecout<<-1<<endl;delete []G.vertice;
}
void Creat(ALGraph &G){cin>>arc>>s>>e;//输入边数，起点，终点 G.vertice=new VNode[MAX];G.arcnum=arc;//G.vexnum=e+1;for(int k=0;k<MAX;k++){G.vertice[k].firstarc=NULL;// G.vertice[k].data=k;G.vertice[k].vis=false;G.vertice[k].wei=MAXInt;//    G.vertice[k].path=-1;}for(int i=0;i<G.arcnum;i++){int v1,v2,wei;cin>>v1>>v2>>wei;ArcNode *pe=new ArcNode;pe->adjvex=v2;pe->weight=wei;pe->nextarc=G.vertice[v1].firstarc;G.vertice[v1].firstarc=pe; }
}
void Dij(ALGraph &G,int s){G.vertice[s].wei=0;//初始化起点weight为0/*错误点1：初始化只需将起点初始化插入队列即可，不需要对起点的邻接点也初始化，
此处操作与循环中操作相同*//*ArcNode *p=G.vertice[s].firstarc;while(p!=NULL){G.vertice[p->adjvex].wei=p->weight;//初始化权重 G.vertice[p->adjvex].path=s;//初始化前驱节点 //    ArcNode *d=p;p=p->nextarc;//   delete d;//释放d所指向的内存 }  */que.push(Pair(0,s));while(!que.empty()){Pair tmp=que.top();que.pop();int v=tmp.second;//节点 int w=tmp.first;//权重 if(G.vertice[v].vis==true)continue;elseG.vertice[v].vis=true;//s已被访问 ArcNode *p=G.vertice[v].firstarc;while(p!=NULL){int v0=p->adjvex;if(w+p->weight<G.vertice[v0].wei&&!G.vertice[v0].vis){G.vertice[v0].wei=G.vertice[v].wei+p->weight;//G.vertice[v0].path=v;//更新前驱节点 que.push(Pair(G.vertice[v0].wei,v0));}p=p->nextarc;//错误点2：p未循环 } }
}

对于上述代码的优化：

1.可以在找到终点时就退出循环，输出结果

2.对于此处的优先队列来说，我以pair（相当于下图的map）为关键字存储，故会存在同一个节点对应不同weight的情况，例如：之前存入了<3,1> (节点1的weight为3），更新之后存入了<2,1>(节点1的权重为2），虽不影响结果，但队列里会有重复的节点，浪费内存

改进：入队前与已在队列里的节点比较weight，小于则修改weight

3、采用链式前向星+优先队列

https://pursuit.blog.csdn.net/article/details/107674290

反思与总结

通过这次实验，让我意识到，从代码思想到代码实现，再到具体的实际应用，这之间都是有距离的。

代码思想到实现：这考验的是个人代码实现水平，把思想变成代码的能力有待加强

代码思想到实际应用：实际应用过程中，由于数据量，时间限制等多方面因素的影响，这就需要改善代码的适应性，结合一些其他的手段以投入实际应用。算法不可能是赤裸裸的直接用的。对于实际问题的处理能力有待增强。