ClassS04CS141/Notes 04 12

Top | ClassS04CS141 | recent changes | Preferences

Introduction to graphs

Started with Koenigsberg bridge problem (search the web for it...), and the following problem:

In the figure below, it is possible to trace a path with a pencil so that the pencil never leaves the paper, and each line segment in the drawing is crossed exactly once:

upload:s04141_ripleys3.tiff ===> upload:s04141_ripleys2.tiff


Is this possible in this next figure?

figure 1: upload:s04141_ripleys.tiff

Consider the following diagrams:

figure 2: upload:s04141_ripleys4.tiff

figure 3: upload:s04141_ripleys5.tiff

The figure above is a drawing of a graph.

The letters represent nodes (also called vertices) of the graph. The lines connecting pairs of letters represent edges.


Graph terminology:


The question about figure 1 is equivalent to the following question:

Does the graph in figure 3 have a path that uses each edge exactly once?


Depth-first search (DFS)

Depth-first search is a "backtracking" method of exploring a graph. It searches from vertex to vertex, backtracking when it encounters vertices that have already been discovered. Here is pseudo-code:

DFS(graph G, vertex v)
   Array<int> visited(0);
   DFS1(G, v, visited);
end

DFS1(graph G, vertex v, Array<int>& visited)
   if (visited[v] == 1)  return
   visited[v] = 1
   for each neighbor w of v do
      DFS1(G, w, visited)
end

We demonstrated DFS on an example. DFS on classifies the edge into two kinds:

The tree edges form a tree (essentially a recursion tree for the DFS). For any back edge (u,v), either u is a descendant of v in the tree or vice versa.

In a graph with N vertices and M edges, the running time for DFS is O(N+M), because the work done for each vertex is proportional to the degree of the vertex, and the sum of the vertex degrees is 2M.

Breadth-first search

DFS is called "depth first" because it descends into the graph as quickly as possible.

Breadth-search first, in contrast, explores nodes by following a "wave front". It explores in order of their distance from the start vertex.

BFS(graph G, vertex v)

   FIFO_Queue Q;
   Array<int> distance(-1);
   
   distance[v] = 0;
   insert vertex v into the queue Q.

   while (Q is not empty)
      take the next vertex W off the front of the queue Q
      for each neighbor X of W do
         if (distance[X] == -1) then
            distance[X] = distance[W] + 1
            add vertex X to the tail of the queue Q
end

We demonstrated BFS on an example, and noted that it ran in time O(N+M) on any graph with N vertices and M edges.


Top | ClassS04CS141 | recent changes | Preferences
This page is read-only | View other revisions
Last edited April 12, 2004 2:50 pm by Neal (diff)
Search: