clean

Author: awangdev

Java/Backspace String Compare.java

@@ -0,0 +1,69 @@
+E
+1533516441
+tags: Two Pointers, Stack
+
+```
+/*
+Given two strings S and T, return if they are equal when both are typed into empty text editors. 
+# means a backspace character.
+
+Example 1:
+
+Input: S = "ab#c", T = "ad#c"
+Output: true
+Explanation: Both S and T become "ac".
+Example 2:
+
+Input: S = "ab##", T = "c#d#"
+Output: true
+Explanation: Both S and T become "".
+Example 3:
+
+Input: S = "a##c", T = "#a#c"
+Output: true
+Explanation: Both S and T become "c".
+Example 4:
+
+Input: S = "a#c", T = "b"
+Output: false
+Explanation: S becomes "c" while T becomes "b".
+Note:
+
+1 <= S.length <= 200
+1 <= T.length <= 200
+S and T only contain lowercase letters and '#' characters.
+Follow up:
+
+Can you solve it in O(N) time and O(1) space?
+
+*/
+
+/*
+Stack to take elements, and pop when # if reached.
+compare the two stacks at the end.
+time/space: O(n)
+*/
+class Solution {
+    public boolean backspaceCompare(String S, String T) {
+        if (S == null || T == null) return false;
+        
+        return type(S).equals(type(T));
+    }
+    
+    private String type(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (c == '#') {
+                if (!stack.isEmpty()) stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        StringBuffer sb = new StringBuffer();
+        while (!stack.isEmpty()) {
+            sb.append(stack.pop());
+        }
+        return sb.toString();
+    }
+}
+```

Java/Diameter of Binary Tree.java

@@ -0,0 +1,57 @@
+E
+1533515503
+tags: Tree
+
+找longest path (include or not include root)
+
+跟Binary Tree Maximum Path Sum 的想法一样: 处理single path, 或者combined path (do not include curr root)
+
+#### Singlepath, combined path
+- `int[]{combinedPath, singlePath}`;
+- pick single path + 1: `singlePath = Math.max(left[1] , right[1]) + 1`;
+- complete left/right child, or join curr root: `combinedPath = Math.max(Math.max(left[0], right[0]), left[1] + right[1] + 1)`;
+
+```
+/*
+Given a binary tree, you need to compute the length of the diameter of the tree. 
+The diameter of a binary tree is the length of the longest path between any two nodes in a tree. 
+This path may or may not pass through the root.
+
+Example:
+Given a binary tree 
+          1
+         / \
+        2   3
+       / \     
+      4   5    
+Return 3, which is the length of the path [4,2,1,3] or [5,2,1,3].
+
+Note: The length of path between two nodes is represented by the number of edges between them.
+
+
+*/
+
+/*
+No special condition: left+root+right, or left, or right
+recursive on itself.
+end condition: if null -> 0, if leaf -> 1
+*/
+class Solution {
+    public int diameterOfBinaryTree(TreeNode root) {
+        if (root == null) return 0;
+        int[] rst = dfs(root);
+        
+        return Math.max(rst[0], rst[1]) - 1;
+    }
+    
+    private int[] dfs(TreeNode root) {
+        if (root == null) return new int[] {0, 0};
+        
+        int[] left = dfs(root.left);
+        int[] right = dfs(root.right);
+        int singlePath = Math.max(left[1] , right[1]) + 1; // pick single path + 1
+        int combinedPath = Math.max(Math.max(left[0], right[0]), left[1] + right[1] + 1); // complete left/right child, or join curr root.
+        return new int[]{combinedPath, singlePath};
+    }
+}
+```

Java/Flood Fill.java

@@ -0,0 +1,75 @@
+E
+1533512047
+tags: DFS
+
+Same as MS Paint
+
+#### DFS 
+- track `boolean[][] visited`, validate before dfs
+
+```
+/*
+An image is represented by a 2-D array of integers, 
+each integer representing the pixel value of the image (from 0 to 65535).
+
+Given a coordinate (sr, sc) representing the starting pixel (row and column) of the flood fill, 
+and a pixel value newColor, "flood fill" the image.
+
+To perform a "flood fill", consider the starting pixel, 
+plus any pixels connected 4-directionally to the starting pixel of the same color as the starting pixel, 
+plus any pixels connected 4-directionally to those pixels (also with the same color as the starting pixel), 
+and so on. Replace the color of all of the aforementioned pixels with the newColor.
+
+At the end, return the modified image.
+
+Example 1:
+Input: 
+image = [[1,1,1],[1,1,0],[1,0,1]]
+sr = 1, sc = 1, newColor = 2
+Output: [[2,2,2],[2,2,0],[2,0,1]]
+Explanation: 
+From the center of the image (with position (sr, sc) = (1, 1)), all pixels connected 
+by a path of the same color as the starting pixel are colored with the new color.
+Note the bottom corner is not colored 2, because it is not 4-directionally connected
+to the starting pixel.
+Note:
+
+The length of image and image[0] will be in the range [1, 50].
+The given starting pixel will satisfy 0 <= sr < image.length and 0 <= sc < image[0].length.
+The value of each color in image[i][j] and newColor will be an integer in [0, 65535].
+
+*/
+
+/*
+dfs, then update curr color.
+mark boolean visited[][]
+*/
+class Solution {
+    int[] dx = {1, -1, 0, 0};
+    int[] dy = {0, 0, 1, -1};
+    boolean[][] visited;
+    public int[][] floodFill(int[][] image, int sr, int sc, int newColor) {
+        int m = image.length, n = image[0].length;
+        visited = new boolean[m][n];
+        dfs(image, sr, sc, image[sr][sc], newColor);
+        return image;
+    }
+
+    private void dfs(int[][] image, int sr, int sc, int original, int newColor) {
+        image[sr][sc] = newColor;
+        visited[sr][sc] = true;
+
+        for (int i = 0; i < 4; i++) {
+            int x = sr + dx[i], y = sc + dy[i];
+            if (validate(image, x, y, original)) {
+                dfs(image, x, y, original, newColor);
+            }
+        }
+    }
+
+    private boolean validate(int[][] image, int x, int y, int original) {
+        int m = image.length, n = image[0].length;
+        return x >= 0 && x < m && y >= 0 && y < n && image[x][y] == original && !visited[x][y];
+    }
+}
+```

Java/Intersection of Two Linked Lists.java

@@ -1,6 +1,6 @@
 E
-tags: Linked List
 1525664839
+tags: Linked List
 
 给两个 linked list, 问从哪个node开始, 两个 linked list 开始有重复?
 

Java/Move Zeroes.java

@@ -0,0 +1,43 @@
+E
+1533511284
+tags: Array, Two Pointers
+
+Move non-zero elements to front of array; preseve order.
+
+#### Two Pointers
+- Outside pointer that moves in certain condition. 
+- Save appropirate elements
+
+```
+/*
+Given an array nums, write a function to move all 0's to the end of it
+while maintaining the relative order of the non-zero elements.
+
+Example:
+
+Input: [0,1,0,3,12]
+Output: [1,3,12,0,0]
+Note:
+
+You must do this in-place without making a copy of the array.
+Minimize the total number of operations.
+*/
+/*
+- Use pointer to move all elements to non-zero index.
+- set remaining list -> 0
+*/
+class Solution {
+    public void moveZeroes(int[] nums) {
+        if (nums == null || nums.length == 0) return;
+        int index = 0;
+        for (int i = 0; i < nums.length; i++) {
+            if (nums[i] != 0) {
+                nums[index++] = nums[i];
+            }
+        }
+        for (int i = index; i < nums.length; i++) {
+            nums[i] = 0;
+        }
+    }
+}
+```

Java/Moving Average from Data Stream.java

@@ -0,0 +1,51 @@
+E
+1533510925
+tags:Design, Queue
+
+给一个interface, design一个structure, 能够计算moving window average.
+
+#### Queue
+- 读懂题目, 注意average 和 window 的处理.
+- 简单的queue.size() comparison
+
+```
+/**
+Given a stream of integers and a window size, 
+calculate the moving average of all integers in the sliding window.
+
+For example,
+MovingAverage m = new MovingAverage(3);
+m.next(1) = 1
+m.next(10) = (1 + 10) / 2
+m.next(3) = (1 + 10 + 3) / 3
+m.next(5) = (10 + 3 + 5) / 3
+ */
+
+class MovingAverage {
+    double sum;
+    int size;
+    Queue<Integer> queue;
+    
+    /** Initialize your data structure here. */
+    public MovingAverage(int size) {
+        this.sum = 0.0;
+        this.size = size;
+        this.queue = new LinkedList<>();
+    }
+    
+    public double next(int val) {
+        sum += val;
+        queue.offer(val);
+        if (queue.size() > size) {
+            sum -= queue.poll();
+        }
+        return sum / queue.size();
+    }
+}
+
+/**
+ * Your MovingAverage object will be instantiated and called as such:
+ * MovingAverage obj = new MovingAverage(size);
+ * double param_1 = obj.next(val);
+ */
+```