Connected Components: The LEDA Implementation

Connected Components:The LEDA Implementation

Melissa Patton 252a-ae

Smith College

December 12, 2000

Contents

• Connected Components

• LEDA’s implementation

– COMPONENTS()

• Structures it uses

• DFS()

• Its variables

• An explanation of the function

• Its time complexity

– code for calling COMPONENTS()• simple call of function

• possible code if called using LEDA window system

• Some websites that where helpful to me in my research

• Summary

Connected Components

An example of a connected components using gw_basic_graph_algorithm for LEDA

LEDA’s implementation of Connected Components

COMPONENTS()

int COMPONENTS(ugraph& G, node_array<int& compnum){ node v,w; list<node S; int count = 0;

node_array(bool) reached(G,false);

forall_nodes(v,G) if ( !reached[v] ) { S = DFS(G,v,reached); forall(w,S) compnum[w] = count; count++; } return count;}

Structures used by COMPONENT()

• Undirected graph– Graph G

• node array– Interger (compnum)– Boolean (reached)

• list – list of nodes S




DFS()

• DFS() is used by COMPONENTS() to determine which nodes are connected to each other.

• Each node in a single DFS() tree is given the same number.

• DFS is given the graph, a node to start from, and a flag ‘reached’ to mark visited nodes.

//------------------------------------------------------------------------------// Depth First Search //------------------------------------------------------------------------------

#include <LEDA/graph_alg.h>

static void dfs(node s, node_array<bool>& reached, list<node>& L){ L.append(s); reached[s] = true; node v; forall_adj_nodes(v,s) if ( !reached[v] ) dfs(v,reached,L); }

list<node> DFS(const graph&, node v, node_array<bool>& reached){ list<node> L; dfs(v,reached,L); return L;}

Leda code for DFS ( _dfs.c )

How COMPONENTS() works




• Receives an undirected graph G and an empty array of nodes compnum

• If it is possible to reach node v then set ever node that can reach it to the number in count, then increment count

• It returns the number of reachable nodes

COMPONENTS()- variables




• v is used to cycle through all the nodes in the graph.

• w works as an index. It is used to run giving all connected nodes the same label

• S is a list of nodes reachable from a node v

• count is used to label each node in the graph and later returns the number of connected components

COMPONENTS() variable cont.




• Reached is an array with an entry for each node in G. All of its entries are set to False.

COMPONENTS() -its actions




The steps of

this function


forall_nodes(v,G)

if ( !reached[v] ) {

S = DFS(G,v,reached);

forall(w,S) compnum[w] = count;

count++;

}

return count;

• Takes place on every node in the Graph

• If a node is currently unreachable, do a DFS and return a list of al the nodes it connects to

• Set every node that was reached to have the same label

• Increment the count

• COMPONENTS() returns the number components in the graph along with the labeled nodes


forall_nodes(v,G)




count++;

}

return count;


• If a node is currently unreachable, do a DFS and return a list of the numbers of the nodes it connects to





forall_nodes(v,G)




count++;

}

return count;



• Give every reachable node the same label (indicated by count)




forall_nodes(v,G)




count++;

}

return count;







forall_nodes(v,G)




count++;

}

return count;





• COMPONENTS() returns the number components in the graph along with the node labels

The time complexity of COMPONENTS()

• COMPONENTS() has the running time O(V+E)




1. Forall_nodes(v,G) iteraticely cycles through every node v in the Graph G

O(V)

2. DFS will eventually run through every edge in the graph

O(V+E)

3. Forall(w,S) will run on all the nodes in G, and only once on each node

O(V)

So the running time will be (3V +E) = O(V+E)

Simple code to call COMPONENTS()

#include <LEDA/graph_alg.h>#include <LEDA/array.h>

/* Initalize a graph */graph G;

/*---------------------MakeGraph-------------------------*/

void MakeGraph(){node first, second, third, four, five;int nnodes, nedges;

/*COMPONENTS() works on undirected graphs*/G.make_undirected();

/*Add objects to the graph*/first = G.new_node();second = G.new_node();third = G.new_node();four = G.new_node();five = G.new_node();

/*Add an edge between the following nodes*/G.new_edge(first, second); G.new_edge(third, five);

/*Get the number of nodes and edges*/nnodes = G.number_of_nodes();nedges = G.number_of_edges();cout<<"There are "<<nnodes<<" nodes and "<<nedges<<" edges"<<endl;

}/* end of MakeGraph */

/*---------------------CallComponents-------------------------*/

void CallComponents(){ int count; node_array<int> nodenumber(G);

/* call the function COMPONENTS() and receive the number of components */count = COMPONENTS(G,nodenumber);

cout<<"*|*****************************************************|*"<<endl;cout<<"*|-----------------------------------------------------|*"<<endl;cout<<"*| This graph has <-- "<<count<<" --> connected components |*"<<endl;cout<<"*|-----------------------------------------------------|*"<<endl;cout<<"*|*****************************************************|*"<<endl;

}/* end of CallComponent */

/*---------------------Main-------------------------*/

void main(){ cout<<"This program calls COMPONENTS() on this graph with this:"<<endl; cout<<"---------------------------"<<endl; cout<<"| [1]----[2] [3] [4] |"<<endl; cout<<"| | |"<<endl; cout<<"| [5] |"<<endl; cout<<"---------------------------"<<endl<<endl; /**** make the graph above ****/ MakeGraph();

/**** calling COMPONENTS*******/CallComponents();

}/* end of main */

/* End of comptest.cpp */

Code to call COMPONENTS() using the LEDA windows system

#include <LEDA/graph_alg.h>#include <LEDA/graphwin.h>#include <LEDA/array.h>

void Concomp(GraphWin& gw){graph& G = gw.get_graph();node_array<int> nodenumber(G);

COMPONENTS(G,nodenumber);

forall_nodes(v, G) {gw.set_color(v,nodenumber[v]); gw.set_user_label(v,string (” ”<<nodenumber[v])<<“ “); gw.set_label_type(v,user_label); }}

int main(){

gw.add_simple_call(Concomp,"CONNECTED COMPONENTS"); gw.display(window::center,window::center); window& W = gw.get_window(); gw.edit();return 0;}

gw.set_init_graph_handler(del_edge_handler);

gw.set_new_edge_handler(new_edge_handler);

gw.set_del_edge_handler(del_edge_handler);

gw.set_new_node_handler(new_node_handler);

gw.set_del_node_handler(del_node_handler);

gw.set_directed(false);

gw.set_node_shape(circle_node);

gw.set_node_label_type(user_label);

gw.set_node_width(20);

#ifdef BOOK

gw.set_node_color(white);

#endif

This code SHOULD work for windows, but is currently This code SHOULD work for windows, but is currently untesteduntested

Helpful sources in my research

• LEDA

– Manual

• Book

• online (http://www.cs.bgu.ac.il/~cgproj/LEDA/)

– graph_alg.h

– gw_basic_graph_algorithm.c

• http://www-pool.math.tu-berline.de/doc/LEDA/

• http://www.sedan.uni-osnabrueck.de/~sewi/leda.html

– extremely useful, but also written German

• http://www.altavista.com (babelfish)

• http://dictionaries.travlang.com/GermanEnglish/

– an German to English online dictionary

Summary

• LEDA implements connected components using the function COMPONENTS()

• This function takes an undirected graph and an array of nodes and returns the number of connected componets using the variable count.

• It iterates over a recursive DFS to find the connect components and number them

• COMPONENTS() has a complexity of O(V+E)• If you need to translate something on line …go to

altavista

Connected Components: The LEDA Implementation

Documents

Transcript of Connected Components: The LEDA Implementation