Merge pull request #13 from daikaixian/master

homework for 3rd class

Author: AlgorithmStuQ

3rd/homework_1/id_80/BinaryTreeZigzagLevelOrderTravrsal.java

@@ -0,0 +1,59 @@
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        
+        //思路一： 和level order traversal 一样。 只是交替的变换一下顺序？
+        
+        
+        Queue<TreeNode> parentQueue = new LinkedList<>();
+        Queue<TreeNode> childrenQueue = new LinkedList<>();
+        
+        if (root == null) {
+            return new ArrayList<>();
+        }
+        
+        List<List<Integer>> list = new ArrayList<>();
+        List<Integer> subList = new ArrayList<>();
+        parentQueue.add(root);
+        int level = 0;
+        while (!parentQueue.isEmpty()) {
+            TreeNode node = parentQueue.poll();
+             if(level % 2 == 1) {
+                subList.add(0,node.val);
+             } else {
+                 subList.add(node.val);
+             }
+            
+            if(node.left != null) {
+                childrenQueue.add(node.left);
+            }
+            if(node.right != null) {
+                childrenQueue.add(node.right);
+            }
+           
+           
+            if(parentQueue.isEmpty()) {
+
+                parentQueue = childrenQueue;
+                childrenQueue= new LinkedList<>();
+               
+                  
+                list.add(subList);
+                subList = new ArrayList<>();
+                level ++;
+            }
+        
+        }
+        return list;
+        
+    }
+}

3rd/homework_2/id_80/WordSearch2.java

@@ -0,0 +1,44 @@
+
+class Solution {
+    
+    //放弃了。。还要用trie.
+    // 字典树。
+   Set<String> res = new HashSet<String>();
+    
+    public List<String> findWords(char[][] board, String[] words) {
+        Trie trie = new Trie();
+        for (String word : words) {
+            trie.insert(word);
+        }
+        
+        int m = board.length;
+        int n = board[0].length;
+        boolean[][] visited = new boolean[m][n];
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                dfs(board, visited, "", i, j, trie);
+            }
+        }
+        
+        return new ArrayList<String>(res);
+    }
+    
+    public void dfs(char[][] board, boolean[][] visited, String str, int x, int y, Trie trie) {
+        if (x < 0 || x >= board.length || y < 0 || y >= board[0].length) return;
+        if (visited[x][y]) return;
+        
+        str += board[x][y];
+        if (!trie.startsWith(str)) return;
+        
+        if (trie.search(str)) {
+            res.add(str);
+        }
+        
+        visited[x][y] = true;
+        dfs(board, visited, str, x - 1, y, trie);
+        dfs(board, visited, str, x + 1, y, trie);
+        dfs(board, visited, str, x, y - 1, trie);
+        dfs(board, visited, str, x, y + 1, trie);
+        visited[x][y] = false;
+    }
+}

3rd/homework_3/id_80/PathSum.java

@@ -0,0 +1,29 @@
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    
+    // 根节点为null怎么办？ 叶子节点为null又怎么办。
+    // 思路： DFS，没什么特别的吧。
+    
+    boolean result = false;
+    public boolean hasPathSum(TreeNode root, int sum) {
+        if(root == null) {
+            return false;
+        }
+        if (root.left == null && root.right == null) {
+            return root.val == sum ? true : false;
+        }
+        
+        boolean left = hasPathSum(root.left, sum - root.val);
+        
+        return left == true ? true : hasPathSum(root.right, sum - root.val);
+    }
+}

3rd/homework_4/id_80/LinkedListCycle2.java

@@ -0,0 +1,48 @@
+
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) {
+ *         val = x;
+ *         next = null;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode detectCycle(ListNode head) {
+        /**
+        * 证明的很漂亮
+        * Definitions:
+          Cycle = length of the cycle, if exists.
+          C is the beginning of Cycle, S is the distance of slow pointer from C when slow pointer meets fast pointer.
+
+          Distance(slow) = C + S, Distance(fast) = 2 * Distance(slow) = 2 * (C + S). To let slow poiner meets fast pointer, only            if fast pointer run 1 cycle more than slow pointer. Distance(fast) - Distance(slow) = Cycle
+            => 2 * (C + S) - (C + S)	= Cycle
+            =>	C + S = Cycle
+            =>	C = Cycle - S
+            => This means if slow pointer runs (Cycle - S) more, it will reaches C. So at this time, if there's another point2              running from head
+            => After C distance, point2 will meet slow pointer at C, where is the beginning of the cycle.
+        *
+        */
+        
+        
+        
+    ListNode slow = head, fast = head;
+	while(fast != null && fast.next != null) {
+		fast = fast.next.next;
+		slow = slow.next;
+		if (slow == fast) {
+			while (head != slow) {
+				head = head.next;
+				slow = slow.next;
+			}
+			return slow;				
+		}
+	}			
+	return null;
+        
+        
+    }
+}

3rd/homework_5/id_80/GenerateParentheses.java

@@ -0,0 +1,30 @@
+
+class Solution {
+    public List<String> generateParenthesis(int n) {
+        
+        //好像没什么具体思路啊。。如果去穷举？
+        // 思路1.构建一颗 level = 2*n 的树，每一棵树的左孩子都是左括号，右孩子都是右括号，根节点为左括号。然后dfs遍历，用stack去匹配。匹配成功则塞回到返回值中。可是建树本身无法完成。。。
+        // 看下别人的思路吧。 
+        // 没能理解这里面的玄机。。。。多想想吧
+        
+    
+    List<String> list = new ArrayList<String>();
+    generateOneByOne("", list, n, n);
+    return list;
+}
+public void generateOneByOne(String sublist, List<String> list, int left, int right){
+    if(left > right){
+        return;
+    }
+    if(left > 0){
+        generateOneByOne( sublist + "(" , list, left-1, right);
+    }
+    if(right > 0){
+        generateOneByOne( sublist + ")" , list, left, right-1);
+    }
+    if(left == 0 && right == 0){
+        list.add(sublist);
+        return;
+    }
+}
+}

3rd/homework_6/id_80/FindLargestValueInEachTreeRow.java

@@ -0,0 +1,55 @@
+
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<Integer> largestValues(TreeNode root) {
+        // 1.层次遍历找出最大值就好了啊。 用优先级队列去做层次遍历？
+        // 2。 思路二， DFS?也不是不可以。每次层次DFS，对应的level，去比较大小，最大的被替换。
+        
+        //来，dfs写一遍。
+        if (root == null) {
+            return new ArrayList<>();
+        }
+        
+        List<Integer> ret = new ArrayList<>();
+        findLargestValue(root, ret, 0);
+        return ret;
+        
+    }
+    
+    private void findLargestValue(TreeNode root, List<Integer> ret, int level){
+        if(ret.size() -1 < level){  //如果是新的一层。怎么处理，待会看
+            ret.add(root.val);
+        }
+        
+        if (root.val > ret.get(level)) {
+            ret.set(level, root.val);
+        }
+        
+        
+        if(root.left != null) {
+            findLargestValue(root.left, ret, level + 1);
+        }
+        if(root.right != null) {
+            findLargestValue(root.right, ret, level + 1);
+        }
+        
+    }
+    
+    
+    
+    
+    
+    
+    
+    
+    
+}

3rd/homework_7/id_80/NQueens.java

@@ -0,0 +1,55 @@
+
+class Solution {
+    public List<List<String>> solveNQueens(int n) {
+        
+        // 没有思路，好难。看答案了。
+        
+        // 
+        
+      
+        char[][] board = new char[n][n];
+        for(int i = 0; i < n; i++)
+            for(int j = 0; j < n; j++)
+                board[i][j] = '.';
+        List<List<String>> res = new ArrayList<List<String>>();
+        dfs(board, 0, res);
+        return res;
+    }
+    
+    private void dfs(char[][] board, int colIndex, List<List<String>> res) {
+        if(colIndex == board.length) {
+            res.add(construct(board));
+            return;
+        }
+        
+        for(int i = 0; i < board.length; i++) {
+            if(validate(board, i, colIndex)) {
+                board[i][colIndex] = 'Q';
+                dfs(board, colIndex + 1, res);
+                board[i][colIndex] = '.';
+            }
+        }
+    }
+    
+    private boolean validate(char[][] board, int x, int y) {
+        for(int i = 0; i < board.length; i++) {
+            for(int j = 0; j < y; j++) {
+                if(board[i][j] == 'Q' && (x + j == y + i || x + y == i + j || x == i))  //为什么不判断y == j?
+                    return false;
+            }
+        }
+        
+        return true;
+    }
+    
+    private List<String> construct(char[][] board) {
+        List<String> res = new LinkedList<String>();
+        for(int i = 0; i < board.length; i++) {
+            String s = new String(board[i]);
+            res.add(s);
+        }
+        return res;
+    }
+        
+    
+}

3rd/homework_8/id_80/ZeroOneMatrix.java

@@ -0,0 +1,45 @@
+
+
+
+class Solution {
+    
+        
+        // 应该创建一个新数组返回，对于矩阵中的每一个元素，去做BFS/DFS的check操作。
+        
+        
+        // 方法写出来了，可是StackOverflowError了。
+        //在想，是不是应该 遍历的时候，先从0开始刷。以0位中心，把周围刷完？
+        public int[][] updateMatrix(int[][] matrix) {
+        int m = matrix.length;
+        int n = matrix[0].length;
+        
+        Queue<int[]> queue = new LinkedList<>();
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (matrix[i][j] == 0) {
+                    queue.offer(new int[] {i, j});
+                }
+                else {
+                    matrix[i][j] = Integer.MAX_VALUE;
+                }
+            }
+        }
+        
+        int[][] dirs = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
+        
+        while (!queue.isEmpty()) {
+            int[] cell = queue.poll();
+            for (int[] d : dirs) {
+                int r = cell[0] + d[0];
+                int c = cell[1] + d[1];
+                if (r < 0 || r >= m || c < 0 || c >= n || 
+                    matrix[r][c] <= matrix[cell[0]][cell[1]] + 1) continue;
+                queue.add(new int[] {r, c});
+                matrix[r][c] = matrix[cell[0]][cell[1]] + 1;
+            }
+        }
+        
+        return matrix;
+    }
+    
+}