Added TSP

Author: davecom

Classic Computer Science Problems in Swift.playground/Pages/Chapter 8.xcplaygroundpage/Contents.swift

@@ -64,5 +64,90 @@ let items = [Item(name: "television", weight: 50, value: 500),
              Item(name: "painting", weight: 10, value: 1000)]
 knapsack(items: items, maxCapacity: 75)
 
+/// Travelling Salesman
+
+let vtCities = ["Rutland", "Burlington", "White River Junction", "Bennington", "Brattleboro"]
+
+let vtDistances = [
+    "Rutland":
+        ["Burlington": 67, "White River Junction": 46, "Bennington": 55, "Brattleboro": 75],
+    "Burlington":
+        ["Rutland": 67, "White River Junction": 91, "Bennington": 122, "Brattleboro": 153],
+    "White River Junction":
+        ["Rutland": 46, "Burlington": 91, "Bennington": 98, "Brattleboro": 65],
+    "Bennington":
+        ["Rutland": 55, "Burlington": 122, "White River Junction": 98, "Brattleboro": 40],
+    "Brattleboro":
+        ["Rutland": 75, "Burlington": 153, "White River Junction": 65, "Bennington": 40]
+]
+
+// backtracking permutations algorithm
+func allPermutationsHelper<T>(contents: [T], permutations: inout [[T]], n: Int) {
+    guard n > 0 else { permutations.append(contents); return }
+    var tempContents = contents
+    for i in 0..<n {
+        tempContents.swapAt(i, n - 1) // move the element at i to the end
+        // move everything else around, holding the end constant
+        allPermutationsHelper(contents: tempContents, permutations: &permutations, n: n - 1)
+        tempContents.swapAt(i, n - 1) // backtrack
+    }
+}
+
+// find all of the permutations of a given array
+func allPermutations<T>(_ original: [T]) -> [[T]] {
+    var permutations = [[T]]()
+    allPermutationsHelper(contents: original, permutations: &permutations, n: original.count)
+    return permutations
+}
+
+// test allPermutations
+let abc = ["a","b","c"]
+let testPerms = allPermutations(abc)
+print(testPerms)
+print(testPerms.count)
+
+// make complete paths for tsp
+func tspPaths<T>(_ permutations: [[T]]) -> [[T]] {
+    return permutations.map {
+        if let first = $0.first {
+            return ($0 + [first]) // append first to end
+        } else {
+            return [] // empty is just itself
+        }
+    }
+}
+
+print(tspPaths(testPerms))
+
+func solveTSP<T>(cities: [T], distances: [T: [T: Int]]) -> (solution: [T], distance: Int) {
+    let possiblePaths = tspPaths(allPermutations(cities))
+    var bestPath: [T] = []
+    var minDistance: Int = Int.max
+    for path in possiblePaths {
+        if path.count < 2 { continue }
+        var distance = 0
+        var last = path.first! // we know there is one becuase of above line
+        for next in path[1..<path.count] {
+            distance += distances[last]![next]!
+            last = next
+        }
+        if distance < minDistance {
+            minDistance = distance
+            bestPath = path
+        }
+    }
+    return (solution: bestPath, distance: minDistance)
+}
+
+let vtTSP = solveTSP(cities: vtCities, distances: vtDistances)
+print("The shortest path is \(vtTSP.solution) in \(vtTSP.distance) miles.")
+
+//func dog(test: inout [String]) {
+//    test.append("hello")
+//
+//}
+
+// City 0
+
 //: [Next](@next)