C++ 在c+中生成随机连通图+；

所以我必须做一个无向图的生成函数。它必须生成一个随机连接的图。首先，我必须创建一个生成树，然后继续创建更多的边

因此，假设我必须制作一个密度为25%的

100vertice

图（我猜这是你用英语说的）。因此，我将不得不使1237.5边（让我们说1237）

现在我要这样做：

列出所有未使用的顶点

随机选择其中两个，连接它们，从列表中删除第一个

将下一个vertice连接到之前连接的vertice（第二个vertice，未从列表中删除）

执行此操作直到使用了所有顶点（空列表）

然后计算我要加多少（1237-100）

现在随机选择两个顶点，检查它们是否连接。如果没有，请连接它们。重复此步骤1137次

现在我有一个连通图。问题是我为此编写了C++代码。它按预期工作，但我必须测量一些操作（不是生成，f.e Prim算法）、密度=

{25,50,75,99}

和5个不同垂直量（f.e从500到5000）的时间。我已经运行了一个可以这样做的程序。它现在运行了大约半个小时。有没有一种方法可以优化我的代码（通过改变我所做的步骤）使其运行得更快？（我特别希望步骤

6

更方便，因为选择2个随机值并检查它们是否未连接（这意味着，迭代整个向量向量）不是很好，因为这样我可以再次随机选择相同的值，并且可以一直运行）

守则：

std::vector<std::vector<int>> undirected_graph::generate(int vertices, int d)
{
    float density = d / 100;
    std::vector<std::vector<int>> data;
    density = density / 100;
    int edges = floor(density * vertices * (vertices - 1) / 2);
    std::vector<int> v_vertices(vertices);
    std::iota(std::begin(v_vertices), std::end(v_vertices), 0);
    std::random_device r;
    std::default_random_engine e1(r()); 
    std::uniform_int_distribution<int> uniform_dist2(1, 100);
    int random = 0, random1;
    v_vertices.erase(v_vertices.begin());
    for (int i = 0; i < vertices - 1; i++) // spanning tree
    {   
        std::uniform_int_distribution<int> uniform_dist1(0, v_vertices.size() - 1);
        random1 = uniform_dist1(e1);
        data.push_back({ random , v_vertices[random1], uniform_dist2(e1) }); // random edge
        random = v_vertices[random1];
        v_vertices.erase(v_vertices.begin() + random1);     
    }
    // now the additional edges
    int needed = edges - vertices;
    std::uniform_int_distribution<int> uniform_dist1(0, vertices-1);
    std::uniform_int_distribution<int> uniform_dist3(0, vertices-1);
    for (int i = 0; i < needed;)
    {
        random = uniform_dist1(e1);
        random1 = uniform_dist3(e1);
        if (random != random1)
        {
            if (!multipleEdgeGenerate(data, random, random1)) // checking if edge like this exists
            {
                data.push_back({ random , v_vertices[random1], uniform_dist2(e1) });
                i++;
            }
        }
    }
    return data;
}

std:：向量无向图：：生成（int顶点，int d）
{
浮子密度=d/100；
std：：矢量数据；
密度=密度/100；
int边=地板（密度*顶点*（顶点-1）/2）；
std：：向量v_顶点（顶点）；
标准：：物联网（标准：：开始（v_顶点），标准：：结束（v_顶点），0）；
std：：随机_装置r；
std：：默认的随机引擎e1（r（））；
标准：统一分布统一分布2（1100）；
int random=0，random1；
擦除（v_顶点.begin（））；
对于（int i=0；i<顶点-1；i++）//生成树
{   
std:：uniform_int_distribute uniform_dist1（0，v_顶点.size（）-1）；
random1=均匀分布1（e1）；
data.push_back（{random，v_顶点[random1]，uniform_dist2（e1）}）；//随机边
随机=v_顶点[random1]；
擦除（v_顶点.begin（）+random1）；
}
//现在是附加边
int needed=边-顶点；
std：：均匀分布均匀分布1（0，顶点-1）；
std：：均匀分布均匀分布3（0，顶点-1）；
for（int i=0；i

需要查看代码使用记忆或不相交的数据集算法，如联合查找。实际上，我在执行Kruskals算法时实现了第二个算法。所以不是O（n），而是O（logn），对吗？