Generating a random connected graph in c++ - c++

Question

So I have to do make a generate function for a undirected graph. It has to make a randomly connected graph. First I have to create a spanning tree, then proceed with more edges.
So let's say I have to make a 100-vertice graph with a density (I guess that is how you say it in English) of let's say 25%. So I will have to make 1237.5 edges (let's say 1237).
Now I would do this like this:
Make a list of all non-used vertices
Randomly choose 2 of them, connect them, remove the first one from a list
Connect next vertice to the one connected before (the second one, not erased from a list)
Do this until we have all vertices used (empty list)
Then calculate how many I have to add (1237-100)
Now randomly choose 2 vertices, check if they are connected. If not, connect them. Repeat this 1137 times
Now I have a connected graph. The problem is I wrote C++ code for this. It works as intended, but I have to measure the times for some operations (not generation, f.e Prim's algorithm), for densities = {25, 50, 75, 99} and for 5 different vertice quantities (f.e from 500 to 5000). I've run a program which would do so. It's running for like a half an hour now. Is there a way so I can optimize my code (by changing steps I did) to make it go faster? (I would especially like step 6 to be more convenient, cuz picking 2 random values and checking if they are not connected (that means, iterating through whole vector of vectors) is not really good, cuz then I can randomly again pick the same values and it can go 4ever)
The code:
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;
}