1 //弗洛伊德 floyd 
 2 void floyd()// n3 
 3 {
 4 //想象為在拉麵條，不斷進行鬆弛操作 
 5     for(ll k=1;k<=n;++k)//k必須放在最外層 
 6     for(ll i=1;i<=n;++i)//列舉兩端點 
 7     for(ll j=1;j<=n;++j)
 8     g[i][j]=min(g[i][j],g[i][k]+g[k][j]);
 9 }
10 //迪傑斯特拉 dijkstra
11 //本質為貪心，即每次取距離最短的點，不斷進行鬆弛操作
12 //時間複雜度：未加堆優化時是n^2，加了堆優化後是nlogn
13
 
 //穩定性很強，但是僅適用於正邊權，有負邊權就game over了
14 ll dis[N],head[M];
15 bool vis[N];
16 struct node
17 {
18     ll len,poi;
19     friend bool operator < (node a,node b)
20     {
21         return a.len>b.len;
22     }
23 }
24 struct edge
25 {
26     ll nex,to,lenth;
27 }e[M];
28 void dijkstra()//堆優化 
29 {
30     dis[start]=0
 
;
31     q.push((node){0,start});
32     while(!q.empty())
33     {
34         node u=q.top();q.pop();
35         l x=u.poi,d=u.dis;
36         if(vis[x])continue;
37         vis[x]=1;
38         for(ll i=head[x];i;i=e[i].nex)
39         {
40             ll v=e[i].to,l=e[i].lenth;
41             if(v==u)continue
 
;
42             if(dis[v]>dis[u]+lenth)
43             {
44                 dis[v]=dis[u]+lenth;
45                 if(vis[v])continue;
46                 q.push((node){dis[v],v});
47             }
48         }
49     }
50 }
51 // spfa
52 // 動態逼近法，也是不斷鬆弛，能夠判斷負環，即一個點入隊次數超過n次
53 // 可以用於負邊權 
54 queue<ll>q;
55 void spfa()//該程式碼沒判斷負環哦
56 {
57     q.push(start);dis[start]=0;vis[start]=1;
58     while(!q.empty())
59     {
60         ll u=q.front();q.pop();vis[u]=0;
61         for(ll i=head[u];i;i=e[i].nex)
62         {
63             ll v=e[i].to,l=e[i].len;
64             if(dis[v]>dis[u]+l)
65             {
66                 dis[v]=dis[u]+l;
67                 if(vis[v]==0)
68                 {
69                     q.push(v);vis[v]=1;
70                 }
71             }
72         }
73     }
74 }
75 // dijkstra和spfa其實是很像的
76 // 稠密圖：dijstra+堆優化 更好 
77 // 稀疏圖：spfa 更好 
78 // 建議用dijkstra，spfa自從在NOI2018被卡後都不敢用了