graph_t kruskal(graph_t graph) {
graph_t result = graph_empty(graph_vertices_count(graph));
unsigned int L, R, num_edges = graph_edges_count(graph);
vertex_t l = NULL, r = NULL;
pqueue_t Q = pqueue_empty(num_edges);
union_find_t C = union_find_create(graph_vertices_count(graph));
edge_t E = NULL, *edges = graph_edges(graph);
for (unsigned int i = 0; i < num_edges; i++) {
pqueue_enqueue(Q, edges[i]);
}
free(edges);
edges = NULL;
while (!pqueue_is_empty(Q) && union_find_count(C) > 1) {
E = edge_copy(pqueue_fst(Q));
l = edge_left_vertex(E);
r = edge_right_vertex(E);
L = union_find_find(C, vertex_label(l));
R = union_find_find(C, vertex_label(r));
if (L != R) {
union_find_union(C, L, R);
E = edge_set_primary(E, true);
} else {
E = edge_set_primary(E, false);
}
result = graph_add_edge(result, E);
pqueue_dequeue(Q);
}
while (!pqueue_is_empty(Q)) {
E = edge_copy(pqueue_fst(Q));
pqueue_dequeue(Q);
E = edge_set_primary(E, false);
result = graph_add_edge(result, E);
}
Q = pqueue_destroy(Q);
C = union_find_destroy(C);
return result;
}
void Graph::sort_edges(std::string order) {
if (order == HILBERT) {
VidType nv = (VidType)get_n_vertices();
LOG(INFO) << " Graph::nv = " << nv;
VidType max_n = 2;
while ( nv >>=1 ) {
max_n <<= 1;
}
LOG(INFO) << " HilbertOrder::max_n = " << max_n;
HilbertOrder::set_maxn(max_n);
//HilbertOrder::set_maxn(MAX_BIT);
//std::sort(edges.begin(), edges.end(), HilbertOrder());
// get permutation
size_t ne = edges.size();
std::vector<int64_t> d(ne);
for(size_t i = 0;i < ne;i ++) {
d[i] = HilbertOrder::get_d(edges[i].src, edges[i].dst);
}
std::vector<size_t> perm(ne);
for(size_t i = 0;i < ne;i ++) {
perm[i] = i;
}
std::sort(perm.begin(), perm.end(),
[&](const size_t & A, const size_t &B) {
return d[A] < d[B];
});
d.resize(0);
// sort
size_t flag = 0;
size_t cnt = 0;
std::vector<Edge> edge_copy(edges);
for(size_t i = 0;i < ne;i ++) {
edges[i] = edge_copy[perm[i]];
}
edge_copy.resize(0);
} else if (order == DST ) {
graph_t kruskal(graph_t graph) {
/* Computes a MST of the given graph.
*
* This function returns a copy of the input graph in which
* only the edges of the MST are marked as primary. The
* remaining edges are marked as secondary.
*
* The input graph does not change.
*
*/
graph_t mst;
union_find_t uf;
pqueue_t pq;
edge_t *edges;
edge_t e;
unsigned int left, right, n, m;
/* Inicialización */
n = graph_vertices_count(graph);
m = graph_edges_count(graph);
mst = graph_empty(n);
uf = union_find_create(n);
pq = pqueue_empty(m);
/* Llenar `pq` */
edges = graph_edges(graph);
for (unsigned int j = 0; j < m; j++) {
pqueue_enqueue(pq, edges[j]);
}
/* Ahora las aristas están en `pq` */
free(edges);
edges = NULL;
/* Principal */
while (!pqueue_is_empty(pq) && union_find_count(uf) > 1) {
e = edge_copy(pqueue_fst(pq));
left = vertex_label(edge_left_vertex(e));
right = vertex_label(edge_right_vertex(e));
left = union_find_find(uf, left);
right = union_find_find(uf, right);
if (!union_find_connected(uf, left, right)) {
e = edge_set_primary(e, true);
union_find_union(uf, left, right);
} else {
e = edge_set_primary(e, false);
}
mst = graph_add_edge(mst, e);
pqueue_dequeue(pq);
}
/* Agregar aristas restantes como secundarias */
while (!pqueue_is_empty(pq)) {
e = edge_copy(pqueue_fst(pq));
e = edge_set_primary(e, false);
mst = graph_add_edge(mst, e);
pqueue_dequeue(pq);
}
/* Destroy */
uf = union_find_destroy(uf);
pq = pqueue_destroy(pq);
return (mst);
}
