README.md

@@ -18,3 +18,8 @@
 ### running-with-bunnies
 * Completed in: 1 day, 4 hrs, 40 mins, 40 secs.
 * Shortest Paths
+
+## Level4
+### escape-pods
+* Completed in: 1 day, 2 hrs, 16 mins, 11 secs.
+* Minimum cut

level4/escape-pods/constraints.txt

@@ -0,0 +1,21 @@
+Java
+====
+Your code will be compiled using standard Java 8. All tests will be run by calling the solution() method inside the Solution class
+
+Execution time is limited.
+
+Wildcard imports and some specific classes are restricted (e.g. java.lang.ClassLoader). You will receive an error when you verify your solution if you have used a blacklisted class.
+
+Third-party libraries, input/output operations, spawning threads or processes and changes to the execution environment are not allowed.
+
+Your solution must be under 32000 characters in length including new lines and and other non-printing characters.
+
+Python
+======
+Your code will run inside a Python 2.7.13 sandbox. All tests will be run by calling the solution() function.
+
+Standard libraries are supported except for bz2, crypt, fcntl, mmap, pwd, pyexpat, select, signal, termios, thread, time, unicodedata, zipimport, zlib.
+
+Input/output operations are not allowed.
+
+Your solution must be under 32000 characters in length including new lines and and other non-printing characters.

level4/escape-pods/readme.txt

@@ -0,0 +1,63 @@
+Escape Pods
+===========
+
+You've blown up the LAMBCHOP doomsday device and relieved the bunnies of their work duries -- and now you need to escape from the space station as quickly and as orderly as possible! The bunnies have all gathered in various locations throughout the station, and need to make their way towards the seemingly endless amount of escape pods positioned in other parts of the station. You need to get the numerous bunnies through the various rooms to the escape pods. Unfortunately, the corridors between the rooms can only fit so many bunnies at a time. What's more, many of the corridors were resized to accommodate the LAMBCHOP, so they vary in how many bunnies can move through them at a time. 
+
+Given the starting room numbers of the groups of bunnies, the room numbers of the escape pods, and how many bunnies can fit through at a time in each direction of every corridor in between, figure out how many bunnies can safely make it to the escape pods at a time at peak.
+
+Write a function solution(entrances, exits, path) that takes an array of integers denoting where the groups of gathered bunnies are, an array of integers denoting where the escape pods are located, and an array of an array of integers of the corridors, returning the total number of bunnies that can get through at each time step as an int. The entrances and exits are disjoint and thus will never overlap. The path element path[A][B] = C describes that the corridor going from A to B can fit C bunnies at each time step.  There are at most 50 rooms connected by the corridors and at most 2000000 bunnies that will fit at a time.
+
+For example, if you have:
+entrances = [0, 1]
+exits = [4, 5]
+path = [
+  [0, 0, 4, 6, 0, 0],  # Room 0: Bunnies
+  [0, 0, 5, 2, 0, 0],  # Room 1: Bunnies
+  [0, 0, 0, 0, 4, 4],  # Room 2: Intermediate room
+  [0, 0, 0, 0, 6, 6],  # Room 3: Intermediate room
+  [0, 0, 0, 0, 0, 0],  # Room 4: Escape pods
+  [0, 0, 0, 0, 0, 0],  # Room 5: Escape pods
+]
+
+Then in each time step, the following might happen:
+0 sends 4/4 bunnies to 2 and 6/6 bunnies to 3
+1 sends 4/5 bunnies to 2 and 2/2 bunnies to 3
+2 sends 4/4 bunnies to 4 and 4/4 bunnies to 5
+3 sends 4/6 bunnies to 4 and 4/6 bunnies to 5
+
+So, in total, 16 bunnies could make it to the escape pods at 4 and 5 at each time step.  (Note that in this example, room 3 could have sent any variation of 8 bunnies to 4 and 5, such as 2/6 and 6/6, but the final solution remains the same.)
+
+Languages
+=========
+
+To provide a Java solution, edit Solution.java
+To provide a Python solution, edit solution.py
+
+Test cases
+==========
+Your code should pass the following test cases.
+Note that it may also be run against hidden test cases not shown here.
+
+-- Java cases --
+Input:
+Solution.solution({0, 1}, {4, 5}, {{0, 0, 4, 6, 0, 0}, {0, 0, 5, 2, 0, 0}, {0, 0, 0, 0, 4, 4}, {0, 0, 0, 0, 6, 6}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}})
+Output:
+    16
+
+Input:
+Solution.solution({0}, {3}, {{0, 7, 0, 0}, {0, 0, 6, 0}, {0, 0, 0, 8}, {9, 0, 0, 0}})
+Output:
+    6
+
+-- Python cases --
+Input:
+solution.solution([0], [3], [[0, 7, 0, 0], [0, 0, 6, 0], [0, 0, 0, 8], [9, 0, 0, 0]])
+Output:
+    6
+
+Input:
+solution.solution([0, 1], [4, 5], [[0, 0, 4, 6, 0, 0], [0, 0, 5, 2, 0, 0], [0, 0, 0, 0, 4, 4], [0, 0, 0, 0, 6, 6], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]])
+Output:
+    16
+
+Use verify [file] to test your solution and see how it does. When you are finished editing your code, use submit [file] to submit your answer. If your solution passes the test cases, it will be removed from your home folder.

level4/escape-pods/solution.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+def solution(entrances, exits, path):
+    p = np.array(path)
+    minimum_width = -1
+    all_rooms = set(range(len(p)))
+    for rooms, others in generate_rooms(all_rooms, set(entrances), set(exits), p):
+        width = calculate_cut_width(rooms, others, p)
+        if width < minimum_width or minimum_width == -1:
+            minimum_width = width
+    return minimum_width
+
+def generate_rooms(all_rooms, prev_rooms, exits, path):
+    yield prev_rooms, all_rooms - set(prev_rooms)
+    for room, width in enumerate(sum(path[list(prev_rooms)])):
+        if room not in prev_rooms and room not in exits and width != 0:
+            next_rooms = prev_rooms | set([room])
+            for result in generate_rooms(all_rooms, next_rooms, exits, path):
+                yield result
+
+def calculate_cut_width(rooms, others, p):
+    return np.sum(p[list(rooms)][:, list(others)])
+
+tests = [
+        [[[0], [3], [[0, 7, 0, 0], [0, 0, 6, 0], [0, 0, 0, 8], [9, 0, 0, 0]]], 6],
+        [[[0, 1], [4, 5], [[0, 0, 4, 6, 0, 0], [0, 0, 5, 2, 0, 0], [0, 0, 0, 0, 4, 4], [0, 0, 0, 0, 6, 6], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]], 16],
+        ]
+
+for test in tests:
+    result = solution(*test[0])
+    print(test[0], result == test[1], result, test[1])