Graph Algorithms

Typical Applications of Graph:

• Transportation maps
• Communication networks
• Anything involves a set of objects and their connectivity

Graph ADT

• A set V of vertices (nodes) representing a set of objects
• A multi-set E of edges (arcs), pairs of vertices from V, Representing connections or relationships between pairs of objects represented by the vertices from V

Definition

• Edge: <u, v>, where u, v is in V; u and v are called end vertices or end points;
• Directed edge: ordered pair <u, v> where <u, v> is not the same as <v, u> u is called origin and v is called destination;
• Undirected edge: unordered pair <u, v> is the same as <v, u>, sometimes denoted as {u, v}
• Symmetric relation: (e.g. bi-directional road map) if A is connected to B, then B must be connected a road to A. Undirected edge can be used to represent such a relation.
• Asymmetric relation: (e.g., report to) if A reports to B, usually B does not report to A. So directed edge is necessary to represent this kind of relation.
• Undirected graph contains only undirected edges
• Directed graph contains only directed edges
• Mixed graph contains both undirected and directed edges
• Unweighted graph: all edges has the same weight (usually just 1)
• Weighted graph: each edge has a weight, the weights of the edges may be different.
• Adjacent: two vertices, which are end points of a same edge, are adjacent.
• Outgoing edges and incoming edges;
• Degree, in-degree, out-degree;
• Parallel edges (multiple edges), self-loop;
• Simple graph: graphs with neither parallel edges nor self-loops;
• Path: a sequence of alternating vertices and edges that starts at a vertex and ends at a vertex, and each vertex is the origin of its successor edge and the destination of its predecessor edge;
• Cycle: a path starts and ends at the same vertex;
• simple path: each vertex in the path is distinct;
• simple cycle: each vertex, except the start and end one is distinct;
• Directed path, directed cycle;
• Sub graph;
• Connected graph
• Tree: connected and acyclic graph

Some theorem involving degree of vertices and number of edges; a simple graph with n vertices has at most n(n-1) edges.

Graph Operations

• Graph queries
  • Number of vertices
  • Number of edges
  • Iterator of vertices
  • Iterator of edges
  • IncidentEdges(v)
  • EndVertices(e)
  • AreAdjacent(v, w)
• Graph updates
  • InsertVertex(v)
  • InsertEdge(v, w, e)
  • RemoveVertex(v)
  • RemoveEdge(e)
  • SetDirectionFrom(e, v)
  • SetDirectionTo(e, v)

Concrete data structures to implement a graph

• Vertex Objects
• Edge Objets
• Edge List Structure
• Adjacency List Structure
  A representation of a directed graph with n vertexes using an array of n lists of vertexes. List i contains vertex j if there is an edge from vertex i to vertex j. A weighted graph may be represented with a list of vertex/weight pairs. An undirected graph may be represented by having vertex j in the list for vertex i and vertex i in the list for vertex j.
• Adjacency Matrix Structure
  A representation of a directed graph with n vertexes using an n × n matrix, where the entry at (i,j) is 1 if there is an edge from vertex i to vertex j; otherwise the entry is 0. A weighted graph may be represented using the weight as the entry. An undirected graph may be represented using the same entry in both (i,j) and (j,i) or using an upper triangular matrix.

Graph Traversal

• Depth-first search -- Backtracking Algorithm

  Algorithm DFS(graph G, start_node v)
      For each edge e in G.incidentEdges(v) do
          If e is not marked then
              w = G.opposite(v, e);
              If w is not marked then
                  Mark w;
                  Mark e as discovery edge;
                  DFS(G, w);
              Else
                  mark e as back edge;
  

• Breadth-first search -- Traverse graph by layers (as in tree traverse)

  Algorithm BFS(graph G, start_node v)
      Create an empty queue Q;
      Mark v;
      Q.enqueue(v);
      While not Q.isEmpty()
          w = Q.dequeue();
          For each edge e in G.incidentEdges(w) do
              If e is not marked then
                  u = G.opposite(w, e);
                  If u is not marked then
                      Mark u;
                      Mark e as discovery edge;
  		    Q.enqueue(u);
                  Else mark e as back edge;
  

• Typical Applications of Graph Traversal
  • Testing connectivity
  • Detecting cycles in G
  • Finding a path between a pair of vertices
  • Crawl the web
  • Systematically examining each vertex and edge in G, etc.

Other typical graph algorithms

• Topological Sort
  • Definition: Consider a directed acyclic graph G = <V, E>, a topological sort of the vertices of G is a sequence S = {v₁, v₂, ..., v_n} in which each element of v_i in V appears exactly once. For pair of distinct vertices v_i and v_j in the sequence S, if <v_i, v_j> is an edge in G, then i < j in S.
  • Algorithm to create such a topological sort:

    Algorithem TopologicalSort(Graph G)
        Create an empty sequence S;
        repeat until G is empty
            select a vertex whose in-degree is zero;
            append this vertex to S;
            remove this vertex and all the edges eminating from it from G;
    

• Single source shortest path
  • Un-weighted undirected simple graph -- BFS
  • Weighted simple graph -- Dijkstra's Algorithm (works for all graphs with all positive weights)

    // Each node will have a label
    // (flag:visited_flag, d:distance_to_source, p:previous_node)
    // weight(x, y) = +inf if there isn't an edge from x to y
    Algorithm Dijkstra(Graph G, start_node v1, destination_node v2)
        set all nodes' label as (false, +inf, -);
        set current node w as the start_node v1;
        set current node's label as (false, 0, -);
        while current node w is not the destination node v2
            set w.flag to be true;
            for each unvisited node x (x's flag is false)
                if (w.d + weight(w,x) < x.d)
                    set x's label as (false, w.d+weight(w,x), w);
            find a node y that is unvisited and has the smallest y.d;
            set current node w to be node y;
    

  • Weighted directed acyclic graph -- DAG algorithm using topological sort

    Algorithm DAG(Graph G, start_node v_s)
        compute a topological sort sequence S for G;
        // S = {v1, v2, ..., vn} 
        D[v_s] = 0;
        for each node v different from v_s
            D[v] = +inf;
        for i = 1 to n-1 do
            for each edge <v_i, u> in G
                if (D[v_i] + weight(v_i, u) < D[u])
                    set D[u] = D[v_i] + weight(v_i, u);
    

• All-pairs shortest paths
  • A dynamic programming algorithm by S.Warshall, R.W. Floyd and P.Z. Ingerman -- works as long as there is no negative weight cycles

    // G has n nodes
    // weight(i, j) stores the weight of the edge from node i to node j
    // weight(i, j) is +inf if there is no edge from node i to node j
    // weight(i, i) is 0
    Algorithm allPairs(Graph G)
        for i = 0 to n-1
            for j = 0 to n-1
                if weight(i, j) != +inf
                    D[i][j] = weight(i, j);
                    next[i][j] = j;
                else
                    D[i][j] = +inf;
                    next[i][j] = null;
        for k = 0 to n-1
            for i = 0 to n-1
                for j = 0 to n-1
                    if (D[i][j] > D[i][k] + D[k][j])
                        D[i][j] = D[i][k] + D[k][j];
                        next[i][j] = next[i][k];
    

  • Matrix Multiplication

    // G has n nodes
    // weight(i, j) stores the weight of the edge from node i to node j
    // weight(i, j) is +inf if there is no edge from node i to node j
    // weight(i, i) is 0
    Algorithm allPairs(Graph G)
        for i = 0 to n-1
            for j = 0 to n-1
                A[0, i, j] = weight(i, j);
        for k = 1 to n-1
            for i = 0 to n-1
                for j = 0 to n-1
                    A[k, i, j] = A[k-1, i, j]
                    for m = 0 to n-1
                        if A[k, i, j] > A[k-1, i, m] + weight(m, j)
                            A[k, i, j] = A[k-1, i, m] + weight(m, j)
    

• Minimum spanning trees
  • The spanning tree of a connected graph is a tree that contains every vertex of the graph, and the edge set of the tree is the subset of the edge set of the graph
  • The minimum spanning tree is a spanning tree with the smallest total weight of the edges.
  • If the graph is an unweighted graph, then the minimum spanning tree is the tree with only the discovery edges while traversing the graph.
  • Calculate the minimum spanning tree of a weighted graph -- Kruskal algorithm

    // Graph G has n vertices
    Algorithm MinimumSpanningTree(Graph G)
        create an empty tree T;
        for each vertex v in G
            define an elementary cluster C(v) = {v};
        create an empty priority Q;
        for each edge e in G, using e's weight as key
            Q.insert(e's weight, e);
        while T has fewer than n-1 edges
            <u, v> = Q.removeMin();
            if u and v are not in the same cluster then
                add the edge <u, v> to T;
                merge u's and v's cluster to one;
        return tree T;
    

  • Calculate the minimum spanning tree of a weighted graph -- Prim-Jarnik algorithm (borrowing ideas from Dijkstra's algorithm)

    // Graph G has n vertices
    Algorithm MinimumSpanningTree(Graph G)
        pick any vertex v of G;
        D[v] = 0;
        for each vertex u <> v
            D[u] = +inf;
        initialize an empty tree T;
        using D[u] as priority to create a priority queue Q
            that includes an entry of (D[u], (u, null)) for each vertex u in G;
        while not Q.isEmpty()
            (u, e) = Q.removeMin(); // e can be null
            add vertex u and edge e to T;
            for each vertex z adjacent to u and z is not in T
                if weight(u, z) < D[z] then
                    D[z] = weight(u, z);
                    change the entry of z in Q to (D[z], (z, (u, z));
        return tree T;