46分，除AC外输出均为0 代码：

#include <string.h>
#include <iostream>
#include <queue>
using namespace std;

typedef long long T;

class Tree
{
private:
    typedef T _T;
    static const _T NODE_MAX = 10005, EDGE_MAX = 300005;

public:
    class Edge
    {
    public:
        _T to, dis, fr;
        Edge *ne;
        Edge() { dis = 0x7fffffff; }
        Edge(_T From, _T To, Edge *Next, _T Dis)
        {
            to = To;
            fr = From;
            ne = Next;
            dis = Dis;
        }
    };
    Edge *head[NODE_MAX];
    void add(_T a, _T b, _T dis)
    {
        Edge *e = new Edge(a, b, head[a], dis);
        head[a] = e;
    }
};

class Step
{
public:
    T x, dis;
    const bool operator>(const Step &a) const { return dis > a.dis; }
};

const T NODEMX = 100005;
priority_queue<T, vector<T>, greater<T>> qu;
Tree mp, dag, dag2;
T ds[10][NODEMX];
T deg[NODEMX], len[NODEMX];
bool vis[NODEMX];

void dijk(T x, T id, T n)
{
    ds[id][x] = 0;
    qu.push(x);
    while (!qu.empty())
    {
        T u = qu.top();
        qu.pop();
        if (vis[u])
            continue;
        vis[u] = 1;
        for (Tree::Edge *e = mp.head[u]; e != nullptr; e = e->ne)
        {
            T y = e->to, w = e->dis;
            if (ds[id][y] > ds[id][u] + w)
            {
                ds[id][y] = ds[id][u] + w;
                qu.push(y);
            }
        }
    }
}

void topology(queue<T> &q, Tree tr, T n)
{
    q = queue<T>();
    for (T i = 1; i <= n; i++)
    {
        if (deg[i] <= 0)
            q.push(i);
    }
    while (!q.empty())
    {
        T x = q.front();
        q.pop();
        for (Tree::Edge *e = tr.head[x]; e != nullptr; e = e->ne)
        {
            T y = e->to, w = e->dis;
            deg[y]--;
            len[y] = max(len[y], len[x] + w);
            if (deg[y] <= 0)
                q.push(y);
        }
    }
}

int main()
{
    T n, m, x1, x2, y1, y2;
    cin >> n >> m >> x1 >> x2 >> y1 >> y2;
    for (T i = 1; i <= m; i++)
    {
        T a, b, d;
        cin >> a >> b >> d;
        mp.add(a, b, d);
        mp.add(b, a, d);
    }
    memset(ds, 0x7f, sizeof(ds));
    memset(vis, 0x00, sizeof(vis));
    dijk(x1, 1, n);
    memset(vis, 0x00, sizeof(vis));
    dijk(y1, 2, n);
    memset(vis, 0x00, sizeof(vis));
    dijk(x2, 3, n);
    memset(vis, 0x00, sizeof(vis));
    dijk(y2, 4, n);
    for (T x = 1; x <= n; x++)
    {
        for (Tree::Edge *e = mp.head[x]; e != nullptr; e = e->ne)
        {
            T y = e->to, w = e->dis;
            if (ds[1][x] + w + ds[2][y] == ds[1][y1])
            {
                if (ds[3][x] + w + ds[4][y] == ds[3][y2])
                {
                    dag.add(x, y, w);
                    deg[y]++;
                }
            }
        }
    }
    queue<T> q;
    T ans = 0;
    memset(vis, 0x00, sizeof(vis));
    topology(q, dag, n);
    for (T i = 1; i <= n; i++)
        ans = max(ans, len[i]);
    memset(deg, 0x00, sizeof(deg));
    memset(len, 0x00, sizeof(deg));
    for (T x = 1; x <= n; x++)
    {
        for (Tree::Edge *e = mp.head[x]; e != nullptr; e = e->ne)
        {
            T y = e->to, w = e->dis;
            if (ds[1][x] + w + ds[2][y] == ds[1][y1])
            {
                if (ds[4][x] + w + ds[3][y] == ds[3][y2])
                {
                    dag2.add(x, y, w);
                    deg[y]++;
                }
            }
        }
    }
    memset(vis, 0x00, sizeof(vis));
    topology(q, dag2, n);
    for (T i = 1; i <= n; i++)
        ans = max(ans, len[i]);
    cout << ans;
}