• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Weighted graphs
 

Weighted graphs

on

  • 1,462 views

 

Statistics

Views

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

Actions

Likes
1
Downloads
53
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).