Added Solution for 300-400q/317 300-400q/351

Author: Garvit244

300-400q/317.py

@@ -0,0 +1,82 @@
+'''
+You want to build a house on an empty land which reaches all buildings in the shortest amount of distance. You can only move up, down, left and right. You are given a 2D grid of values 0, 1 or 2, where:
+
+Each 0 marks an empty land which you can pass by freely.
+Each 1 marks a building which you cannot pass through.
+Each 2 marks an obstacle which you cannot pass through.
+For example, given three buildings at (0,0), (0,4), (2,2), and an obstacle at (0,2):
+
+1 - 0 - 2 - 0 - 1
+| | | | |
+0 - 0 - 0 - 0 - 0
+| | | | |
+0 - 0 - 1 - 0 - 0
+The point (1,2) is an ideal empty land to build a house, as the total travel distance of 3+3+1=7 is minimal. So return 7.
+
+Note:
+There will be at least one building. If it is not possible to build such house according to the above rules, return -1.
+'''
+
+
+class Solution(object):
+def shortestDistance(self, grid):
+if not grid:
+return -1
+
+def bfs(grid, distance_reach_map, row, col):
+if(row < 0 or row > len(grid) or col < 0 or col > len(grid[0])):
+return
+queue = [[row, col]]
+qdist = [1]
+
+direction = [[-1, 0], [0, 1], [1, 0], [0, -1]]
+while queue:
+x, y = queue.pop(0)
+curr_dist = qdist.pop(0)
+
+for dx, dy in direction:
+new_x, new_y = x+dx, y+dy
+if((0 <= new_x < len(grid)) and (0 <= new_y < len(grid[0])) and grid[new_x][new_y] == 0):
+grid[new_x][new_y] = -1
+queue.append([new_x, new_y])
+
+
+temp = distance_reach_map[new_x][new_y]
+dist, reach = temp[0], temp[1]
+dist += curr_dist
+reach += 1
+distance_reach_map[new_x][new_y] = [dist, reach]
+qdist.append(curr_dist+1)
+
+for row in range(len(grid)):
+for col in range(len(grid[0])):
+if grid[row][col] == -1:
+grid[row][col] =0
+
+r_len, c_len = len(grid), len(grid[0])
+distance_reach_map = [[[0, 0]]*c_len for _ in range(r_len)]
+buildings = 0
+for row in range(len(grid)):
+for col in range(len(grid[0])):
+if grid[row][col] == 1:
+bfs(grid, distance_reach_map, row, col)
+buildings += 1
+
+result = float('inf')
+for row in range(r_len):
+for col in range(c_len):
+dist, reach = distance_reach_map[row][col]
+if reach == buildings:
+result = min(result, dist)
+return result
+
+solution = Solution()
+grid = [[1, 0, 2, 0, 1], 
+[0, 0, 0, 0, 0], 
+[0, 0, 1, 0 ,0]]
+print solution.shortestDistance(grid)
+
+
+
+
+

300-400q/351.py

@@ -0,0 +1,58 @@
+'''
+Given an Android 3x3 key lock screen and two integers m and n, where 1 ≤ m ≤ n ≤ 9, count the total number of unlock patterns of the Android lock screen, which consist of minimum of m keys and maximum n keys.
+
+Rules for a valid pattern:
+Each pattern must connect at least m keys and at most n keys.
+All the keys must be distinct.
+If the line connecting two consecutive keys in the pattern passes through any other keys, the other keys must have previously selected in the pattern. No jumps through non selected key is allowed.
+The order of keys used matters.
+
+Explanation:
+| 1 | 2 | 3 |
+| 4 | 5 | 6 |
+| 7 | 8 | 9 |
+Invalid move: 4 - 1 - 3 - 6 
+Line 1 - 3 passes through key 2 which had not been selected in the pattern.
+
+Invalid move: 4 - 1 - 9 - 2
+Line 1 - 9 passes through key 5 which had not been selected in the pattern.
+
+Valid move: 2 - 4 - 1 - 3 - 6
+Line 1 - 3 is valid because it passes through key 2, which had been selected in the pattern
+
+Valid move: 6 - 5 - 4 - 1 - 9 - 2
+Line 1 - 9 is valid because it passes through key 5, which had been selected in the pattern.
+
+Example:
+Given m = 1, n = 1, return 9.
+'''
+
+class Solution(object):
+def numberOfPatterns(self, m, n):
+def dfs(reamin, current, visited, skip):
+if reamin < 0:
+return 0
+if reamin == 0:
+return 1
+visited[current] = True 
+result = 0
+for index in range(1, 10):
+if not visited[index] and (skip[current][index] == 0 || visited[skip[current][index]])
+result += dfs(reamin-1, index, visited, skip)
+visited[current] = False
+return result
+
+skip = [[0 for _ in range(10)] for _ in range(10)]
+skip[1][3] = skip[3][1] = 2
+ skip[1][7] = skip[7][1] = 4
+ skip[3][9] = skip[9][3] = 6
+ skip[7][9] = skip[9][7] = 8
+ skip[1][9] = skip[9][1] = skip[2][8] = skip[8][2] = skip[3][7] = skip[7][3] = skip[4][6] = skip[6][4] = 5
+ visited = [False for _ in range(10)]
+
+result = 0
+for index in range(m, n):
+result += dfs(index-1, 1, visited, skip)
+result += dfs(index-1, 2, visited, skip)
+result += dfs(index-1, 5, visited, skip)
+return result