int igraph_biconnected_components(const igraph_t *graph,
igraph_integer_t *no,
igraph_vector_ptr_t *tree_edges,
igraph_vector_ptr_t *component_edges,
igraph_vector_ptr_t *components,
igraph_vector_t *articulation_points) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_long_t nextptr;
igraph_vector_long_t num, low;
igraph_vector_bool_t found;
igraph_vector_int_t *adjedges;
igraph_stack_t path;
igraph_vector_t edgestack;
igraph_inclist_t inclist;
long int i, counter, rootdfs=0;
igraph_vector_long_t vertex_added;
long int comps=0;
igraph_vector_ptr_t *mycomponents=components, vcomponents;
IGRAPH_CHECK(igraph_vector_long_init(&nextptr, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &nextptr);
IGRAPH_CHECK(igraph_vector_long_init(&num, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &num);
IGRAPH_CHECK(igraph_vector_long_init(&low, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &low);
IGRAPH_CHECK(igraph_vector_bool_init(&found, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &found);
IGRAPH_CHECK(igraph_stack_init(&path, 100));
IGRAPH_FINALLY(igraph_stack_destroy, &path);
IGRAPH_VECTOR_INIT_FINALLY(&edgestack, 0);
IGRAPH_CHECK(igraph_vector_reserve(&edgestack, 100));
IGRAPH_CHECK(igraph_inclist_init(graph, &inclist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_inclist_destroy, &inclist);
IGRAPH_CHECK(igraph_vector_long_init(&vertex_added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &vertex_added);
if (no) {
*no=0;
}
if (tree_edges) {
igraph_vector_ptr_clear(tree_edges);
}
if (components) {
igraph_vector_ptr_clear(components);
}
if (component_edges) {
igraph_vector_ptr_clear(component_edges);
}
if (articulation_points) {
igraph_vector_clear(articulation_points);
}
if (component_edges && !components) {
mycomponents=&vcomponents;
IGRAPH_CHECK(igraph_vector_ptr_init(mycomponents, 0));
IGRAPH_FINALLY(igraph_i_free_vectorlist, mycomponents);
}
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(low)[i] != 0) { continue; } /* already visited */
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_stack_push(&path, i));
counter=1;
rootdfs=0;
VECTOR(low)[i]=VECTOR(num)[i]=counter++;
while (!igraph_stack_empty(&path)) {
long int n;
long int act=(long int) igraph_stack_top(&path);
long int actnext=VECTOR(nextptr)[act];
adjedges=igraph_inclist_get(&inclist, act);
n=igraph_vector_int_size(adjedges);
if (actnext < n) {
/* Step down (maybe) */
long int edge=(long int) VECTOR(*adjedges)[actnext];
long int nei=IGRAPH_OTHER(graph, edge, act);
if (VECTOR(low)[nei] == 0) {
if (act==i) { rootdfs++; }
IGRAPH_CHECK(igraph_vector_push_back(&edgestack, edge));
IGRAPH_CHECK(igraph_stack_push(&path, nei));
VECTOR(low)[nei] = VECTOR(num)[nei]=counter++;
} else {
/* Update low value if needed */
if (VECTOR(num)[nei] < VECTOR(low)[act]) {
VECTOR(low)[act]=VECTOR(num)[nei];
}
}
VECTOR(nextptr)[act] += 1;
} else {
/* Step up */
igraph_stack_pop(&path);
if (!igraph_stack_empty(&path)) {
long int prev=(long int) igraph_stack_top(&path);
/* Update LOW value if needed */
if (VECTOR(low)[act] < VECTOR(low)[prev]) {
VECTOR(low)[prev] = VECTOR(low)[act];
}
/* Check for articulation point */
if (VECTOR(low)[act] >= VECTOR(num)[prev]) {
if (articulation_points && !VECTOR(found)[prev]
&& prev != i /* the root */) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, prev));
VECTOR(found)[prev] = 1;
}
if (no) { *no += 1; }
/*------------------------------------*/
/* Record the biconnected component just found */
if (tree_edges || mycomponents) {
igraph_vector_t *v = 0, *v2 = 0;
comps++;
if (tree_edges) {
v=igraph_Calloc(1, igraph_vector_t);
if (!v) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(v, 0));
IGRAPH_FINALLY(igraph_vector_destroy, v);
}
if (mycomponents) {
v2=igraph_Calloc(1, igraph_vector_t);
if (!v2) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(v2, 0));
IGRAPH_FINALLY(igraph_vector_destroy, v2);
}
while (!igraph_vector_empty(&edgestack)) {
long int e=(long int) igraph_vector_pop_back(&edgestack);
long int from=IGRAPH_FROM(graph,e);
long int to=IGRAPH_TO(graph,e);
if (tree_edges) {
IGRAPH_CHECK(igraph_vector_push_back(v, e));
}
if (mycomponents) {
if (VECTOR(vertex_added)[from] != comps) {
VECTOR(vertex_added)[from] = comps;
IGRAPH_CHECK(igraph_vector_push_back(v2, from));
}
if (VECTOR(vertex_added)[to] != comps) {
VECTOR(vertex_added)[to] = comps;
IGRAPH_CHECK(igraph_vector_push_back(v2, to));
}
}
if (from==prev || to==prev) {
break;
}
}
if (mycomponents) {
IGRAPH_CHECK(igraph_vector_ptr_push_back(mycomponents, v2));
IGRAPH_FINALLY_CLEAN(1);
}
if (tree_edges) {
IGRAPH_CHECK(igraph_vector_ptr_push_back(tree_edges, v));
IGRAPH_FINALLY_CLEAN(1);
}
if (component_edges) {
igraph_vector_t *nodes=VECTOR(*mycomponents)[comps-1];
igraph_vector_t *vv=igraph_Calloc(1, igraph_vector_t);
long int ii, no_vert=igraph_vector_size(nodes);
if (!vv) { IGRAPH_ERROR("Out of memory", IGRAPH_ENOMEM); }
IGRAPH_CHECK(igraph_vector_init(vv, 0));
IGRAPH_FINALLY(igraph_vector_destroy, vv);
for (ii=0; ii<no_vert; ii++) {
long int vert=(long int) VECTOR(*nodes)[ii];
igraph_vector_int_t *edges=igraph_inclist_get(&inclist,
vert);
long int j, nn=igraph_vector_int_size(edges);
for (j=0; j<nn; j++) {
long int e=(long int) VECTOR(*edges)[j];
long int nei=IGRAPH_OTHER(graph, e, vert);
if (VECTOR(vertex_added)[nei] == comps && nei<vert) {
IGRAPH_CHECK(igraph_vector_push_back(vv, e));
}
}
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(component_edges, vv));
IGRAPH_FINALLY_CLEAN(1);
}
} /* record component if requested */
/*------------------------------------*/
}
} /* !igraph_stack_empty(&path) */
}
} /* !igraph_stack_empty(&path) */
if (articulation_points && rootdfs >= 2) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, i));
}
} /* i < no_of_nodes */
if (mycomponents != components) {
igraph_i_free_vectorlist(mycomponents);
IGRAPH_FINALLY_CLEAN(1);
}
igraph_vector_long_destroy(&vertex_added);
igraph_inclist_destroy(&inclist);
igraph_vector_destroy(&edgestack);
igraph_stack_destroy(&path);
igraph_vector_bool_destroy(&found);
igraph_vector_long_destroy(&low);
igraph_vector_long_destroy(&num);
igraph_vector_long_destroy(&nextptr);
IGRAPH_FINALLY_CLEAN(8);
return 0;
}
int dfs_d(const igraph_t *graph, igraph_integer_t root,
igraph_neimode_t mode, igraph_bool_t unreachable,
igraph_vector_t *order,
igraph_vector_t *order_out, igraph_vector_t *father,
igraph_vector_t *dist, igraph_dfshandler_t *in_callback,
igraph_dfshandler_t *out_callback,
void *extra) {
long int no_of_nodes=igraph_vcount(graph);
igraph_lazy_adjlist_t adjlist;
igraph_stack_t stack;
igraph_vector_char_t added;
igraph_vector_long_t nptr;
long int actroot;
long int act_rank=0;
long int rank_out=0;
long int act_dist=0;
if (root < 0 || root >= no_of_nodes) {
IGRAPH_ERROR("Invalid root vertex for DFS", IGRAPH_EINVAL);
}
if (mode != IGRAPH_OUT && mode != IGRAPH_IN &&
mode != IGRAPH_ALL) {
IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
}
if (!igraph_is_directed(graph)) { mode=IGRAPH_ALL; }
IGRAPH_CHECK(igraph_vector_char_init(&added, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_char_destroy, &added);
IGRAPH_CHECK(igraph_stack_init(&stack, 100));
IGRAPH_FINALLY(igraph_stack_destroy, &stack);
IGRAPH_CHECK(igraph_lazy_adjlist_init(graph, &adjlist, mode, /*simplify=*/ 0));
IGRAPH_FINALLY(igraph_lazy_adjlist_destroy, &adjlist);
IGRAPH_CHECK(igraph_vector_long_init(&nptr, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &nptr);
# define FREE_ALL() do { \
igraph_vector_long_destroy(&nptr); \
igraph_lazy_adjlist_destroy(&adjlist); \
igraph_stack_destroy(&stack); \
igraph_vector_char_destroy(&added); \
IGRAPH_FINALLY_CLEAN(4); } while (0)
/* Resize result vectors and fill them with IGRAPH_NAN */
# define VINIT(v) if (v) { \
igraph_vector_resize(v, no_of_nodes); \
igraph_vector_fill(v, IGRAPH_NAN); }
VINIT(order);
VINIT(order_out);
VINIT(father);
VINIT(dist);
# undef VINIT
IGRAPH_CHECK(igraph_stack_push(&stack, root));
VECTOR(added)[(long int)root] = 1;
if (father) { VECTOR(*father)[(long int)root] = -1; }
if (order) { VECTOR(*order)[act_rank++] = root; }
if (dist) { VECTOR(*dist)[(long int)root] = 0; }
if (in_callback) {
igraph_bool_t terminate=in_callback(graph, root, 0, extra);
if (terminate) { FREE_ALL(); return 0; }
}
for (actroot=0; actroot<no_of_nodes; actroot++) {
/* 'root' first, then all other vertices */
if (igraph_stack_empty(&stack)) {
if (!unreachable) { break; }
if (VECTOR(added)[actroot]) { continue; }
IGRAPH_CHECK(igraph_stack_push(&stack, actroot));
VECTOR(added)[actroot] = 1;
if (father) { VECTOR(*father)[actroot] = -1; }
if (order) { VECTOR(*order)[act_rank++] = actroot; }
if (dist) { VECTOR(*dist)[actroot] = 0; }
if (in_callback) {
igraph_bool_t terminate=in_callback(graph, (igraph_integer_t) actroot,
0, extra);
if (terminate) { FREE_ALL(); return 0; }
}
}
while (!igraph_stack_empty(&stack)) {
long int actvect=(long int) igraph_stack_top(&stack);
igraph_vector_t *neis=igraph_lazy_adjlist_get(&adjlist,
(igraph_integer_t) actvect);
long int n=igraph_vector_size(neis);
long int *ptr=igraph_vector_long_e_ptr(&nptr, actvect);
igraph_vector_shuffle(neis);
igraph_vector_print(neis);
/* Search for a neighbor that was not yet visited */
igraph_bool_t any=0;
long int nei;
while (!any && (*ptr) <n) {
nei=(long int) VECTOR(*neis)[(*ptr)];
any=!VECTOR(added)[nei];
(*ptr) ++;
}
if (any) {
/* There is such a neighbor, add it */
IGRAPH_CHECK(igraph_stack_push(&stack, nei));
VECTOR(added)[nei] = 1;
if (father) { VECTOR(*father)[ nei ] = actvect; }
if (order) { VECTOR(*order)[act_rank++] = nei; }
act_dist++;
if (dist) { VECTOR(*dist)[nei] = act_dist; }
if (in_callback) {
igraph_bool_t terminate=in_callback(graph, (igraph_integer_t) nei,
(igraph_integer_t) act_dist,
extra);
if (terminate) { FREE_ALL(); return 0; }
}
} else {
/* There is no such neighbor, finished with the subtree */
igraph_stack_pop(&stack);
if (order_out) { VECTOR(*order_out)[rank_out++] = actvect; }
act_dist--;
if (out_callback) {
igraph_bool_t terminate=out_callback(graph, (igraph_integer_t)
actvect, (igraph_integer_t)
act_dist, extra);
if (terminate) { FREE_ALL(); return 0; }
}
}
}
}
FREE_ALL();
# undef FREE_ALL
return 0;
}
int igraph_biconnected_components(const igraph_t *graph,
igraph_integer_t *no,
igraph_vector_ptr_t *components,
igraph_vector_t *articulation_points) {
long int no_of_nodes=igraph_vcount(graph);
igraph_vector_long_t nextptr;
igraph_vector_long_t num, low;
igraph_vector_bool_t found;
igraph_vector_t *adjedges;
igraph_stack_t path;
igraph_vector_t edgestack;
igraph_adjedgelist_t adjedgelist;
long int i, counter, rootdfs=0;
IGRAPH_CHECK(igraph_vector_long_init(&nextptr, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &nextptr);
IGRAPH_CHECK(igraph_vector_long_init(&num, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &num);
IGRAPH_CHECK(igraph_vector_long_init(&low, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_long_destroy, &low);
IGRAPH_CHECK(igraph_vector_bool_init(&found, no_of_nodes));
IGRAPH_FINALLY(igraph_vector_bool_destroy, &found);
IGRAPH_CHECK(igraph_stack_init(&path, 100));
IGRAPH_FINALLY(igraph_stack_destroy, &path);
IGRAPH_VECTOR_INIT_FINALLY(&edgestack, 0);
IGRAPH_CHECK(igraph_vector_reserve(&edgestack, 100));
IGRAPH_CHECK(igraph_adjedgelist_init(graph, &adjedgelist, IGRAPH_ALL));
IGRAPH_FINALLY(igraph_adjedgelist_destroy, &adjedgelist);
if (no) {
*no=0;
}
if (components) {
igraph_vector_ptr_clear(components);
}
if (articulation_points) {
igraph_vector_clear(articulation_points);
}
for (i=0; i<no_of_nodes; i++) {
if (VECTOR(low)[i] != 0) {
continue; /* already visited */
}
IGRAPH_ALLOW_INTERRUPTION();
IGRAPH_CHECK(igraph_stack_push(&path, i));
counter=1;
rootdfs=0;
VECTOR(low)[i]=VECTOR(num)[i]=counter++;
while (!igraph_stack_empty(&path)) {
long int n;
long int act=igraph_stack_top(&path);
long int actnext=VECTOR(nextptr)[act];
adjedges=igraph_adjedgelist_get(&adjedgelist, act);
n=igraph_vector_size(adjedges);
if (actnext < n) {
/* Step down (maybe) */
long int edge=VECTOR(*adjedges)[actnext];
long int nei=IGRAPH_OTHER(graph, edge, act);
if (VECTOR(low)[nei] == 0) {
if (act==i) {
rootdfs++;
}
IGRAPH_CHECK(igraph_vector_push_back(&edgestack, edge));
IGRAPH_CHECK(igraph_stack_push(&path, nei));
VECTOR(low)[nei] = VECTOR(num)[nei]=counter++;
} else {
/* Update low value if needed */
if (VECTOR(num)[nei] < VECTOR(low)[act]) {
VECTOR(low)[act]=VECTOR(num)[nei];
}
}
VECTOR(nextptr)[act] += 1;
} else {
/* Step up */
igraph_stack_pop(&path);
if (!igraph_stack_empty(&path)) {
long int prev=igraph_stack_top(&path);
/* Update LOW value if needed */
if (VECTOR(low)[act] < VECTOR(low)[prev]) {
VECTOR(low)[prev] = VECTOR(low)[act];
}
/* Check for articulation point */
if (VECTOR(low)[act] >= VECTOR(num)[prev]) {
if (articulation_points && !VECTOR(found)[prev]
&& prev != i /* the root */) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, prev));
VECTOR(found)[prev] = 1;
}
if (no) {
*no += 1;
}
if (components) {
igraph_vector_t *v=igraph_Calloc(1, igraph_vector_t);
IGRAPH_CHECK(igraph_vector_init(v, 0));
while (!igraph_vector_empty(&edgestack)) {
long int e=igraph_vector_pop_back(&edgestack);
IGRAPH_CHECK(igraph_vector_push_back(v, e));
if (IGRAPH_FROM(graph,e)==prev || IGRAPH_TO(graph,e)==prev) {
break;
}
}
IGRAPH_CHECK(igraph_vector_ptr_push_back(components, v));
}
}
} /* !igraph_stack_empty(&path) */
}
} /* !igraph_stack_empty(&path) */
if (articulation_points && rootdfs >= 2) {
IGRAPH_CHECK(igraph_vector_push_back(articulation_points, i));
}
} /* i < no_of_nodes */
igraph_adjedgelist_destroy(&adjedgelist);
igraph_vector_destroy(&edgestack);
igraph_stack_destroy(&path);
igraph_vector_bool_destroy(&found);
igraph_vector_long_destroy(&low);
igraph_vector_long_destroy(&num);
igraph_vector_long_destroy(&nextptr);
IGRAPH_FINALLY_CLEAN(7);
return 0;
}
