Search the web for the [Koenigsberg bridge 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:
Consider the following diagrams:
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.
The question about figure 1 is equivalent to the following question:
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.
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.