773 Sliding Puzzle

idf · idf · commit 44e277514145 · 2019-05-15T17:21:45.000-07:00
diff --git a/755 Pour Water.py b/755 Pour Water.py
@@ -0,0 +1,155 @@
+#!/usr/bin/python3
+"""
+We are given an elevation map, heights[i] representing the height of the terrain
+at that index. The width at each index is 1. After V units of water fall at
+index K, how much water is at each index?
+
+Water first drops at index K and rests on top of the highest terrain or water at
+that index. Then, it flows according to the following rules:
+
+If the droplet would eventually fall by moving left, then move left.
+Otherwise, if the droplet would eventually fall by moving right, then move right.
+Otherwise, rise at it's current position.
+Here, "eventually fall" means that the droplet will eventually be at a lower
+level if it moves in that direction. Also, "level" means the height of the
+terrain plus any water in that column.
+We can assume there's infinitely high terrain on the two sides out of bounds of
+the array. Also, there could not be partial water being spread out evenly on
+more than 1 grid block - each unit of water has to be in exactly one block.
+
+Example 1:
+Input: heights = [2,1,1,2,1,2,2], V = 4, K = 3
+Output: [2,2,2,3,2,2,2]
+Explanation:
+#       #
+#       #
+##  # ###
+#########
+ 0123456    <- index
+
+The first drop of water lands at index K = 3:
+
+#       #
+#   w   #
+##  # ###
+#########
+ 0123456
+
+When moving left or right, the water can only move to the same level or a lower
+level.
+(By level, we mean the total height of the terrain plus any water in that column.)
+Since moving left will eventually make it fall, it moves left.
+(A droplet "made to fall" means go to a lower height than it was at previously.)
+
+#       #
+#       #
+## w# ###
+#########
+ 0123456
+
+Since moving left will not make it fall, it stays in place.  The next droplet
+falls:
+
+#       #
+#   w   #
+## w# ###
+#########
+ 0123456
+
+Since the new droplet moving left will eventually make it fall, it moves left.
+Notice that the droplet still preferred to move left,
+even though it could move right (and moving right makes it fall quicker.)
+
+#       #
+#  w    #
+## w# ###
+#########
+ 0123456
+
+#       #
+#       #
+##ww# ###
+#########
+ 0123456
+
+After those steps, the third droplet falls.
+Since moving left would not eventually make it fall, it tries to move right.
+Since moving right would eventually make it fall, it moves right.
+
+#       #
+#   w   #
+##ww# ###
+#########
+ 0123456
+
+#       #
+#       #
+##ww#w###
+#########
+ 0123456
+
+Finally, the fourth droplet falls.
+Since moving left would not eventually make it fall, it tries to move right.
+Since moving right would not eventually make it fall, it stays in place:
+
+#       #
+#   w   #
+##ww#w###
+#########
+ 0123456
+
+The final answer is [2,2,2,3,2,2,2]:
+
+    #
+ #######
+ #######
+ 0123456
+Example 2:
+Input: heights = [1,2,3,4], V = 2, K = 2
+Output: [2,3,3,4]
+Explanation:
+The last droplet settles at index 1, since moving further left would not cause
+it to eventually fall to a lower height.
+Example 3:
+Input: heights = [3,1,3], V = 5, K = 1
+Output: [4,4,4]
+Note:
+
+heights will have length in [1, 100] and contain integers in [0, 99].
+V will be in range [0, 2000].
+K will be in range [0, heights.length - 1].
+"""
+from typing import List
+
+
+class Solution:
+    def pourWater(self, heights: List[int], V: int, K: int) -> List[int]:
+        """
+        Simulation?
+        O(V * L)
+        """
+        for _ in range(V):
+            s = K
+            # looking to the left
+            optimal = s
+            for i in range(s-1, -1, -1):
+                if heights[i] <= heights[i+1]:
+                    if heights[i] < heights[optimal]:
+                        optimal = i
+                else:
+                    break
+            if optimal == s:
+                # looking to the right
+                for i in range(s+1, len(heights)):
+                    if heights[i] <= heights[i-1]:
+                        if heights[i] < heights[optimal]:
+                            optimal = i
+                    else:
+                        break
+            heights[optimal] += 1
+
+        return heights
+
+
+if __name__ == "__main__":
+    assert Solution().pourWater([2,1,1,2,1,2,2], 4, 3) == [2,2,2,3,2,2,2]
diff --git a/773 Sliding Puzzle.py b/773 Sliding Puzzle.py
@@ -0,0 +1,128 @@
+#!/usr/bin/python3
+"""
+On a 2x3 board, there are 5 tiles represented by the integers 1 through 5, and
+an empty square represented by 0.
+
+A move consists of choosing 0 and a 4-directionally adjacent number and swapping
+it.
+
+The state of the board is solved if and only if the board is [[1,2,3],[4,5,0]].
+
+Given a puzzle board, return the least number of moves required so that the
+state of the board is solved. If it is impossible for the state of the board to
+be solved, return -1.
+
+Examples:
+
+Input: board = [[1,2,3],[4,0,5]]
+Output: 1
+Explanation: Swap the 0 and the 5 in one move.
+Input: board = [[1,2,3],[5,4,0]]
+Output: -1
+Explanation: No number of moves will make the board solved.
+Input: board = [[4,1,2],[5,0,3]]
+Output: 5
+Explanation: 5 is the smallest number of moves that solves the board.
+An example path:
+After move 0: [[4,1,2],[5,0,3]]
+After move 1: [[4,1,2],[0,5,3]]
+After move 2: [[0,1,2],[4,5,3]]
+After move 3: [[1,0,2],[4,5,3]]
+After move 4: [[1,2,0],[4,5,3]]
+After move 5: [[1,2,3],[4,5,0]]
+Input: board = [[3,2,4],[1,5,0]]
+Output: 14
+Note:
+
+board will be a 2 x 3 array as described above.
+board[i][j] will be a permutation of [0, 1, 2, 3, 4, 5].
+"""
+from typing import List
+from collections import defaultdict
+from copy import deepcopy
+import heapq
+
+
+final_pos = {
+    1: (0, 0),
+    2: (0, 1),
+    3: (0, 2),
+    4: (1, 0),
+    5: (1, 1),
+    0: (1, 2),
+}
+
+dirs = (
+    (0, -1),
+    (0, 1),
+    (-1, 0),
+    (1, 0),
+)
+
+
+class Solution:
+    def slidingPuzzle(self, board: List[List[int]]) -> int:
+        """
+        BFS + visited
+
+        => A*
+        priority = current_dist + heuristic_dist
+
+        Chain the matrix into 1d array. N = R * C
+        Complexity O(N * N!)
+        There are O(N!) possible board states. O(N) is the time to scan the board for the operations in the loop.
+        """
+        visited = defaultdict(bool)
+        m, n = len(board), len(board[0])
+        q = [(self.heuristic_dist(board) + 0, 0, board)]
+        target = [
+            [1, 2, 3],
+            [4, 5, 0],
+        ]
+        while q:
+            heu, cur_dist, board = heapq.heappop(q)
+            visited[self.ser(board)] = True
+            if board == target:
+                return cur_dist
+
+            cur_dist += 1
+            i, j = self.zero_pos(board)
+            for di, dj in dirs:
+                I = i + di
+                J = j + dj
+                if 0 <= I < m and 0 <= J < n:
+                    B = deepcopy(board)   # need a copy in the queue
+                    B[I][J], B[i][j] = B[i][j], B[I][J]
+                    if not visited[self.ser(B)]:
+                        heapq.heappush(q, (self.heuristic_dist(B) + cur_dist, cur_dist, B))
+        return -1
+
+    def zero_pos(self, board):
+        for i, row in enumerate(board):
+            for j, v in enumerate(row):
+                if v == 0:
+                    return i, j
+        raise
+
+    def heuristic_dist(self, board):
+        """
+        manhattan distance
+        """
+        ret = 0
+        for i, row in enumerate(board):
+            for j, v in enumerate(row):
+                if v != 0:
+                    I, J = final_pos[v]
+                    ret += abs(i - I) + abs(j - J)
+        return ret
+
+    def ser(self, board):
+        return tuple(
+            tuple(row)
+            for row in board
+        )
+
+
+if __name__ == "__main__":
+    assert Solution().slidingPuzzle([[1,2,3],[4,0,5]]) == 1
+    assert Solution().slidingPuzzle([[1,2,3],[5,4,0]]) == -1
