dijstra原理：

以單源開始，每次以新的點去更新所有的（沒訪問過的點） 到單源的最短路。    

   其中新的點---------應該找每次更新後當前到單源權值最小的點.

作法一：鄰接矩陣

void DIJ(int n)//傳入頂點個數n，預設0為起點 
{ 
    int i,j,k; 
    low[0]=0; 
    bool flag[SIZE]={0}; 
    flag[0]=1; 
    for(i=1;i<n;i++) 
    { 
        low[i]=a[0][i]; 
    } 
     
    for(i=1;i<n;i++) 
    { 
        int min=INF; 
        for(j=0;j<n;j++) 
        { 
            if(flag[j]==0&&low[j]<min) 
            { 
                min=low[j]; 
                k=j; 
            } 
        } 
        flag[k]=1; 
        for(j=0;j<n;j++) 
        { 
            if(flag[j]==0&&a[k][j]+low[k]<low[j]) 
                low[j]=low[k]+a[k][j]; 
        } 
    } 
}
 

作法2：鄰接表+優先佇列  

題為：求一個點到 三個點距離和 最小的點。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
#define N 5050
#define M 20010
#define INF 0x1f1f1f1f
int lowa[N],lowb[N],lowc[N];
int head[N];  //鄰接表的頭。下標為每個城市編號，對映是以它為頂點的第一條邊 在arc中的儲存位置。
struct Arc
{
    int next;
    int point;
    int cost;
}arc[M];  //模擬連結串列儲存，下標是儲存地址，每個節點儲存末端頂點編號，與這條邊權值。
struct str //優先佇列的元素：儲存這一點的編號 和到單源的最短路。
{
    int num;
    int cost;
    str(int a,int b):num(a),cost(b){}
    str(){}
    friend bool operator<(str a ,str b)
    {
        return a.cost>b.cost;
    }
};
int vis[N];
void dij(int src,int n,int *low)
{
    memset(vis,0,sizeof(vis));//每個單源開始都把vis歸0；
    priority_queue<str> q; 
    q.push(str(src,0));   //把單源push進去，它到單源路徑為0;
    int kk=0;   
    while(kk<n&&!q.empty())//只要其餘n-1個點都訪問完，就ok了.
    {

        str s=q.top();
        q.pop();
        if(vis[s.num]) continue;//一定要防止再次訪問 已經確定最短路的點。
        vis[s.num]=1;//標記訪問了。
        low[s.num]=s.cost;//標誌著 這一點到單源的最短路已經確定.
        kk++;
        for(int e=head[s.num];e!=-1;e=arc[e].next)
        {
            if(!vis[arc[e].point])
                q.push(str(arc[e].point,arc[e].cost+s.cost));
        }
    }
}
int main()
{
    int ces=1;
    int n,m;
    int A,B,C;
    while(~scanf("%d%d",&n,&m))
    {
        memset(lowa,0x1f,sizeof(lowa));
        memset(lowb,0x1f,sizeof(lowa));
        memset(lowc,0x1f,sizeof(lowc));
        memset(head,-1,sizeof(head));
        scanf("%d%d%d",&C,&A,&B);
        for(int i=1;i<=m;i++)
        {
            int x,y,k;
            scanf("%d%d%d",&x,&y,&k);
            arc[i].next=head[x];
            arc[i].point=y;
            arc[i].cost=k;
            head[x]=i;

            arc[m+i].next=head[y];
            arc[m+i].point=x;
            arc[m+i].cost=k;
            head[y]=m+i;

        }
        int ans=INF;
        dij(A,n,lowa);     //用3個點做單源。
        dij(B,n,lowb);
        dij(C,n,lowc); 
        printf("Scenario  #%d\n",ces++);
        if(lowc[A]>=INF||lowc[B]>=INF)  //圖不連通.A或B到不了C
        {
            printf("Can not reah!\n");
            continue;
        }
        for(int i=1;i<=n;i++) //列舉Y 形交叉路的交叉點--找到最適合的兩人分開的交叉點。
        {
            if(lowa[i]+lowb[i]+lowc[i]<ans)
            {
                ans=lowa[i]+lowb[i]+lowc[i];
            }
        }
        printf("%d\n",ans);
        printf("\n");
    }
    return 0;
}