Weighted graphs
Upcoming SlideShare
Loading in...5
×
 

Weighted graphs

on

  • 1,619 views

 

Statistics

Views

Total Views
1,619
Views on SlideShare
1,619
Embed Views
0

Actions

Likes
1
Downloads
57
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Weighted graphs Weighted graphs Presentation Transcript

  • Weighted graphs
    • Example Consider the following graph, where nodes represent cities, and edges show if there is a direct flight between each pair of cities.
    • CHG
    • SF HTD
    • OAK
    • ATL
    • LA
    • SD
    • V = {SF, OAK, CHG, HTD, ATL, LA, SD}
    • E = {{SF, HTD}, {SF, CHG}, {SF, LA}, {SF, SD}, {SD, OAK}, {CHG, LA},
    • {LA, OAK}, {LA, ATL}, {LA, SD}, {ATL, HTD}, {SD, ATL}}
             
    • Problem formulation: find the "best" path between two vertices v 1 , v 2  V
    • in graph G = (V, E). Depending on what the "best" path means, we have 2
    • types of problems:
    • The minimum spanning tree problem , where the "best" path means the "lowest-cost" path.
    • The shortest path problem , where the "best" path means the "shortest" path.
    • Note that here edge weights are not necessarily Euclidean distances. Example:
      • 2985 > 1421 + 310, not the case
      • here, however.
                
  • The Weighted Graph ADT
    • Definition A weighted graph, G, is a triple (V, E, W), where (V, E) is a graph,
    • and W is a function from E into Z + , where Z + is a set of all positive integers.
    • That is, W : E  Z + .
    • Additional operations (methods) on weighted graphs:
    • addEdge(v1, v2, weight) Returns G with new edge v1v2 added
    • removeEdge(v1, v2, weight) Returns G with edge v1v2 removed
    • edgeWeight(v1, v2) Returns the weight of edge v1v2
  • The minimum spanning tree problem
    • Definition. A minimum spanning tree of a weighted graph is a collection of
    • edges connecting all of the vertices such that the sum of the weights of the
    • edges is at least as small as the sum of the weights of any other collection of
    • edges connecting all of the vertices.
    • Example Consider the following graph
                           a  b  m  l  k  j  i  h  d  e  f  g  c
    • Property of a minimum spanning tree (MST). Given any division of the
    • vertices of a graph into two sets, the minimum spanning tree contains the
    • shortest of the edges connecting a vertex in one of the sets to a vertex in the
    • other set.
    • This property tells us that we can start building the MST by selecting any
    • vertex, and always taking next the vertex which is closest to the vertices
    • already on the tree. If more than one "closest" vertex exists, then we can take
    • anyone of these vertices (therefore, a MST of a graph is not unique).
    • Example: Let V1 = {a, b, c, d} , V2 = {e, f, …, m}. Then, the MSP must contain
    • edge fd , because W(fd) = 1.
    • Note that V2 consists of two types of vertices:
    • Fringe vertices, which are adjacent to V1.
    • Unseen vertices, which are not adjacent to V1.
    • Extended example to be distributed in class!
  • Generation of a MST : the Prim's algorithm
    • The idea : Select an arbitrary vertex to start the tree. While there are fringe
    • vertices remaining, select an edge of minimum weight between a tree vertex
    • and a fringe vertex, and add the selected edge and fringe vertex to the tree.
    • Algorithm MST (start, T)
    • Included[start] = true // Assume Boolean array Included tells,
    • for (node = 2) to NumberOfNodes // which vertices are already in the MST.
    • Included[node] = false
    • for (node = 1) to (NumberOf Nodes - 1) {
    • edge = FindMinEdge () // Requires a loop over all of the nodes.
    • Included[edge.IncidentNode()] = true
    • AddEdge(edge, MST) }
    • Efficiency result : Prim's algorithm for generating a MST is O(N^2), where N is
    • the number of nodes in the tree. Since the number of edges is not important it
    • is good for dense graphs.
  • Generation of a MST : the Kruskal's algorithm
    • The idea: Add edges one at a time selecting at each step the shortest edge
    • that does not form a cycle.
    • Assume that vertices of a MST are initially viewed as one element sets,
    • and edges are arranged in a priority queue according to their weights. Then,
    • we remove edges from the priority queue in order of increasing weights and
    • check if the vertices incident to that edge are already connected. If not, we
    • connect them and this way the disconnected components gradually evolve into
    • a tree -- the minimum spanning tree.
    • Extended example to be distributed in class!
    • Efficiency result: Assume that
      • The priority queue is implemented as a heap.
      • The minimum spanning tree is implemented as a weight-balanced tree.
      • The graph is implemented by means of adjacency lists.
      • Then:
      • The initial formation of the priority queue of edges is O(NumberOfEdges*log(NumberOfEdges)) operation.
      • The phase of removing edges from the queue and performing one or two operations requires also O(NumberOfEdges*log(NumberOfEdges)) time.
      • Therefore, the total efficiency of the Kruskal's algorithm is O(NumberOfEdges*log(NumberOfEdges)).
  • The shortest-path problem
    • Definition. The weight, or length, of a path v 0 , v 1 , v 2 , …, v k in weighted graph
    • k-1
    • G = (V, E, W) is  W(v i v i+1 ). Path v 0 , v 1 , v 2 , …, v k is the shortest path from
    • i = 0
    • v 0 to v k if there is no other path from v 0 to v k with lower weight.
    • Definition. The distance from vertex x to vertex y (x, y  V), denoted as
    • d(x,y) is the weight of the shortest path from x to y .
    • The problem: Given x  V, we want to find the shortest paths from x to any
    • other vertex in V in order of increasing distance from x. Consider the following
    • two cases:
    • All weights are "1". Therefore, the problem becomes finding a path containing the minimum number of edges. To solve this problem, we can use the breadth-first search algorithm.
    • If edge weights are different, we can use the Dijkstra's shortest path algorithm.
  • The shortest-path problem: Dijkstra's algorithm
    • Extended example to be distributed in class!
    • To implement Dijkstra's algorithm we need the following data structures:
    • An integer array, distance , of NumberOfNodes size (assuming that edge weights are integers).
    • A Node array, path , of NumberOfNodes size.
    • A Boolean array, included , of NumberOfNodes size.
    • Given the start node, the initialization of these arrays is the following:
    • included[start] := true, all other entries in included initialized to false.
    • 0, if node = start
    • distance[node] := EdgeWeight(start, node)
    •  , if there does not exist a direct edge between
    • start and node
    • path[node] := start, if there exists an edge between start and node
    • undefined, otherwise.
  • Dijkstra's algorithm (contd.)
    • The iteration phase:
    • repeat
    • find the node, j, that is at the minimum distance from start among those
    • not yet included and make included[j] := true
    • for each node, r, not yet included
    • if r is connected by an edge to j, then
    • if distance[j] + EdgeWeight(j, r) < distance[r] then
    • distance[r] := distance[j] + EdgeWeight(j, r)
    • path[r] := j // path contains the immediate predecessor of each node
    • until included[destination_node] := true
    • Efficiency result. If EdgeWeight operation is O(1), then Dijkstra's algorithm is
    • O(NumberOfNodes^2).