Algorithm 类Djikstra算法的优化

我试图设计一个简单的算法，使用类似Dijkstra的算法访问一个图，但是当这个图非常大（超过75000个节点）时，它似乎没有得到优化

这是我的密码

class lamp {

    int id;
    bool visited = false;
    list<lamp*> connected;
    int distance = INT_MAX;

public:
    void setVisited() {
        visited = true;
    }

    bool isVisited() {
        return visited;
    }

    void addCOnnected(lamp* l) {
        connected.push_back(l);
    }

    list<lamp*> getConnected() {
        return connected;
    }

    void resetVisited() {
        visited = false;
    }

    void setId(int i) {
        id = i;
    }

    void setDistance(int d) {
        distance = distance < d ? distance : d;
    }

    int getDistance() {
        return distance;
    }

};

void resetVisited(lamp* l, int n) {
    for (int i = 0; i < n; i++) {
        l[i].resetVisited();
    }
}

void evaluateDistance(lamp& l) {

    queue<lamp*> lampQueue;
    lampQueue.push(&l);
    l.setDistance(1);

    while (lampQueue.size() > 0) {

        lamp* current = lampQueue.front();
        lampQueue.pop();
        int currentDistance = current->getDistance();

        for (lamp* conn : current->getConnected()) {
            if (!(conn->isVisited())) {
                lampQueue.push(conn);
                conn->setVisited();
                conn->setDistance(currentDistance + 1);
            }
        }
    };
}

class灯{
int-id；
布尔=假；
连接的列表；
int距离=int_最大值；
公众：
void setvisted（）{
访问=真实；
}
布尔·伊斯特（）{
回访；
}
已连接的灯（灯*l）{
已连接。向后推（l）；
}
列表getConnected（）{
回流连接；
}
作废{
访问=假；
}
void setId（inti）{
id=i；
}
无效设置距离（int d）{
距离=距离0）{
lamp*电流=lampQueue.front（）；
lampQueue.pop（）；
int currentDistance=当前->获取距离（）；
用于（灯*连接：当前->连接（）{
如果（！（连接->已访问（））{
灯队。推（康涅狄格州）；
conn->setvisted（）；
连接->设置距离（当前距离+1）；
}
}
};
}

---

奇怪的设置距离是因为从不同的灯开始，对任何灯的距离进行多次评估，并且在每个循环中保留最低值。

这看起来应该具有复杂性O（边缘数）。图中有多少条边？我希望它能够处理每秒大约2000万次的数据。如果性能要低得多，我建议使用探查器检查时间是否花在了一些意想不到的地方（例如内存管理、复制数据结构、推到列表末尾），你说的不优化是什么意思？随着节点数量的增加，距离之和在开始时会大幅下降，然后在结束时几乎不会下降？在竞争中，单次测试似乎花费了太多时间。我将尝试获得有关所涉及的边/顶点数量的提示。