单源最短路径（Dijkstra）（C++）

寻找起始点与其余点的最短路径向量。

例如：

       输入：

                   1     （一组测试数据）

                   5     7  （共5个节点（1   2   3   4   5 ），即将输入7组关系）

                   1      5       100（1->5之间有向连接 ，权值100）

                   1      2       10

                   1      4       30

                   2      3       50

                   3      5       10

                   4      3       20

                   4      5       60

        输出：0    10    50     30    60

解：

#include<iostream>
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<map>
#include<string>
#include<vector>
using namespace std;
#define MaxInt 0x3f3f3f3f
void dijkstra(int** map,vector<int>& result,int n,int sp)
{
bool* visited=new bool[n+1];//存储已访问的节点
memset(visited,0,sizeof(bool)*(n+1));
for(int i=0;i<=n;i++)      
result.push_back(MaxInt);
//源点为节点1，根据源点初始化各项值
visited[sp]=1;
int pos=sp,min;
for(int j=1;j<=n;j++)
{
if(j==sp)
result[j]=0;
else
       result[j]=map[pos][j];
}

//循环n-1次，每次造访一个节点
for(int i=0;i<n-1;i++)
{
min=MaxInt;
//每次寻找result中未被造访的最小值
for(int j=1;j<=n;j++)
{
if(result[j]<min&&visited[j]==0)
{
min=result[j];
pos=j;
}
}
visited[pos]=1;
//更新result数组，如果存在更短的路径则更新
for(int j=1;j<=n;j++)
{
if((map[pos][j]+result[pos])<result[j]&&visited[j]==0)
result[j]=map[pos][j]+result[pos];
}
}
}

int main()
{
int n;
while(cin>>n)
{
int v,e;
cin>>v>>e;//v个节点，即将输入e组关系
//初始化邻接矩阵为MaxInt
int **map=new int*[v+1];
for(int i=1;i<v+1;i++)
{
map[i]=new int[v+1];
memset(map[i],MaxInt,sizeof(int)*(v+1));
}
   //输入邻接矩阵
for(int i=0;i<e;i++)
{
int m1,m2,tmp;
cin>>m1>>m2>>tmp;
map[m1][m2]=tmp;
}
//定义结果向量，用以存储最终返回结果
vector<int> result;
//调用单源最短路径算法
dijkstra(map,result,v,1);
//输出结果
for(int i=1;i<=v;i++)
cout<<result[i]<<endl;
}
}