继续迪杰斯特拉算法

对于任何时候循环记住两个点：
1如果要循环已有数字，从1开始，从1开始！
如果是自己的vector 一定要从0开始，自己造的数据一定要想好从哪里开始！
2 一定不要忘记访问visited，

void dj(int s, int n) { 
    fill(dis, dis + N + 5, INF);
    fill(visited, visited + N + 5, false);

    dis[s] = 0;
    //不能在这里有这个东西集集堡，0是开始要进入的，不能没了！visited[s] = true; 
    int u = s;

    for (int iter = 0; iter < n; iter++) {  
        int u = -1, maxd = INF;
        for (int i = 1; i <= n; i++) {
            if (!visited[i] && dis[i] < maxd) { //注意visited未访问！ 
                u = i;
                maxd = dis[i];
            }
        }

        if (u == -1) return;  //一定要注意这里要return！！

        visited[u] = true;  

        for (int i = 0; i < P[u].size(); i++) {  
            int id = P[u][i].to;
            int w = P[u][i].w;
            if (dis[u] + w < dis[id]) {  
                dis[id] = dis[u] + w;
            }
        }
    }
}

堆优化的模板//

#include <bits/stdc++.h>
using namespace std;


const int INF = 1e9;

struct Edge {
    int to, w;
};
struct cmp { 
    bool operator()(const Edge& a, const Edge& b) const {
        return a.to > b.to; 
    }
}; //注意这里的bool函数还没有学习
const int N = (int)1e6 + 5;
vector<Edge> P[N + 5]; 
bool visited[N + 5];
int dis[N + 5];
int dis1[N + 5],dis2[N+5];
priority_queue< Edge, vector<Edge>, cmp> pp;
void dj(int s, int n) { 
    fill(dis, dis + N , INF);
    fill(visited, visited + N, false);

    dis[s] = 0;
    pp.push({ 0,s });
    while (!pp.empty()) {
        Edge qw = pp.top();
        pp.pop();
        int to = qw.to, w = qw.w;
        if (visited[w])continue;
        visited[w] = true;
        for (int i = 0; i < P[w].size(); i++) {
            int nto = P[w][i].to, nw = P[w][i].w;
            if (dis[w] + nw < dis[nto]) {
                dis[nto] = dis[w] + nw;
                pp.push({ dis[nto],nto });
            }
        }
    }
    return ;
    ///*visited[s] = true;*/
    //int u = s;

    //for (int iter = 0; iter < n; iter++) {  
    //    int u = -1, mind = INF;
    //    for (int i = 1; i <= n; i++) {
    //        if (!visited[i] && dis[i] < mind) {  
    //            u = i;
    //            mind = dis[i];
    //        }
    //    }

    //    if (u == -1) return;  

    //    visited[u] = true;  

    //    for (int i = 0; i < P[u].size(); i++) {  
    //        int id = P[u][i].to;
    //        int w = P[u][i].w;
    //        if (dis[u] + w < dis[id]) {  
    //            dis[id] = dis[u] + w;
    //        }
    //    }
    //}
}
int main() {
    int n, m, a, b;
    cin >> n >> m >> a >> b;
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        P[u].push_back({ v, w });
        P[v].push_back({ u, w });
    }
    dj(1, n);
    copy(dis, dis + N, dis1);
    dj(n, n);
    copy(dis, dis + N, dis2);
    int ans = INF;
    for (int i = 1; i <= n; ++i)
        if (dis1[i] <= a && dis2[i] <= b)
            ans = min(ans, dis1[i] + dis2[i]);

    ans == INF ? cout << "(T_T)" : cout << ans;
    return 0;
}