#include<iostream>
#include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;

struct e{
    int next,c;
};
vector<e> edge[101];
bool mark[101];
int dis[101];

int main (){
    int n,m;
    while (cin>>n>>m && n!=0 && m!=0){
        
 
int a,b,c;
        e temp;
        //初始化 
        for (int i=1;i<=n;i++){
            edge[i].clear();
            dis[i]=-1;
            mark[i]=false;
        }
        dis[1]=0;
        mark[1]=true;
        
        
        while(m--){
            cin>>a>>b>>c;
            temp.c
 
=c;
            temp.next=a;
            edge[b].push_back(temp);
            temp.next=b;
            edge[a].push_back(temp);
        }
        
        int newp=1;
        for (int i=1;i<n;i++){
            for (int j=0;j<edge[newp].size();j++){
                int nex=edge[newp][j].next;
                
 
int c = edge[newp][j].c;
                if (mark[nex] == true)
                continue;
                if (dis[nex]==-1 || dis[nex]>dis[newp]+c)//floyd也有若不可達或者比之小，不知道為啥要有不可達，先記住 
                dis[nex] = dis[newp]+c;
            }
            int min=100000000;
            for (int j=1;j<=n;j++){
                if (mark[j] == true)
                continue;
                if (dis[j] == -1)//因為我們的無窮大不是無窮，而是-1，之後的比大小有影響 
                continue;       //所以要加上這個條件
                if(dis[j]<min){
                    min = dis[j];
                    newp=j;
                }  
            }
            mark[newp]=true;
            
            
        }
    cout<<dis[n]<<endl;
    }

    return 0;

}

在寫代碼上感覺比floyd麻煩很多。但是floyd是n的三次方的復雜度，被求解圖的大小不能大於200個節點

dijstra是n的平方的復雜度

標紅的鄰接鏈表初始化我總是忘記

核心代碼循環n-1次，先更新通過新節點後的dis，再找更新後最近的成為newp

最短路，dijstra算法