最短路（Dijkstra）

算法过程

1.设置顶点集合S并不断的作贪心选择来扩充这个集合。一个顶点属于集合S当且仅当从源点到该点的最短路径长度已知
2.初始时，S中仅含有源。设U是G的某一个顶点，把从源到U且中间只经过S中的顶点的路称为从源到U的特殊路径，并用dis数组距离当前每一个顶点所对应的最短特殊路径
3.Dijkstra算法每一次从V-S中取出具有最短特殊长度的顶点u，将u添加到S中，同时对dis数组进行修改。一旦S包含了所有的V中的顶点，dis数组就记录了从源点到其它顶点的最短路径长度。

算法特点

1.Dijkstra算法解决的是图中单个源点到其它顶点的最短路径。只能解决权值非负.
2.Dijkstral不能求出任意两点之间的最短距离，同时适用于有向图和无向图，未优化时复杂度为O(n^2).

O(n^2)算法

int  value[maxn][maxn];/*保存的是边权值*/  
int  dis[maxn]；/*保存源点到任意点之间的最短路*/  
int  father[maxn];/*保存i点的父亲节点*/  
int  vis[maxn];/*标记顶点是否进入s集合*/  

void input()
{
    int star,even,v;  
    scanf("%d%d",&n,&m);  
    for(int i = 1 ; i <= n ; i++)/*初始化value数组*/ 
    { 
        for(int j = 1; j <= n; j++)  
            value[i][j] = INF;  
    }  
    for(int i = 0; i < m; i++)
    {  
        scanf("%d%d%d",&star,&even,&v);  
        if(value[star][even] == INF)  
            value[star][even] = value[even][star] = v;/*处理成无向图*/  
        else
        {  
            if(v < value[star][even])/*判断重边是否出现*/  
                 value[star][even] = value[even][star] = v;  
        }  
}  

void dijkstra(int s)//s为源点
{
    memset(vis,0,sizeof(vis));  
    memset(father,0,sizeof(father));  
    for(int i = 1; i <= n; i++)//初始化dis数组
       dis[i] = INF;  
    dis[s] = 0;  
    for(int i = 1; i <= n; i++)//枚举n个顶点（假设源点为0）
    {
        int pos;//记录要进入集合S的点  
        pos = -1;  
        for(int j = 1 ; j <= n ;j++)//找到未加入集合的最短路点
        { 
            if(!vis[j] && (pos == -1 || dis[j] < dis[pos]))  
                pos = j;  
        }  
        vis[pos] = 1;//把这个点加入最短路径集合  
        for(int j = 1; j <= n; j++)//更新dis数组 
        {
            if(!vis[j] && (dis[j] > dis[pos] + value[pos][j]))
            { 
                dis[j] = dis[pos] + value[pos][j];  
                father[j] = pos;  
            }  
        }  
     }  
}  

o(mlogn)算法（利用邻接表来优化）

///注意初始化head=-1，cnt=0；
const int maxn = 210;///点的个数
const int maxm = 4010;///边的个数
const int INF = 0xfffffff;
int n,m,cnt;///有n个点，m条边
int vis[maxn],dis[maxn],head[maxn];

typedef pair<int,int> pii;

struct edge
{
    int to,val,next;
}e[maxm];

void add(int from,int to,int  val)
{
    e[cnt].to=to;
    e[cnt].val=val;
    e[cnt].next=head[from];
    head[from]=cnt++;
}

void Dijkstra(int s)
{
    memset(vis,0,sizeof(vis));
    for(int i = 0 ; i < n ; i++) /*初始化点的距离*/
        dis[i] = INF;
    dis[s] = 0;
    priority_queue<pii,vector<pii>,greater<pii> > pq;
    pq.push(make_pair(dis[s],s));
    while(!pq.empty())
    {
        pii u = pq.top();
        pq.pop();
        int x = u.second; //点
        if(vis[x])  continue;
        vis[x] = 1;
        for(int i = head[x]; i != -1; i = e[i].next)//对每条边及其有相同点（x）的其他边进行更新
        {
            int v = e[i].to;
            if(dis[v] > dis[x]+e[i].val && !vis[v])
            {
                dis[v] = dis[x] + e[i].val;
                pq.push(make_pair(dis[v],v));
            }
        }
     }
}