如何加快dijkstra单源，单目标回溯

我试图解决Dijkstra问题Alpha#20 Prob C，并在案例31中得到TLE，该案例具有具有99999边的100000节点。我假设我的代码的复杂度是O（E lg V），大约相当于499995。我认为这已经足够快了，但由于结果不成功，我通过使用内联代码进行回溯和一些优化来加快速度，比如在从队列中删除目标节点后立即中断dijkstra。我认为这不应该影响结果，就像删除了一个节点一样，这意味着已经找到了最佳路径，我们可以去享受了。我现在已经没有优化这个代码的想法了，所以来到这里。代码如下：

#include <iostream>
#include <vector>
#include <set>
#include <cstdio>
#include <climits>
#include <limits>
using namespace std;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<vii> vvii;
vi D;
vi parent;
vi path;
vvii graph;

void dijkstra(int i, int j)
{
        set<ii> Q;
        Q.insert(ii(0, i));
        D[i] = 0; parent[i] = -555;
        bool checked = false;
        while(!Q.empty())
        {
                ii top = *Q.begin();
            Q.erase(Q.begin());
            int topnode = top.second;
            for(vii::iterator it = graph[topnode].begin();it != graph[topnode].end();it++)
            {
                int v = it->first, d2 = it->second;
                if(D[v] > D[topnode] + d2)
                    {
                        if(D[v] != INT_MAX)
                        {
                                Q.erase(Q.find(ii(D[v], v)));
                        }
                        D[v] = D[topnode] + d2; parent[v] = topnode;
                        Q.insert(ii(D[v], v));
                        if(v == j)
                                checked = true;
                    }
            }
            if(checked)
            {
                if(Q.find(ii(D[j], j)) == Q.end())
                    break;
            }
        }
}
/* void backtrack(int n)
{
    if(parent[n] != -555)
    {
        path.push_back(n);
        backtrack(parent[n]);
    }
}
void backtrack2(int n)
{
    while(parent[n] != -555)
    {
        path.push_back(n);
        n = parent[n];
    }
} */
int main(void) {
    int n, m, x, y, z;
    scanf("%d%d", &n, &m);
    graph.clear(); graph.resize(n); D.resize(n, INT_MAX); parent.resize(n, -1);
    while(m--)
    {
        scanf("%d%d%d", &x, &y, &z);
        graph[x-1].push_back(ii(y-1, z));
        graph[y-1].push_back(ii(x-1, z));
    }
    dijkstra(0, n-1);
    if(D[n-1] == INT_MAX)
        printf("-1n");
    else
    {
        int x = n-1;
        while(parent[x] != -555)
        {
            path.push_back(x);
            x = parent[x];
        }
        printf("1 ");
        for(int i = int(path.size())-1;i >= 0;i--)
        {
            printf("%d ", path[i]+1);
        }
        printf("n");
    }
}

我不确定我能做些什么来提高它的速度。我已经尝试过减少递归调用的开销，这是可能的。如果有人有任何其他想法，或者能够指出某种错误（如果有（在优化中）），我们将不胜感激。我认为现在唯一可以做的就是使用priority_queue（而不是set），但我认为这不会对性能产生太大影响。

谢谢！

nib