我如何才能更有效地对 Dijkstra 算法进行这种修改？

Question

这个问题是我计算机科学作业的一部分。 作业包括 5 种不同类型的学生，他们穿越给定的加权无向节点图，其中每个学生都有不同的方法。 第五个学生是最难的一个，我没能有效地实施它。

第五个学生有一个秘密力量，他可以在相邻节点之间传送，因此它们之间的移动时间为0。 但是，要给那神秘力量充电，他需要通过两个边缘，而在他/她的旅程开始时，他（她）并没有那神秘力量。 与其他四个学生不同，他可以多次使用同一条边，因此在第一步中，他可能会走N_1->N_2和N_2->N_1来补充他/她的秘密力量。 (S)他不能储存他/她的秘密力量，必须在获得后立即使用。

第五个学生想知道到达山顶的最短时间。 一开始，他没有任何力量，所以他需要通过两个边缘来充电。

我尝试的方法是对 Dijkstra 算法的修改； 其中不是逐个节点移动，而是从一个节点计算所有三个可能的跳跃，只考虑前两次跳跃的权重。 它考虑了所有情况，例如去一个节点然后回来充电并跳过一个高权重的节点。 它确实有效，而且我确实得到了给定测试用例的所有正确答案，但它很慢。 我们有两秒的限制，现在我的算法需要大约 4 秒来处理具有 50 000 个节点和 100 000 个边的测试用例。

我猜问题是在到达邻居内，因为有 3 个嵌套的 for 循环来到达所有可能的 3 个跳跃邻居（同时也能够多次使用相同的边），这基本上使这个 O(n^3) （但我不太擅长大哦符号，所以我不确定它是否真的是这样。）

有没有人有任何想法可以使这个算法更有效，或者一个不那么慢的不同算法？

任何帮助表示赞赏！

如果有帮助，这里是代码。

long long int HelpStudents::fifthStudent() { 
auto start = std::chrono::system_clock::now();


set< pair<long long int,int> >setds;
vector<long long int> dist(totalNodes+15,std::numeric_limits<long long int>::max());
setds.insert(make_pair(0,1));
dist[1] = 0;
bool change = false;
int counter = 0;   //these variables were just for checking some things
int max_counter = 0;
int changed_summit = 0;
int operations_after_last_change = 0;


int w1;
int w2;
int db = 0;

vector<int> neighbors;
vector<int> neighbors2;
vector<int> neighbors3;
int u;

while(!setds.empty()){
    pair<long long int,int> tmp = *(setds.begin());
    setds.erase(setds.begin());
    u = tmp.second; //vertex label
    if(dist[u] > dist[summit_no]){
        continue;
    }
    if(!change){
        counter++;
    }else{
        counter = 0;  //debugging stuff
    }
    db++;
    //cout << db2 << endl;

    operations_after_last_change++;
    max_counter = max(counter,max_counter);
    //cout << "counter: " << counter <<endl;
    change = false;
    neighbors = adjacency_map[u];  //adjacency map holds a vector which contains the adjacent nodes for the given key

    //cout << "processing: " << "(" << tmp.first << ","<< tmp.second << ") " << endl;

    for(int nb : neighbors){
        w1 = getWeight(u,nb);  //this is one jump,
        //nb is neighboor
        neighbors2 = adjacency_map[nb];
        //cout << "\t->"  << nb  << endl;
        if( nb == summit_no){
            if(dist[nb] >  dist[u] + (w1)){

                auto t = setds.find(make_pair(dist[nb],nb));
                if(t != setds.end()){
                    setds.erase(t);
                }
                dist[nb] = dist[u] + (w1);
                change = true;
                changed_summit++;
                operations_after_last_change = 0;
                //cout << "changed summit to " << (dist[u] + (w1)) << endl;

                //continue;
            }
        }

        for(int nb2: neighbors2){  //second jump
            w2 = getWeight(nb,nb2);
            //cout << "\t\t->"  << nb2  << endl;
            if( nb2 == summit_no){
                if(dist[nb2] >  dist[u] + (w1+w2)){

                    auto t = setds.find(make_pair(dist[nb2],nb2));
                    if(t != setds.end()){
                        setds.erase(t);
                    }
                    dist[nb2] = dist[u] + (w1+w2);
                    change=true;
                    changed_summit++;
                    operations_after_last_change = 0;
                    //cout << "changed summit to " << (dist[u] + (w1+w2)) << endl;

                    //continue;
                }
            }
            neighbors3 = adjacency_map[nb2];

            for(int nbf: neighbors3){  //third jump, no weight
                //cout << "\t\t\t->"  << nbf;
                if(dist[nbf] >  dist[u] + (w1+w2)){


                    auto t = setds.find(make_pair(dist[nbf],nbf));
                    if(t != setds.end()) {
                        setds.erase(t);
                    }

                    change = true;
                    dist[nbf] = dist[u] + (w1+w2);
                    if(nbf == summit_no){
                        changed_summit++;
                        operations_after_last_change = 0;
                        //cout  << endl;
                    }else{
                        setds.insert(make_pair(dist[nbf],nbf));
                        //cout << "\t\t\t\t inserted ("<<dist[nbf]<<","<<nbf<<")"  << endl;
                    }

                    //cout << "changed " << nbf << " to " << (dist[u] + (w1+w2)) << ";  path: "<< u <<" -> "<<nb<<" -> "<<nb2 << " -> " <<nbf << endl;
                    //setds.insert(make_pair(dist[nbf],nbf));
                }else{
                    //cout  << endl;
                }
            }

        }





    }
}
auto end = std::chrono::system_clock::now();
std::chrono::duration<double> elapsed_seconds = end-start;
cout << "time passed: "<< elapsed_seconds.count() <<"   total loop: "<<db<< endl;
return dist[summit_no];

Answer 1

您制作（或更可能想象）一个新的有向图，其中包含一个节点，用于学生 5 可能处于的每个独特情况/状态——即原始图节点和电荷状态（0、1 或 2）的组合。 因为有 3 个电荷态，这个图的节点数是原始图的 3 倍。

然后你在这个新图上使用非常普通的 Dijkstra 算法。