h

Author: awangdev

Java/Frog Jump.java

@@ -0,0 +1,117 @@
+H
+1533535937
+tags: DP, Hash Table
+
+Frog jump 的题目稍微需要理解: 每个格子可以 jump k-1, k, k+1 steps, 而k取决于上一步所跳的步数. 默认 0->1 一定是跳了1步.
+
+注意: int[] stones 里面是stone所在的unit (不是可以跳的步数, 不要理解错).
+
+#### DP
+- 原本想按照corrdiante dp 来做, 但是发现很多问题, 需要track 不同的 possible previous starting spot.
+- 根据jiuzhang答案: 按照定义, 用一个 map of <stone, Set<possible # steps to reach stone>>
+- 每次在处理一个stone的时候, 都根据他自己的 set of <previous steps>, 来走下三步: k-1, k, or k+1 steps.
+- 每次走一步, 查看 stone + step 是否存在; 如果存在, 就加进 next position: `stone+step`的 hash set 里面
+
+##### 注意init
+- `dp.put(stone, new HashSet<>())` mark 每个stone的存在
+- `dp.get(0).add(0)` init condition, 用来做 dp.put(1, 1)
+
+##### 思想
+- 最终做下来思考模式, 更像是BFS的模式: starting from (0,0), add all possible ways 
+- 然后again, try next stone with all possible future ways ... etc
+
+```
+
+/*
+A frog is crossing a river. The river is divided into x units and at each unit 
+there may or may not exist a stone. The frog can jump on a stone, but it must not jump into the water.
+
+Given a list of stones' positions (in units) in sorted ascending order, 
+determine if the frog is able to cross the river by landing on the last stone. 
+Initially, the frog is on the first stone and assume the first jump must be 1 unit.
+
+If the frog's last jump was k units, then its next jump must be either k - 1, k, or k + 1 units. 
+Note that the frog can only jump in the forward direction.
+
+Note:
+
+The number of stones is ≥ 2 and is < 1,100.
+Each stone's position will be a non-negative integer < 231.
+The first stone's position is always 0.
+Example 1:
+
+[0,1,3,5,6,8,12,17]
+
+There are a total of 8 stones.
+The first stone at the 0th unit, second stone at the 1st unit,
+third stone at the 3rd unit, and so on...
+The last stone at the 17th unit.
+
+Return true. The frog can jump to the last stone by jumping 
+1 unit to the 2nd stone, then 2 units to the 3rd stone, then 
+2 units to the 4th stone, then 3 units to the 6th stone, 
+4 units to the 7th stone, and 5 units to the 8th stone.
+Example 2:
+
+[0,1,2,3,4,8,9,11]
+
+Return false. There is no way to jump to the last stone as 
+the gap between the 5th and 6th stone is too large.
+*/
+
+// simplified with helper function
+class Solution {
+    public boolean canCross(int[] stones) {
+        if (stones == null || stones.length == 0) return false;
+        Map<Integer, Set<Integer>> dp = new HashMap<>();
+        // Init: all stone slots has nothing on them
+        for (int stone : stones) {
+            dp.put(stone, new HashSet<>());
+        }
+        dp.get(0).add(0); // such that dp.get(0) will move (dp, 0-stone, 1-step) on index 0
+        for (int stone : stones) {
+            for (int k : dp.get(stone)) {
+                move(dp, stone, k);
+                move(dp, stone, k + 1);
+                move(dp, stone, k - 1);
+            }
+        }
+        int lastStone = stones[stones.length - 1];
+        return !dp.get(lastStone).isEmpty(); // able to reach
+    }
+    
+    private void move(Map<Integer, Set<Integer>> dp, int stone, int step) {
+        if (step > 0 && dp.containsKey(stone + step)) {
+            dp.get(stone + step).add(step);
+        }
+    }
+}
+
+// original 
+class Solution {
+    public boolean canCross(int[] stones) {
+        if (stones == null || stones.length == 0) return false;
+        int n = stones.length;
+        Map<Integer, Set<Integer>> dp = new HashMap<>();
+        for (int stone : stones) {
+            dp.put(stone, new HashSet<>());
+        }
+        dp.get(0).add(0);
+        for (int stone : stones) {
+            for (int k : dp.get(stone)) {
+                if (k - 1 > 0 && dp.containsKey(stone + k - 1)) { // k - 1
+                    dp.get(stone + k - 1).add(k - 1);
+                }
+                if (k > 0 && dp.containsKey(stone + k)) {// k
+                    dp.get(stone + k).add(k);
+                }
+                if (k + 1 > 0 && dp.containsKey(stone + k + 1)) { // k + 1
+                    dp.get(stone + k + 1).add(k + 1);
+                }
+            }
+        }
+        int lastStone = stones[n - 1];
+        return !dp.get(lastStone).isEmpty(); // able to reach
+    }
+}
+```

Java/Longest Substring with At Most Two Distinct Characters.java

@@ -0,0 +1,59 @@
+H
+1533538848
+tags: Hash Table, Two Pointers, String, Sliding Window
+
+如题.
+
+#### Two Pointer + HashMap
+- 原本想用 DP, 但是其实用 sliding window 的思想
+- sliding window 的切割: 用hashmap 存 last occurrance of char index; 
+- map.remove(c) 之后, 就等于彻底切掉了那一段; 那么 map.get(c) + 1 也就是新的 left window border
+
+```
+/*
+Given a string s , find the length of the longest substring t that contains at most 2 distinct characters.
+
+Example 1:
+
+Input: "eceba"
+Output: 3
+Explanation: t is "ece" which its length is 3.
+Example 2:
+
+Input: "ccaabbb"
+Output: 5
+Explanation: t is "aabbb" which its length is 5.
+
+*/
+
+/*
+Map<Character, Integer> to map last occurrance of certain character.
+if map.size() > 2, we'll remove trop off left-most char
+maintain max based on curr right - left
+*/
+class Solution {
+    public int lengthOfLongestSubstringTwoDistinct(String s) {
+        if (s == null || s.length() == 0) return 0;
+        int n = s.length();
+        Map<Character, Integer> lastOccurMap = new HashMap<>();
+        int left = 0, right = 0, max = 0;
+
+        while (right < n) {
+            if (lastOccurMap.size() <= 2) { // add new char
+                lastOccurMap.put(s.charAt(right), right++);
+            }
+            if (lastOccurMap.size() > 2) { // clean up left-most char
+                int leftMost = right;
+                for (int index : lastOccurMap.values()) {
+                    leftMost = Math.min(leftMost, index);
+                }
+                lastOccurMap.remove(s.charAt(leftMost));
+                left = leftMost + 1;
+            }
+            max = Math.max(max, right - left);
+        }
+
+        return max;
+    }
+}
+```

Java/Moving Average from Data Stream.java

@@ -1,6 +1,6 @@
 E
 1533510925
-tags:Design, Queue
+tags:Design, Queue, Sliding Window
 
 给一个interface, design一个structure, 能够计算moving window average.
 

Java/Read N Characters Given Read4 II - Call multiple times.java

@@ -0,0 +1,80 @@
+H
+1533532566
+tags: String, Enumeration
+
+Read N Character using `Read4(char[] buf)` 的加强版: 可以不断读 read(buf, n)
+
+#### String 
+- 注意String的index handle, 慢慢写edge case
+- 理解题目意思: `read4(char[] buf)` 这样的 `populate input object` 的function稍微少一点. 
+- 遇到时候, 仔细理解function用法, 不要慌乱. 其实思考方式很简单, 仔细handle string 还有 edge case就好了.
+
+```
+/*
+The API: int read4(char *buf) reads 4 characters at a time from a file.
+
+The return value is the actual number of characters read. For example, 
+it returns 3 if there is only 3 characters left in the file.
+
+By using the read4 API, implement the function int read(char *buf, int n) 
+that reads n characters from the file.
+
+Note:
+The read function may be called multiple times.
+
+Example 1: 
+
+Given buf = "abc"
+read("abc", 1) // returns "a"
+read("abc", 2); // returns "bc"
+read("abc", 1); // returns ""
+Example 2: 
+
+Given buf = "abc"
+read("abc", 4) // returns "abc"
+read("abc", 1); // returns ""
+
+ */
+
+/* The read4 API is defined in the parent class Reader4.
+      int read4(char[] buf); */
+
+/*
+Cache results from read4(char*); only read again if not enough; 
+Cache the read cacheIndex of read4 result;
+If read4 returns 0, just return ""; maybe have global variable to mark end.
+*/
+public class Solution extends Reader4 {
+    /**
+     * @param buf Destination buffer
+     * @param n   Maximum number of characters to read
+     * @return    The number of characters read
+     */
+    private char[] cache = new char[4];
+    private int cacheIndex = 0;
+    private int count = 0;
+    //private int index = 0;
+    private boolean isEnd = false;
+    public int read(char[] buf, int n) {
+        if (buf == null || n <= 0 || isEnd) return 0; // if read4 is ended, return 0;
+        
+        // decrease n for existing read4 content
+        int i = 0; // current iteration
+        while (cacheIndex > 0 && cacheIndex < count && i < n) {
+            buf[i++] = cache[cacheIndex++];
+        }
+        // read while using while loop until n is exhausted
+        while (i < n) {
+            cache = new char[4];
+            count = read4(cache);
+            int range = i + 3 < n ? count : Math.min(n - i, count);
+            System.arraycopy(cache, 0, buf, i, range);
+            i += range;
+            if (range < 4) cacheIndex = range;
+            if (count < 4 && range == count) isEnd = true;
+            if (count < 4) break;
+        }
+        return i;
+    }
+}
+```

Java/Read N Characters Given Read4.java

@@ -1,6 +1,6 @@
 E
 1533408053
-tags: String
+tags: String, Enumeration
 
 Read4 题目. 理解题目: 是有个input object buff, 会被populated with data.
 

Java/Shortest Distance from All Buildings.java

@@ -0,0 +1,46 @@
+H
+1533539906
+tags: BFS
+
+给Walls and Gates很像, 不同的是, 这道题要选一个 coordinate, having shortest sum distance to all buildings (marked as 1).
+
+#### BFS
+- BFS 可以 mark shortest distance from bulding -> any possible spot.
+- Try each building (marked as 1) -> BFS cover all 0. 
+- time: O(n^2) * # of building; use new visited[][] to mark visited for each building.
+- O(n^2) find smallest point/aggregation value.
+- 注意, 这道题我们update grid[][] sum up with shortest path value from building.
+- 最后找个min value 就好了, 甚至不用return coordinate.
+- 分析过, 还没有写.
+
+```
+
+/*
+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.
+Example:
+
+Input: [[1,0,2,0,1],[0,0,0,0,0],[0,0,1,0,0]]
+
+1 - 0 - 2 - 0 - 1
+|   |   |   |   |
+0 - 0 - 0 - 0 - 0
+|   |   |   |   |
+0 - 0 - 1 - 0 - 0
+
+Output: 7 
+
+Explanation: Given three buildings at (0,0), (0,4), (2,2), and an obstacle at (0,2),
+             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.
+
+ */
+```

Java/Sliding Window Maximum.java

@@ -1,4 +1,5 @@
 H
+tags: Sliding Window
 
 妙：用deque数据结构（实际上采用LinkedList的形式）来做一个递减的queue.
 每次把小于当前node的，全部剔除，剩下的，自然就是:最大的>第二大的>第三大的...ETC.

Java/Sliding Window Median.java

@@ -1,6 +1,6 @@
 H
 1533183594
-tags: Heap, Design, MaxHeap, MinHeap
+tags: Heap, Design, MaxHeap, MinHeap, Sliding Window
 
 Data Stream Median 的同理题目: 不只是不断增加的Sequence, 而且要remove item (保持一个window size)