单源最短路~热浪

德克萨斯纯朴的民众们这个夏天正在遭受巨大的热浪！！！

他们的德克萨斯长角牛吃起来不错，可是它们并不是很擅长生产富含奶油的乳制品。

农夫John此时身先士卒地承担起向德克萨斯运送大量的营养冰凉的牛奶的重任，以减轻德克萨斯人忍受酷暑的痛苦。

John已经研究过可以把牛奶从威斯康星运送到德克萨斯州的路线。

这些路线包括起始点和终点一共有 T个城镇，为了方便标号为 1 到 T。

除了起点和终点外的每个城镇都由 双向道路 连向至少两个其它的城镇。

每条道路有一个通过费用（包括油费，过路费等等）。

给定一个地图，包含 C 条直接连接 2 个城镇的道路。

每条道路由道路的起点 Rs，终点 Re 和花费 Ci 组成。

求从起始的城镇 Ts 到终点的城镇 Te 最小的总费用。

输入格式

第一行: 44 个由空格隔开的整数: T,C,Ts,Te;

第 22 到第 C+1 行: 第 i+1 行描述第 i 条道路，包含 3 个由空格隔开的整数: Rs,Re,Ci。

输出格式

一个单独的整数表示从 Ts 到 Te 的最小总费用。

数据保证至少存在一条道路。

数据范围

1≤T≤2500
1≤C≤6200
1≤Ts,Te,Rs,Re≤T
1≤Ci≤1000

输入样例：

7 11 5 4
2 4 2
1 4 3
7 2 2
3 4 3
5 7 5
7 3 3
6 1 1
6 3 4
2 4 3
5 6 3
7 2 1

输出样例：

7

代码示例：

方法一：spfa

//spfa算法
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;

const int  N=3000,M=15000;
int h[N], e[M], w[M], ne[M], idx;
int dist[M];
bool st[N];
int n,m,ts,te;
queue<int> q;

void add(int a, int b, int c)  
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}

int spfa()
{
    memset(dist,0x3f,sizeof dist);
    q.push(ts);
    dist[ts]=0;
    st[ts]=true;
    
    while(q.size())
    {
        int t=q.front();
        q.pop();
        
        st[t]=false;
        
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>dist[t]+w[i])
            {
                dist[j]=dist[t]+w[i];
            
                if(!st[j])
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
    
    return dist[te];
}

int main()
{
    cin>>n>>m>>ts>>te;
    memset(h, -1, sizeof h);
    
    while (m -- ){
        int a,b,c;
        cin>>a>>b>>c;
        add(a, b, c);
        add(b, a, c);
    }
    
    int t=spfa();
    cout<<t<<endl;
    
    return 0;
}

方法二：dijkstra

//dijkatra朴素
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=3000,M=20000;
int dist[N];
int g[N][N];
int n,m,ts,te;
bool st[N];
int h[N], e[M], w[M], ne[M], idx;

int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[ts]=0;
    
    for(int i=1;i<=n;i++)
    {
        int t=-1;
        for(int j=1;j<=n;j++)
        {
            if(!st[j] && (t==-1 || dist[t]>dist[j])) 
            {
                t=j;
            }
        }
        st[t]=true;
        
        for(int j=1;j<=n;j++)
        {
            dist[j]=min(dist[j],dist[t]+g[t][j]);
        }
    }
    return dist[te];
}

int main()
{
    memset(g, 0x3f, sizeof g);
    cin>>n>>m>>ts>>te;
    
    while (m -- )
    {
        int a,b,c;
        cin>>a>>b>>c;
        g[a][b]=g[b][a]=min(g[a][b],c);
    }
    
    int t=dijkstra();
    cout<<t<<endl;
    
    return 0;
}