@@ -95,7 +95,7 @@ public static void main(String[] args) {
             gct.printTable("ReviewPage.md", outputContent);
         } else if (args != null && args[0].contains("tags")) {//Wordpress
             outputContent = gct.generateTagREADME(listOfFiles);
-            gct.printTable("TagsREADME.txt", outputContent);
+            gct.printTable("TagREADME.md", outputContent);
         } else if (args != null && args[0].contains("all")) {
             outputContent = gct.generateREADME(listOfFiles);
             gct.printTable("README.md", outputContent);
@@ -104,7 +104,7 @@ public static void main(String[] args) {
             outputContent = gct.generateReviewPage(listOfFiles);
             gct.printTable("ReviewPage.md", outputContent);
             outputContent = gct.generateTagREADME(listOfFiles);
-            gct.printTable("TagsREADME.md", outputContent);
+            gct.printTable("TagREADME.md", outputContent);
             outputContent = gct.generateTagReviewPage(listOfFiles);
             gct.printTable("TagReviewPage.md", outputContent);
         }
 
@@ -1,20 +1,126 @@
-H
+R
+1521176156
+tags: Divide and Conquer, Heap, Binary Indexed Tree, Segment Tree, Sweep Line
 
-又叫做skyline
+又叫做skyline. 用Sweep Line做的O(nLogN), 但是貌似还有很多做法: segement tree, hashheap, treeSet?
 
-看网上的解答做， 思路很漂亮。 （http://codechen.blogspot.com/2015/06/leetcode-skyline-problem.html?_sm_au_=isVmHvFmFs40TWRt）
+#### 方法1: Sweep Line, Time O(nLogN), Space O(n)
+original reference http://codechen.blogspot.com/2015/06/leetcode-skyline-problem.html?_sm_au_=isVmHvFmFs40TWRt
 
-跟scan line的approach类似:      
-1. 把所有点分出来， 每个点有index x, 再加上一个height.         
-2. 在这个list上排序，根据index和height（注意用负数标记building start point,这样保证start在end 之前。）. 叫做 heightPoints            
-3. 在processs时候用max-heap (reversed priorityqueue)，在ieteraete heightPoints 来存最大的height . 遇到peek,就是一个合理的解    
-    处理1：因为start,end的height都存在了heightPoints里面，这里就是用来check end of bulding的，然后把height 从queue里面remove.
-    处理2：重复x 上面的许多height?  priorityqueue给了我们最高，这okay了；那么其他的重复点，用一个int prev来mark之前做过的，一旦重复，跳过。
+sweep line:
+- 把所有点分出来， 每个点有index x, 再加上一个height.         
+- 在这个list上排序，根据index和height. 注意用负数标记building start point height, 这样保证start在end 之前
+- 用负数的height标记start: 在priority queue里面同一个x-pos比较 startPoint.height, endPoint.height 的时候, 因为end height是整数, 所以compare时会自动把start point放在end point前面
+- 当然了, 如果两个 start point比较, 第二个point的负数超大的话(也就是height很高), 就会顺理compare return正数, 成章形成倒位
+- 在processs时候用max-heap (reversed priorityqueue)，再iterate heightPoints 来存最大的height . 遇到peek,就是一个合理的解    
+- heightQueue里面加一个0, 用来在结尾的时候做closure
 
-想法非常natural。 大题目，脑子乱。    
-看了解答再去想，挺naturally doable的。
+#### 方法2: Segment Tree
+REVIEW
+
+Binary Indexed Tree?
+
+HashHeap?
 
 ```
+/*
+LeetCode:
+A city's skyline is the outer contour of the silhouette formed by all the buildings in that city
+when viewed from a distance. Now suppose you are given the locations and height of all the buildings
+as shown on a cityscape photo (Figure A), write a program to output the skyline formed by these buildings
+collectively (Figure B).
+
+The geometric information of each building is represented by a triplet of integers [Li, Ri, Hi],
+where Li and Ri are the x coordinates of the left and right edge of the ith building, respectively,
+and Hi is its height. It is guaranteed that 0 ≤ Li, Ri ≤ INT_MAX, 0 < Hi ≤ INT_MAX, and Ri - Li > 0.
+You may assume all buildings are perfect rectangles grounded on an absolutely flat surface at height 0.
+
+For instance, the dimensions of all buildings in Figure A are recorded as:
+[ [2 9 10], [3 7 15], [5 12 12], [15 20 10], [19 24 8] ] .
+
+The output is a list of "key points" (red dots in Figure B) in the format of
+[ [x1,y1], [x2, y2], [x3, y3], ... ] that uniquely defines a skyline.
+A key point is the left endpoint of a horizontal line segment. Note that the last key point,
+where the rightmost building ends, is merely used to mark the termination of the skyline,
+and always has zero height. Also, the ground in between any two adjacent buildings
+should be considered part of the skyline contour.
+
+For instance, the skyline in Figure B should be represented as:
+[ [2 10], [3 15], [7 12], [12 0], [15 10], [20 8], [24, 0] ].
+
+Notes:
+
+The number of buildings in any input list is guaranteed to be in the range [0, 10000].
+The input list is already sorted in ascending order by the left x position Li.
+The output list must be sorted by the x position.
+There must be no consecutive horizontal lines of equal height in the output skyline. For instance, [...[2 3], [4 5], [7 5], [11 5], [12 7]...] is not acceptable; the three lines of height 5 should be merged into one in the final output as such: [...[2 3], [4 5], [12 7], ...]
+
+*/
+
+/*
+Thoughts:
+Sweep Line. 
+1. Store the building start/end points into a Point object.
+2. PriorityQueue on the Point: height low -> high && position lowX -> highX
+3. Loop over PointQueue, and store the heights in a separate maxQueue
+4. Based on the currPeak and prevPeak to detect diff: when there is a diff, there is a recording point.
+   Keeping add start height into the maxHeap, and remove end points whenever facing one.
+
+*/
+class Solution {
+    class Point {
+        int pos;
+        int height;
+        public Point(int pos, int height) {
+            this.pos = pos;
+            this.height = height;
+        }
+    }
+    public List<int[]> getSkyline(int[][] buildings) {
+        List<int[]> rst = new ArrayList<>();
+        if (buildings == null || buildings.length == 0 || buildings[0] == null || buildings[0].length == 0) {
+            return rst;
+        }
+        int m = buildings.length;
+        // Sort points(xPos, height, isStart:boolean) by height && xPos with queue
+        PriorityQueue<Point> queue = new PriorityQueue<Point>(new Comparator<Point>() {
+           public int compare(Point a, Point b) {
+               if (a.pos == b.pos) {
+                   return a.height - b.height;
+               } else {
+                   return a.pos - b.pos;
+               }
+           }
+        });
+        for (int i = 0; i < m; i++) {
+            queue.offer(new Point(buildings[i][0], -buildings[i][2]));
+            queue.offer(new Point(buildings[i][1], buildings[i][2]));
+        }
+        
+        // Mark height and calcualte the outline point.
+        PriorityQueue<Integer> maxHeightQueue = new PriorityQueue<>(Collections.reverseOrder());
+        maxHeightQueue.offer(0);
+        int prevPeak = maxHeightQueue.peek();
+
+        while (!queue.isEmpty()) {
+            Point point = queue.poll();
+            if (point.height < 0) {
+                maxHeightQueue.offer(-point.height);
+            } else { // is end point of a building
+                maxHeightQueue.remove(point.height);
+            }
+            
+            int currPeak = maxHeightQueue.peek();
+            if (currPeak != prevPeak) {
+                rst.add(new int[]{point.pos, currPeak});
+                prevPeak = currPeak;
+            }
+        }
+        return rst;
+    }
+}
+
+
 /*
 LintCode description:
 Given N buildings in a x-axis，each building is a rectangle and can be represented by a triple (start, end, height)，
 
@@ -1,9 +1,15 @@
 M
+1521167295
+tags: Heap, Greedy, Sort, Sweep Line
 
+给一串数字pair, 代表会议的开始/结束时间. 找同时又多少个会议发生(需要多少件房间)
 
-方法1:PriorityQueue + 一个Class来解决。Ｏ(nlogn)
+#### 方法1
+- PriorityQueue + 一个Class来解决.Ｏ(nlogn)
+- 跟 Number of Airpline in the sky是同一道题
 
-方法2:这里有尝试了一下用一个sorted Array + HashMap： 也还行，但是handle edge的时候,HashMap 要小心，因为相同时间start和end的map key 就会重复了。
+#### 方法2: 尝试了一下用一个sorted Array + HashMap
+也还行，但是handle edge的时候,HashMap 要小心，因为相同时间start和end的map key 就会重复了。
 
 ```
 /*
@@ -19,13 +25,26 @@
 */
 
 
-
-
-// Similar to Meeting Room I, using Point class and Priorityqueue
-// Creating a customized class, but makes the problem a bit easier to think.
-public class Solution {
+/**
+ * Definition for an interval.
+ * public class Interval {
+ *     int start;
+ *     int end;
+ *     Interval() { start = 0; end = 0; }
+ *     Interval(int s, int e) { start = s; end = e; }
+ * }
+ */
+/*
+Thoughts:
+Counts the num of concurrent meetings.
+Use sweep line to modle the inverval into time Points, where 1 means start of meeting and -1 means end of meeting.
+Sort all points by time stamp, and accumulate +1, -1
+Mark the max of count
+*/
+class Solution {
     class Point {
-        int pos, flag;
+        int pos;
+        int flag;
         public Point(int pos, int flag) {
             this.pos = pos;
             this.flag = flag;
@@ -35,30 +54,31 @@ public int minMeetingRooms(Interval[] intervals) {
         if (intervals == null || intervals.length == 0) {
             return 0;
         }
-        
-        PriorityQueue<Point> queue = new PriorityQueue<Point>(2, new Comparator<Point>() {
-            public int compare(Point p1, Point p2) {
-                return p1.pos - p2.pos;
+        int count = 0;
+        int max = 0;
+        PriorityQueue<Point> queue = new PriorityQueue<Point>(new Comparator<Point>() {
+            public int compare(Point a, Point b) {
+                return a.pos - b.pos;
             }
         });
 
-        for (int i = 0; i < intervals.length; i++) {
-            queue.offer(new Point(intervals[i].start, 1));
-            queue.offer(new Point(intervals[i].end, -1));
+        for (Interval interval: intervals) {
+            queue.offer(new Point(interval.start, 1));
+            queue.offer(new Point(interval.end, -1));
         }
-        int count = 0;
-        int rst = 0;
+        
         while (!queue.isEmpty()) {
-            Point p = queue.poll();
-            count += p.flag;
-            while (!queue.isEmpty() && p.pos == queue.peek().pos) {
-                p = queue.poll();
-                count += p.flag;
+            Point curr = queue.poll();
+            count += curr.flag;
+            while (!queue.isEmpty() && curr.pos == queue.peek().pos) {
+                curr = queue.poll();
+                count += curr.flag;
             }
-            rst = Math.max(count, rst);
+            
+            max = Math.max(count, max);
         }
 
-        return rst;
+        return max;
     }
 }
 
 
@@ -3,6 +3,81 @@
 为啥可以不管不无地剔除？
 因为我们只在乎最大值的存在；而任何小于当前（正要新就加进去的）值的，反正以后也成不了最大值，于是扔掉！
 ```
+/*
+LeetCode:
+Given an array nums, there is a sliding window of size k which is moving 
+from the very left of the array to the very right. 
+You can only see the k numbers in the window. 
+Each time the sliding window moves right by one position.
+
+For example,
+Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.
+
+Window position                Max
+---------------               -----
+[1  3  -1] -3  5  3  6  7       3
+ 1 [3  -1  -3] 5  3  6  7       3
+ 1  3 [-1  -3  5] 3  6  7       5
+ 1  3  -1 [-3  5  3] 6  7       5
+ 1  3  -1  -3 [5  3  6] 7       6
+ 1  3  -1  -3  5 [3  6  7]      7
+Therefore, return the max sliding window as [3,3,5,5,6,7].
+
+Note: 
+You may assume k is always valid, ie: 1 ≤ k ≤ input array's size for non-empty array.
+
+Follow up:
+Could you solve it in linear time?
+
+*/
+
+/*
+Thoughts:
+Brutle way: for every k window, calculate the max O(nk)
+Can use priority queue to track max => O(nLogK) => O(nLogN)
+Linear time: O(n)?
+
+Want to maintain the window, a deque, where right-most element in the window is the lowest value in the deque.
+1. when adding new element, we need to clean up the deque bottom
+2. when removing item, simply just match see if any top max is match; if match, remove it.
+
+Deque always have all unique max values, with right-most window element as smallest max in the deque.
+
+*/
+class Solution {
+    public int[] maxSlidingWindow(int[] nums, int k) {
+        if (nums == null || nums.length < k || k <= 0) {
+            return new int[0];
+        }
+        int[] rst = new int[nums.length - k + 1];
+        Deque<Integer> deque = new ArrayDeque<Integer>();
+        for (int i = 0; i < k - 1; i++) {
+            inQueue(deque, nums[i]);
+        }
+        
+        for (int i = k - 1; i < nums.length; i++) {
+            inQueue(deque, nums[i]); // clean up and add new smallest maximum, if applicable
+            rst[i - k + 1] = deque.peekFirst();
+            outQueue(deque, nums[i - k + 1]); // remove top max if the num === max
+        }
+        return rst;
+    }
+    
+    private void inQueue(Deque<Integer> deque, int num) {
+        while (!deque.isEmpty() && deque.peekLast() < num) { // top
+            deque.pollLast();
+        }
+        deque.offerLast(num);
+    }
+    
+    private void outQueue(Deque<Integer> deque, int num) {
+        if (deque.peekFirst() == num) {
+            deque.pollFirst();
+        }
+    }
+}
+
+
 /*
 Given an array of n integer with duplicate number, and a moving window(size k), move the window at each iteration from the start of the array, find the maximum number inside the window at each moving.
 
 
@@ -139,6 +139,15 @@ Segment Tree
 - 查找前缀
 
 
+### Deque
+- linear collection that supports insertion and removal at both ends. Pronounced 'deck'
+- It's a queue && stack
+- new ArrayDeque<Integer>()
+- head/top: offerFirst(), pollFirst(), peekFirst()
+- tail/bottom: offerLast(), pollLast(), peekLast() 
+- 双端queue: 维护一个候选可能的最大值集合
+- ex: Sliding WIndow Maximum
+
 ### Graph
 
 Graph
@@ -163,10 +172,12 @@ Two Pointers
 - 有时候在index上二分, mid是index; 但是有时候, 会在数值上二分, 那么mid就是value, 忌讳不要死板地套用nums[mid]
 
 #### 二分思想
+- 按值二分，需要怎么二分性
 - 找到可能的解的范围
 - 猜答案
 - 检验答案 (match/if/else ...)
 - 调整搜索范围
+- Find Peak Element II
 
 ### Sort
 
@@ -308,6 +319,13 @@ Design
 - 加一个数
 - 删一个数
 
+##### Sweep Line
+- 见到区间需要排序就可以考虑扫描线
+- 事件往往是以区间的形式存在
+- 区间两端代表事件的开始和结束
+- 需要排序
+- Meeting Room I, II
+