Introduces new workspace

Author: kelvinlauKL

SwiftAlgorithmClub/AllPairsShortestPaths.playground/Contents.swift

@@ -0,0 +1,27 @@
+var graph = AdjacencyListGraph<String>()
+
+let v1 = graph.createVertex("Montreal")
+let v2 = graph.createVertex("New York")
+let v3 = graph.createVertex("Boston")
+let v4 = graph.createVertex("Portland")
+let v5 = graph.createVertex("Portsmouth")
+
+graph.addDirectedEdge(v1, to: v2, withWeight: 3)
+graph.addDirectedEdge(v1, to: v5, withWeight: -4)
+graph.addDirectedEdge(v1, to: v3, withWeight: 8)
+
+graph.addDirectedEdge(v2, to: v4, withWeight: 1)
+graph.addDirectedEdge(v2, to: v5, withWeight: 7)
+
+graph.addDirectedEdge(v3, to: v2, withWeight: 4)
+
+graph.addDirectedEdge(v4, to: v1, withWeight: 2)
+graph.addDirectedEdge(v4, to: v3, withWeight: -5)
+
+graph.addDirectedEdge(v5, to: v4, withWeight: 6)
+
+let result = FloydWarshall<String>.apply(graph)
+
+let path = result.path(fromVertex: v1, toVertex: v4, inGraph: graph)
+
+print(graph)

SwiftAlgorithmClub/AllPairsShortestPaths.playground/Sources/APSP.swift

@@ -0,0 +1,35 @@
+//
+//  Base.swift
+//  APSP
+//
+//  Created by Andrew McKnight on 5/6/16.
+//
+
+import Foundation
+
+/**
+ `APSPAlgorithm` is a protocol for encapsulating an All-Pairs Shortest Paths algorithm.
+ It provides a single function `apply` that accepts a subclass of `AbstractGraph` and
+ returns an object conforming to `APSPResult`.
+ */
+public protocol APSPAlgorithm {
+
+  associatedtype Q: Hashable
+  associatedtype P: APSPResult
+
+  static func apply(_ graph: AbstractGraph<Q>) -> P
+
+}
+
+/**
+ `APSPResult` is a protocol defining functions `distance` and `path`, allowing for opaque
+ queries into the actual data structures that represent the APSP solution according to the algorithm used.
+ */
+public protocol APSPResult {
+
+  associatedtype T: Hashable
+
+  func distance(fromVertex from: Vertex<T>, toVertex to: Vertex<T>) -> Double?
+  func path(fromVertex from: Vertex<T>, toVertex to: Vertex<T>, inGraph graph: AbstractGraph<T>) -> [T]?
+
+}

SwiftAlgorithmClub/AllPairsShortestPaths.playground/Sources/AdjacencyListGraph.swift

@@ -0,0 +1,109 @@
+//
+//  AdjacencyListGraph.swift
+//  Graph
+//
+//  Created by Andrew McKnight on 5/13/16.
+//
+
+import Foundation
+
+private class EdgeList<T> where T: Hashable {
+  var vertex: Vertex<T>
+  var edges: [Edge<T>]?
+
+  init(vertex: Vertex<T>) {
+    self.vertex = vertex
+  }
+
+  func addEdge(_ edge: Edge<T>) {
+    edges?.append(edge)
+  }
+}
+
+open class AdjacencyListGraph<T>: AbstractGraph<T> where T: Hashable {
+  private var adjacencyList: [EdgeList<T>] = []
+
+  public required init() {
+    super.init()
+  }
+
+  public required init(fromGraph graph: AbstractGraph<T>) {
+    super.init(fromGraph: graph)
+  }
+
+  open override var vertices: [Vertex<T>] {
+    adjacencyList.map { $0.vertex }
+  }
+
+  open override var edges: [Edge<T>] {
+    Array(adjacencyList.flatMap { $0.edges ?? [] }.reduce(into: Set<Edge<T>>()) { $0.insert($1) })
+  }
+
+  open override func createVertex(_ data: T) -> Vertex<T> {
+    if let match = vertices.first(where: { $0.data == data }) {
+      return match
+    }
+    
+    // if the vertex doesn't exist, create a new one
+    let vertex = Vertex(data: data, index: adjacencyList.count)
+    adjacencyList.append(EdgeList(vertex: vertex))
+    return vertex
+  }
+
+  open override func addDirectedEdge(_ from: Vertex<T>, to: Vertex<T>, withWeight weight: Double?) {
+    // works
+    let edge = Edge(from: from, to: to, weight: weight)
+    let edgeList = adjacencyList[from.index]
+    if edgeList.edges != nil {
+        edgeList.addEdge(edge)
+    } else {
+        edgeList.edges = [edge]
+    }
+  }
+
+  open override func addUndirectedEdge(_ vertices: (Vertex<T>, Vertex<T>), withWeight weight: Double?) {
+    addDirectedEdge(vertices.0, to: vertices.1, withWeight: weight)
+    addDirectedEdge(vertices.1, to: vertices.0, withWeight: weight)
+  }
+
+  open override func weightFrom(_ sourceVertex: Vertex<T>, to destinationVertex: Vertex<T>) -> Double? {
+    guard let edges = adjacencyList[sourceVertex.index].edges else {
+      return nil
+    }
+
+    for edge: Edge<T> in edges {
+      if edge.to == destinationVertex {
+        return edge.weight
+      }
+    }
+
+    return nil
+  }
+
+  open override func edgesFrom(_ sourceVertex: Vertex<T>) -> [Edge<T>] {
+    return adjacencyList[sourceVertex.index].edges ?? []
+  }
+
+  open override var description: String {
+    var rows = [String]()
+    for edgeList in adjacencyList {
+
+      guard let edges = edgeList.edges else {
+        continue
+      }
+
+      var row = [String]()
+      for edge in edges {
+        var value = "\(edge.to.data)"
+        if edge.weight != nil {
+          value = "(\(value): \(edge.weight!))"
+        }
+        row.append(value)
+      }
+
+      rows.append("\(edgeList.vertex.data) -> [\(row.joined(separator: ", "))]")
+    }
+
+    return rows.joined(separator: "\n")
+  }
+}

SwiftAlgorithmClub/AllPairsShortestPaths.playground/Sources/Edge.swift

@@ -0,0 +1,24 @@
+//
+//  Edge.swift
+//  Graph
+//
+//  Created by Andrew McKnight on 5/8/16.
+//
+
+public struct Edge<T: Hashable> {
+  public let from: Vertex<T>
+  public let to: Vertex<T>
+  public let weight: Double?
+}
+
+extension Edge: CustomStringConvertible {
+  public var description: String {
+    guard let unwrappedWeight = weight else {
+      return "\(from.description) -> \(to.description)"
+    }
+    return "\(from.description) -(\(unwrappedWeight))-> \(to.description)"
+  }
+}
+
+extension Edge: Hashable {}
+extension Edge: Equatable {}