Merge pull request kodecocodes#146 from mrael2/master

Set Cover (Unweighted)

Author: Chris Pilcher

Set Cover (Unweighted)/README.markdown

@@ -0,0 +1,33 @@
+# Set Cover (Unweighted)
+
+If you have a group of sets, this algorithm finds a subset of those sets within that group whose union will cover an initial set that you're trying to match. The initial set is also known as the universe.
+
+For example, suppose you have a universe of `{1, 5, 7}` and you want to find the sets which cover the universe within the following group of sets:
+
+> {8, 4, 2}
+> {3, 1}
+> {7, 6, 5, 4}
+> {2}
+> {1, 2, 3}
+
+You can see that the sets `{3, 1} {7, 6, 5, 4}` when unioned together will cover the universe of `{1, 5, 7}`. Yes, there may be additional elements in the sets returned by the algorithm, but every element in the universe is represented in the cover itself.
+
+There may be cases where no cover exists. For example, if your universe is `{7, 9}`, there is no combination of sets within the group above that will yield a cover.
+
+## The algorithm
+
+The Greedy Set Cover algorithm (unweighted) is provided here. It's known as greedy because it uses the largest intersecting set from the group of sets first before examining other sets in the group. This is part of the reason why the cover may have additional elements which are not part of the universe.
+
+The function (named `cover`) is provided as an extension of the Swift type `Set`. The function takes a single parameter, which is an array of sets. This array represents the group, and the set itself represents the universe.
+
+One of the first things done in `cover` is to make a copy of the universe in `remainingSet`. Then, the algorithm enters a `while` loop in which a call to `largestIntersectingSet` is made. The value returned from `largestIntersectingSet` is the set which has the most elements in common with the remaining universe identified by `remainingSet`. If all sets have nothing in common, `largestIntersectingSet` returns `nil`.
+
+If the result from `largestIntersectingSet` is not nil, that result is subtracted from `remainingSet` (reducing its size), and the loop continues until `remainingSet` has zero length (meaning a cover has been found) or until `largestIntersectingSet` returns `nil`.
+
+If there is no cover within the group of sets, `cover` returns `nil`.
+
+## See also
+
+[Set cover problem on Wikipedia](https://en.wikipedia.org/wiki/Set_cover_problem)
+
+*Written for Swift Algorithm Club by [Michael C. Rael](https://github.com/mrael2)*

Set Cover (Unweighted)/SetCover.playground/Contents.swift

@@ -0,0 +1,31 @@
+let universe1 = Set(1...7)
+let array1 = randomArrayOfSets(covering: universe1)
+let cover1 = universe1.cover(within: array1)
+
+let universe2 = Set(1...10)
+let array2: Array<Set<Int>> = [[1,2,3,4,5,6,7], [8,9]]
+let cover2 = universe2.cover(within: array2)
+
+let universe3 = Set(["tall", "heavy"])
+let array3: Array<Set<String>> = [["tall", "light"], ["short", "heavy"], ["tall", "heavy", "young"]]
+let cover3 = universe3.cover(within: array3)
+
+let universe4 = Set(["tall", "heavy", "green"])
+let cover4 = universe4.cover(within: array3)
+
+let universe5: Set<Int> = [16, 32, 64]
+let array5: Array<Set<Int>> = [[16,17,18], [16,32,128], [1,2,3], [32,64,128]]
+let cover5 = universe5.cover(within: array5)
+
+let universe6: Set<Int> = [24, 89, 132, 90, 22]
+let array6 = randomArrayOfSets(covering: universe6)
+let cover6 = universe6.cover(within: array6)
+
+let universe7: Set<String> = ["fast", "cheap", "good"]
+let array7 = randomArrayOfSets(covering: universe7, minArraySizeFactor: 20.0, maxSetSizeFactor: 0.7)
+let cover7 = universe7.cover(within: array7)
+
+let emptySet = Set<Int>()
+let coverTest1 = emptySet.cover(within: array1)
+let coverTest2 = universe1.cover(within: Array<Set<Int>>())
+let coverTest3 = emptySet.cover(within: Array<Set<Int>>())

Set Cover (Unweighted)/SetCover.playground/Sources/RandomArrayOfSets.swift

@@ -0,0 +1,43 @@
+import Foundation
+
+public func randomArrayOfSets<T>(covering universe: Set<T>,
+                              minArraySizeFactor: Double = 0.8,
+                              maxSetSizeFactor: Double = 0.6) -> Array<Set<T>> {
+  var result = [Set<T>]()
+  var ongoingUnion = Set<T>()
+  
+  let minArraySize = Int(Double(universe.count) * minArraySizeFactor)
+  var maxSetSize = Int(Double(universe.count) * maxSetSizeFactor)
+  if maxSetSize > universe.count {
+    maxSetSize = universe.count
+  }
+  
+  while true {
+    var generatedSet = Set<T>()
+    let targetSetSize = Int(arc4random_uniform(UInt32(maxSetSize)) + 1)
+    
+    while true {
+      let randomUniverseIndex = Int(arc4random_uniform(UInt32(universe.count)))
+      for (setIndex, value) in universe.enumerate() {
+        if setIndex == randomUniverseIndex {
+          generatedSet.insert(value)
+          break
+        }
+      }
+      
+      if generatedSet.count == targetSetSize {
+        result.append(generatedSet)
+        ongoingUnion = ongoingUnion.union(generatedSet)
+        break
+      }
+    }
+    
+    if result.count >= minArraySize {
+      if ongoingUnion == universe {
+        break
+      }
+    }
+  }
+  
+  return result
+}

Set Cover (Unweighted)/SetCover.playground/Sources/SetCover.swift

@@ -0,0 +1,33 @@
+public extension Set {
+  func cover(within array: Array<Set<Element>>) -> Array<Set<Element>>? {
+    var result: [Set<Element>]? = [Set<Element>]()
+    var remainingSet = self
+    
+    func largestIntersectingSet() -> Set<Element>? {
+      var largestIntersectionLength = 0
+      var largestSet: Set<Element>?
+      
+      for set in array {
+        let intersectionLength = remainingSet.intersect(set).count
+        if intersectionLength > largestIntersectionLength {
+          largestIntersectionLength = intersectionLength
+          largestSet = set
+        }
+      }
+      
+      return largestSet
+    }
+    
+    while remainingSet.count != 0 {
+      guard let largestSet = largestIntersectingSet() else { break }
+      result!.append(largestSet)
+      remainingSet = remainingSet.subtract(largestSet)
+    }
+    
+    if remainingSet.count != 0 || self.count == 0 {
+      result = nil
+    }
+    
+    return result
+  }
+}

Set Cover (Unweighted)/SetCover.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='osx'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Set Cover (Unweighted)/SetCover.swift

@@ -0,0 +1,33 @@
+extension Set {
+  func cover(within array: Array<Set<Element>>) -> Array<Set<Element>>? {
+    var result: [Set<Element>]? = [Set<Element>]()
+    var remainingSet = self
+    
+    func largestIntersectingSet() -> Set<Element>? {
+      var largestIntersectionLength = 0
+      var largestSet: Set<Element>?
+      
+      for set in array {
+        let intersectionLength = remainingSet.intersect(set).count
+        if intersectionLength > largestIntersectionLength {
+          largestIntersectionLength = intersectionLength
+          largestSet = set
+        }
+      }
+      
+      return largestSet
+    }
+    
+    while remainingSet.count != 0 {
+      guard let largestSet = largestIntersectingSet() else { break }
+      result!.append(largestSet)
+      remainingSet = remainingSet.subtract(largestSet)
+    }
+    
+    if remainingSet.count != 0 || self.count == 0 {
+      result = nil
+    }
+    
+    return result
+  }
+}