[Function add]:1. Add leetcode solutions

Author: Botao Xiao

leetcode/174. Dungeon Game.md

@@ -69,7 +69,31 @@ Note:
     }
     ```
 
-* Method 2: Union find set to be added
+* Method 2: Union find set
+  ```Java
+  class Solution {
+      private int[] uf;
+      public int[] findRedundantConnection(int[][] edges) {
+          uf = new int[edges.length * 2 + 1];
+          for(int i = 1; i < uf.length; i++){
+              uf[i] = i;
+          }
+          for(int[] edge : edges){
+              int p = find(edge[0]);
+              int q = find(edge[1]);
+              if(p == q) return edge;
+              uf[p] = q;
+          }
+          return null;
+      }
+      private int find(int i){
+          if(i != uf[i]){
+              uf[i] = find(uf[i]);
+          }
+          return uf[i];
+      }
+  }
+  ```
 
 ### Reference
-1. [花花酱 LeetCode 684. Redundant Connection](http://zxi.mytechroad.com/blog/tree/leetcode-684-redundant-connection/)
+1. [花花酱 LeetCode 684. Redundant Connection](http://zxi.mytechroad.com/blog/tree/leetcode-684-redundant-connection/)

leetcode/377. Combination Sum IV.md

@@ -0,0 +1,82 @@
+## 743. Network Delay Time
+
+### Question
+There are N network nodes, labelled 1 to N.
+
+Given times, a list of travel times as directed edges times[i] = (u, v, w), where u is the source node, v is the target node, and w is the time it takes for a signal to travel from source to target.
+
+Now, we send a signal from a certain node K. How long will it take for all nodes to receive the signal? If it is impossible, return -1.
+
+Note:
+1. N will be in the range [1, 100].
+2. K will be in the range [1, N].
+3. The length of times will be in the range [1, 6000].
+4. All edges times[i] = (u, v, w) will have 1 <= u, v <= N and 0 <= w <= 100.
+
+
+### Solution:
+* Method 1: Floyd O(n ^ 3)
+  ```Java
+  class Solution {
+      public int networkDelayTime(int[][] times, int N, int K) {
+          int[][] cost = new int[N + 1][N + 1];
+          for(int[] c : cost) Arrays.fill(c, Integer.MAX_VALUE >> 1);
+          for(int i = 1; i <= N; i++) cost[i][i] = 0;
+          for(int[] time : times){
+              cost[time[0]][time[1]] = time[2];
+          }
+          for(int k = 1; k <= N; k++){
+              for(int i = 1; i <= N; i++){
+                  for(int j = 1; j <= N; j++){
+                      cost[i][j] = Math.min(cost[i][j], cost[i][k] + cost[k][j]);
+                  }
+              }
+          }
+          int res = 0;
+          for(int i = 1; i <= N; i++){
+              if(cost[K][i] > 6000) return -1;
+              res = Math.max(res, cost[K][i]);
+          }
+          return res;
+      }
+  }
+  ```
+
+* Method 2: Dijkstra
+  ```Java
+  class Solution {
+      public int networkDelayTime(int[][] times, int N, int K) {
+          int[][] cost = new int[N + 1][N + 1];
+          for(int[] c : cost) Arrays.fill(c, Integer.MAX_VALUE >> 1);
+          for(int i = 1; i <= N; i++) cost[i][i] = 0;
+          for(int[] time : times){
+              cost[time[0]][time[1]] = time[2];
+          }
+          int[] result = Arrays.copyOf(cost[K], N + 1);
+          Set<Integer> set = new HashSet<>();
+          set.add(K);
+          while(set.size() < N){
+              int index = -1, min = Integer.MAX_VALUE;
+              for(int i = 1; i <= N; i++){
+                  if(!set.contains(i) && min > result[i]){
+                      index = i;
+                      min = result[i];
+                  }
+              }
+              for(int i = 0; i <= N; i++){
+                  if(index != -1 && !set.contains(i)){
+                      result[i] = Math.min(result[i], min + cost[index][i]);
+                  }
+              }
+              if(index == -1) return -1;
+              else set.add(index);
+          }
+          int res = 0;
+          for(int i = 1; i <= N; i++){
+              if(result[i] > 6000) return -1;
+              res = Math.max(result[i], res);
+          }
+          return res;
+      }
+  }
+  ```

leetcode/416. Partition Equal Subset Sum.md

@@ -0,0 +1,69 @@
+## 815. Bus Routes
+
+### Question
+We have a list of bus routes. Each routes[i] is a bus route that the i-th bus repeats forever. For example if routes[0] = [1, 5, 7], this means that the first bus (0-th indexed) travels in the sequence 1->5->7->1->5->7->1->... forever.
+
+We start at bus stop S (initially not on a bus), and we want to go to bus stop T. Travelling by buses only, what is the least number of buses we must take to reach our destination? Return -1 if it is not possible.
+
+```
+Example:
+Input:
+routes = [[1, 2, 7], [3, 6, 7]]
+S = 1
+T = 6
+Output: 2
+Explanation:
+The best strategy is take the first bus to the bus stop 7, then take the second bus to the bus stop 6.
+```
+
+Note:
+1. 1 <= routes.length <= 500.
+2. 1 <= routes[i].length <= 500.
+3. 0 <= routes[i][j] < 10 ^ 6.
+
+### Solution
+* Method 1: bfs
+  * we need to construct a graph using map, where key is the stop number and value is a list recording all buses passes through this stop.
+  * we also need a boolean array to record which bus is visited since all stops on this routes can be visited.
+  ```Java
+  class Solution {
+      public int numBusesToDestination(int[][] routes, int S, int T) {
+          if(S == T) return 0;
+          // Create the graph
+          Map<Integer, List<Integer>> g = new HashMap<>();
+          for(int i = 0; i < routes.length; i++){
+              for(int j = 0; j < routes[i].length; j++){
+                  List<Integer> buses = g.containsKey(routes[i][j]) ? g.get(routes[i][j]): new ArrayList<>();
+                  buses.add(i);
+                  g.put(routes[i][j], buses);
+              }
+          }
+          Queue<Integer> q = new LinkedList<>();
+          q.offer(S);
+          int step = 0;
+          boolean[] ride = new boolean[routes.length];
+          while(!q.isEmpty()){
+              int size = q.size();
+              ++step;
+              for(int i = 0; i < size; i++){
+                  int cur = q.poll();
+                  // for each bus stop, get all buses that can pass through this stop
+                  List<Integer> buses = g.get(cur);
+                  for(Integer bus : buses){
+                      if(ride[bus]) continue;
+                      ride[bus] = true;
+                      // If never visited this bus before, add all stops of this bus to the queue.
+                      for(Integer stop : routes[bus]){
+                          if(stop == T) return step;
+                          q.offer(stop);
+                      }
+                  }
+              }
+          }
+          return -1;
+      }
+  }
+  ```
+
+### Reference
+1. [花花酱 LeetCode 815. Bus Routes](http://zxi.mytechroad.com/blog/graph/leetcode-815-bus-routes/)

leetcode/546. Remove Boxes.md

@@ -0,0 +1,66 @@
+## 847. Shortest Path Visiting All Nodes
+
+### Question
+An undirected, connected graph of N nodes (labeled 0, 1, 2, ..., N-1) is given as graph.
+
+graph.length = N, and j != i is in the list graph[i] exactly once, if and only if nodes i and j are connected.
+
+Return the length of the shortest path that visits every node. You may start and stop at any node, you may revisit nodes multiple times, and you may reuse edges.
+
+```
+Example 1:
+
+Input: [[1,2,3],[0],[0],[0]]
+Output: 4
+Explanation: One possible path is [1,0,2,0,3]
+Example 2:
+
+Input: [[1],[0,2,4],[1,3,4],[2],[1,2]]
+Output: 4
+Explanation: One possible path is [0,1,4,2,3]
+```
+
+Note:
+1. 1 <= graph.length <= 12(This means 2 ^ n level)
+2. 0 <= graph[i].length < graph.length
+
+### Solution:
+* Method 1: bfs time complexity O(n * 2 ^ n)
+  * Since we can visit a node multiple times, we need to have 2 variables to record breaking condition for a node:
+    * cur_node
+    * state: for current node, how many nodes were visited.
+    * for a single node, if that state is visited means it is a duplicate condition and we can continue.
+  ```Java
+  class Solution {
+      public int shortestPathLength(int[][] graph) {
+          int len = graph.length;
+          int expect = (1 << len) - 1; //This set all bits to 1.
+          Queue<int[]> q = new LinkedList<>();    // int[] saves current node, visited states
+          for(int i = 0; i < len; i++)
+              q.offer(new int[]{i, 1 << i});  // We could start from any points.
+          // if for current node and state, we visit it again will be dulplicate, we can continue.
+          boolean[][] visited = new boolean[len][1 << len];
+          int step = -1;
+          while(!q.isEmpty()){
+              int size = q.size();
+              ++step;
+              for(int i = 0; i < size; i++){
+                  int[] pair = q.poll();
+                  int node = pair[0];
+                  int state = pair[1];
+                  // We've visited all of the nodes
+                  if(state == expect) return step;
+                  if(visited[node][state]) continue;
+                  visited[node][state] = true;
+                  for(int next : graph[node]){
+                      q.offer(new int[]{next, state | (1 << next)});
+                  }
+              }
+          }
+          return -1;
+      }
+  }
+  ```
+
+### Reference
+1. [花花酱 LeetCode 847. Shortest Path Visiting All Nodes](http://zxi.mytechroad.com/blog/graph/leetcode-847-shortest-path-visiting-all-nodes/)

leetcode/547. Friend Circles.md

@@ -0,0 +1,91 @@
+## 864. Shortest Path to Get All Keys
+
+### Question
+We are given a 2-dimensional grid. "." is an empty cell, "#" is a wall, "@" is the starting point, ("a", "b", ...) are keys, and ("A", "B", ...) are locks.
+
+We start at the starting point, and one move consists of walking one space in one of the 4 cardinal directions.  We cannot walk outside the grid, or walk into a wall.  If we walk over a key, we pick it up.  We can't walk over a lock unless we have the corresponding key.
+
+For some 1 <= K <= 6, there is exactly one lowercase and one uppercase letter of the first K letters of the English alphabet in the grid.  This means that there is exactly one key for each lock, and one lock for each key; and also that the letters used to represent the keys and locks were chosen in the same order as the English alphabet.
+
+Return the lowest number of moves to acquire all keys.  If it's impossible, return -1.
+
+```
+Example 1:
+
+Input: ["@.a.#","###.#","b.A.B"]
+Output: 8
+Example 2:
+
+Input: ["@..aA","..B#.","....b"]
+Output: 6
+```
+
+Note:
+1. 1 <= grid.length <= 30
+2. 1 <= grid[0].length <= 30
+3. grid[i][j] contains only '.', '#', '@', 'a'-'f' and 'A'-'F'
+4. The number of keys is in [1, 6].  Each key has a different letter and opens exactly one lock.
+
+### Solution:
+* Method 1: BFS
+  * we use a integer to represent current state |bit 31:16 x index| bits 15:8 y index | bits 7-0 key|
+  ```Java
+  class Solution {
+      private static final int[][] dir = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
+      public int shortestPathAllKeys(String[] grid) {
+          int height = grid.length, width = grid[0].length();
+          char[][] g = new char[height][width];
+          int startX = -1, startY = -1;
+          int expect = 0;
+          for(int i = 0; i < height; i++){
+              char[] arr = grid[i].toCharArray();
+              for(int j = 0; j < width; j++){
+                  g[i][j] = arr[j];
+                  if(arr[j] == '@'){
+                      startX = i;
+                      startY = j;
+                  }else if(arr[j] >= 'a' && arr[j] <= 'f'){
+                      expect |= 1 << (arr[j] - 'a');
+                  }
+              }
+          }
+          Queue<Integer> q = new LinkedList<>(); //int[] records [x, y]
+          int startState = (startX << 16) | (startY << 8) | 0;
+          q.offer(startState);
+          int step = -1;
+          Set<Integer> visited = new HashSet<>();
+          while(!q.isEmpty()){
+              int size = q.size();
+              ++step;
+              for(int i = 0; i < size; i++){
+                  int cur = q.poll();
+                  if((cur & (0b111111)) == expect) return step;
+                  if(visited.contains(cur)) continue;
+                  visited.add(cur);
+                  int tx = 0, ty = 0;
+                  int curX = (cur >> 16) & 0xFF, curY = (cur >> 8) & 0xFF;
+                  int curKey = cur & 0xFF;
+                  for(int d = 0; d < 4; d++){
+                      tx = curX + dir[d][0];
+                      ty = curY + dir[d][1];
+                      if(tx >= 0 && tx < height && ty >= 0 && ty < width && g[tx][ty] != '#'){
+                          if(isUpper(g[tx][ty]) && (cur & (1 << (g[tx][ty] - 'A'))) == 0) continue;
+                          int nextState = (tx << 16) | (ty << 8) | (!isLower(g[tx][ty]) ? curKey : (curKey | (1 << (g[tx][ty] - 'A'))));
+                          q.offer(nextState);
+                      }
+                  }
+              }
+          }
+          return -1;
+      }
+      private boolean isUpper(char c){
+          return c >= 'A' && c <= 'F';
+      }
+      private boolean isLower(char c){
+          return c >= 'a' && c <= 'f';
+      }
+  }
+  ```
+
+### Reference
+1. [花花酱 LeetCode 864. Shortest Path to Get All Keys](https://zxi.mytechroad.com/blog/searching/leetcode-864-shortest-path-to-get-all-keys/)