gou

Author: awangdev

Java/Bus Routes.java

@@ -0,0 +1,69 @@
+H
+1534208810
+tags: BFS
+
+```
+/*
+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 <= routes.length <= 500.
+1 <= routes[i].length <= 500.
+0 <= routes[i][j] < 10 ^ 6.
+*/
+
+/*
+1. Map stop -> bus list
+2. Add stop to queue
+3. process queue, if stop match return; otherwise, try the linked bus (track visited bus)
+*/
+class Solution {
+    public int numBusesToDestination(int[][] routes, int S, int T) {
+        Set<Integer> visited = new HashSet<>();
+        Map<Integer, Set<Integer>> stopMap = new HashMap<>();
+        Queue<Integer> queue = new LinkedList<>();
+        // init
+        for (int i = 0; i < routes.length; i++) {
+            for (int stop : routes[i]) {
+                stopMap.putIfAbsent(stop, new HashSet<>());
+                stopMap.get(stop).add(i); // add bus route to stop
+            }
+        }
+        queue.offer(S);
+        int count = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            for (int i = 0; i < size; i++) { 
+                int stop = queue.poll(); // 1, 2, 7
+                if (stop == T) return count;
+                for (int bus : stopMap.get(stop)) {
+                    if (!visited.contains(bus)) {
+                        visited.add(bus);
+                        for (int nextStop : routes[bus]) {
+                            queue.offer(nextStop); // 3, 6, 7
+                        }
+                    }
+                }
+            }
+            count++;
+        }
+        
+        return -1;
+    }
+}
+```

Java/Cracking the Safe.java

@@ -0,0 +1,105 @@
+H
+1534220198
+tags: Math, DFS, Greedy
+
+#### Greedy, Iterative
+- For 2 passwords, the shortest situation is both passwords overlap for n-1 chars.
+- We can use a window to cut out last (n-1) substring and append with new candidate char from [k-1 ~ 0]
+- Track the newly formed string; if new, add the new char to overall result
+- Note: this operation will run for k^n times: for all spots of [0 ~ n - 1] each spot tries all k values [k-1 ~ 0]
+- Same concept as dfs
+
+#### DFS
+- Same concept: use window to cut out tail, and append with new candidate
+- do this for k^n = Math.pow(k, n) times
+
+```
+/*
+There is a box protected by a password. The password is n digits, 
+where each letter can be one of the first k digits 0, 1, ..., k-1.
+
+You can keep inputting the password, 
+the password will automatically be matched against the last n digits entered.
+
+For example, assuming the password is "345", I can open it when I type "012345", 
+but I enter a total of 6 digits.
+
+Please return any string of minimum length that is guaranteed to open the box 
+after the entire string is inputted.
+
+Example 1:
+Input: n = 1, k = 2
+Output: "01"
+Note: "10" will be accepted too.
+Example 2:
+Input: n = 2, k = 2
+Output: "00110"
+Note: "01100", "10011", "11001" will be accepted too.
+Note:
+n will be in the range [1, 4].
+k will be in the range [1, 10].
+k^n will be at most 4096.
+
+http://www.cnblogs.com/grandyang/p/8452361.html
+*/
+
+/*
+For 2 passwords, the shortest situation is both passwords overlap for n-1 chars.
+We can use a window to cut out last (n-1) substring and append with new candidate char from [k-1 ~ 0]
+Track the newly formed string; if new, add the new char to overall result
+Note: this operation will run for k^n times: for all spots of [0 ~ n - 1] each spot tries all k values [k-1 ~ 0]
+
+This is more greedy: will generate one correct solution
+*/
+class Solution {
+    public String crackSafe(int n, int k) {
+        //if (n == 1) return "0";
+        
+        Set<String> set = new HashSet<>();
+        StringBuffer sb = new StringBuffer();
+        for (int i = 0; i < n; i++) sb.append("0");
+        set.add(sb.toString());
+        
+        for (int i = 0; i < Math.pow(k, n); i++) {
+            String tail = sb.substring(sb.length() - n + 1); // last n - 1 chars
+            for (int j = k - 1; j >= 0; j--) {
+                String newStr = tail + j;
+                if (!set.contains(newStr)) {
+                    set.add(newStr);
+                    sb.append(j);
+                    break;
+                }
+            }
+        }
+        
+        return sb.toString();
+    }
+}
+
+
+// DFS
+class Solution {
+    public String crackSafe(int n, int k) {        
+        Set<String> visited = new HashSet<>();
+        StringBuffer sb = new StringBuffer();
+        for (int i = 0; i < n; i++) sb.append("0");
+        visited.add(sb.toString());
+        
+        // recursive, dfs
+        dfs(n, k, Math.pow(k, n), visited, sb);
+        return sb.toString();
+    }
+    
+    private void dfs(int n, int k, double total, Set<String> visited, StringBuffer sb) {
+        if (visited.size() == total) return;
+        String tail = sb.substring(sb.length() - n + 1);
+        for (int j = k - 1; j >= 0; j--) {
+            String newStr = tail + j;
+            if (visited.contains(newStr)) continue;
+            visited.add(newStr);
+            sb.append(j);
+            dfs(n, k, total, visited, sb);
+        }
+    }
+}
+```

Java/Graph Valid Tree.java

@@ -1,5 +1,5 @@
 M
-1532583365
+1534225885
 tags: DFS, BFS, Union Find, Graph 
 
 给一个数字n代表n nodes, marked from 1 ~ n, 和一串undirected edge int[][]. 
@@ -16,10 +16,12 @@
 - http://www.lintcode.com/en/problem/find-the-weak-connected-component-in-the-directed-graph/
 
 #### DFS
+- Very similar to `Redundant Connection`
 - Create adjacent list graph: Map<Integer, List<Integer>>
 - 检查: 
 - 1. 是否有cycle using dfs, check boolean[] visited
 - 2. 是否所有的node全部链接起来: validate if all edge connected: # of visited node should match graph size
+- IMPORTANT: use `pre` node to avoid linking backward/infinite loop such as (1)->(2), and (2)->(1)
 
 #### BFS
 - (还没做, 可以写一写)
@@ -97,10 +99,9 @@ private int find(int x) {
 */
 class Solution {
     public boolean validTree(int n, int[][] edges) {
-        // No node, false
         if (n == 0) return false;
 
-        Map<Integer, List<Integer>> graph = buildGraph(n, edges);
+        Map<Integer, Set<Integer>> graph = buildGraph(n, edges);
         Set<Integer> visited = new HashSet<>();
 
         // dfs(graph, visited, i, -1) and validate cycle
@@ -111,10 +112,10 @@ public boolean validTree(int n, int[][] edges) {
     }
 
     // build graph in form of adjacent list
-    private Map<Integer, List<Integer>> buildGraph(int n, int[][] edges) {
-        Map<Integer, List<Integer>> graph = new HashMap<>();
+    private Map<Integer, Set<Integer>> buildGraph(int n, int[][] edges) {
+        Map<Integer, Set<Integer>> graph = new HashMap<>();
         for (int i = 0; i < n; i++) {
-            if (!graph.containsKey(i)) graph.put(i, new ArrayList<>());
+            graph.putIfAbsent(i, new HashSet<>());
         }
         for (int[] edge: edges) {
             graph.get(edge[0]).add(edge[1]);
@@ -124,11 +125,12 @@ private Map<Integer, List<Integer>> buildGraph(int n, int[][] edges) {
     }
 
     // dfs: mark visited nodes, and keep dfs into children nodes
-    private boolean dfs(Map<Integer, List<Integer>> graph, Set<Integer> visited, int i, int pre) {
-        if (visited.contains(i)) return false;
-        visited.add(i);
-        for (int child : graph.get(i)) {
-            if (child != pre && !dfs(graph, visited, child, i)) return false;
+    private boolean dfs(Map<Integer, Set<Integer>> graph, Set<Integer> visited, int curr, int pre) {
+        if (visited.contains(curr)) return false;
+        visited.add(curr);
+        for (int child : graph.get(curr)) {
+            if (child == pre) continue;
+            if (!dfs(graph, visited, child, curr)) return false;
         }
         return true;
     }

Java/Isomorphic Strings.java

@@ -1,13 +1,16 @@
 E
+1534215677
+tags: Hash Table
 
-HashMap 来确认match。有几种情况考虑:
+#### HashMap
+- two failture cases:
+- same key, value not matching
+- two key maps to same value
 
+#### Previous note
 1. Match. 就是map.containsKey, map.containsValue, and char1 == char2. Perfect.
-
 2. Either Key not exist, or Value not exit. False;
-
 3. Both key and Value exist, but map.get(char1) != char2.  Miss-match. False.
-
 4. None of Key or Value exist in HashMap. Then add the match.
 
 ```
@@ -34,6 +37,24 @@ Hide Similar Problems (E) Word Pattern
 
 */
 
+class Solution {
+    public boolean isIsomorphic(String s, String t) {
+        if (s == null || t == null || s.length() != t.length()) return false;
+        Map<Character, Character> map = new HashMap<>();
+        
+        for (int i = 0; i < s.length(); i++) {
+            char charS = s.charAt(i), charT = t.charAt(i);
+            if (map.containsKey(charS)) {
+                if (map.get(charS) != charT) return false; // same key, value not matching
+            } else {
+                if (map.containsValue(charT)) return false; // two key maps to same value
+                map.put(charS, charT);
+            }
+        }
+        
+        return true;
+    }
+}
 
 //Use hashMap<Char,Char> to store matches. If conflict, return false
 public class Solution {

Java/Redundant Connection II.java

@@ -0,0 +1,85 @@
+H
+1534232150
+tags: Tree, DFS, Union Find, Graph
+
+#### Union Find
+- 讨论3种情况
+- http://www.cnblogs.com/grandyang/p/8445733.html
+
+```
+/*
+In this problem, a rooted tree is a directed graph such that, there is exactly one node (the root) for which all other nodes are descendants of this node, plus every node has exactly one parent, except for the root node which has no parents.
+
+The given input is a directed graph that started as a rooted tree with N nodes (with distinct values 1, 2, ..., N), with one additional directed edge added. The added edge has two different vertices chosen from 1 to N, and was not an edge that already existed.
+
+The resulting graph is given as a 2D-array of edges. Each element of edges is a pair [u, v] that represents a directed edge connecting nodes u and v, where u is a parent of child v.
+
+Return an edge that can be removed so that the resulting graph is a rooted tree of N nodes. If there are multiple answers, return the answer that occurs last in the given 2D-array.
+
+Example 1:
+Input: [[1,2], [1,3], [2,3]]
+Output: [2,3]
+Explanation: The given directed graph will be like this:
+  1
+ / \
+v   v
+2-->3
+Example 2:
+Input: [[1,2], [2,3], [3,4], [4,1], [1,5]]
+Output: [4,1]
+Explanation: The given directed graph will be like this:
+5 <- 1 -> 2
+     ^    |
+     |    v
+     4 <- 3
+Note:
+The size of the input 2D-array will be between 3 and 1000.
+Every integer represented in the 2D-array will be between 1 and N, where N is the size of the input array.
+*/
+
+/*
+- find inDegree == 2
+- union and return cycle item
+- if cycle not exist, return the inDegree==2 edge
+
+*/
+class Solution {
+    int[] parent;
+    public int[] findRedundantDirectedConnection(int[][] edges) {
+        int n = edges.length;
+        parent = new int[n + 1];
+
+        // find the edges where inDegree == 2 
+        int[] first = null, second = null;
+        for (int[] edge : edges) {
+            int x = edge[0], y = edge[1];
+            if (parent[y] == 0) {
+                parent[y] = x;
+            } else {
+                first = new int[]{parent[y], y};
+                second = new int[]{edge[0], edge[1]};
+                edge[1] = 0; // why?
+            }
+        }
+        // re-init unionFind
+        for (int i = 0; i <= n; i++) parent[i] = i;
+        
+        // Union
+        for (int[] edge : edges) {
+            int x = edge[0], y = edge[1];
+            if (y == 0) continue;
+            int parentX = find(x), parentY = find(y);
+            if (parentX == parentY) return first == null ? edge : first;
+            parent[parentX] = parentY;
+        }
+        
+        return second;
+    }
+    
+    public int find(int x) {
+        int parentX = parent[x];
+        if (parentX == x) return parentX;
+        return parent[x] = find(parentX);
+    }
+}
+```