add some more questions and memo

Author: chihungyu1116

207 Course Schedule.js

@@ -8,17 +8,25 @@
  * @return {boolean}
  */
 
+ // http://www.cnblogs.com/Liok3187/p/4752700.html
+
 var constructGraph = function(numNodes, pre) {
     var nodes = [];
     for (var i = 0; i < numNodes; i++) {
         var node = {};
         node.neighbors = [];
-        nodes[i] = node;
+        nodes.push(node);
     }
     for (var j = 0; j < pre.length; j++) {
-        var s = pre[j][1];
-        var d = pre[j][0];
-        nodes[s].neighbors.push(nodes[d]);
+        var requiredCourse = pre[j][1];
+        var course = pre[j][0];
+        // pushing course that require required-course to it's neighbor
+        // when we go to the required-course, and traverse it's neighbors, we want to make sure that those neighbor doesn't have others that nodes
+        // that required those neighbor plus those neighbor's required-course
+        // example [1,0], [0,2], [2,1]
+        // 1 required 0, 0 required 2, and 2 required 1
+        // it creates loop
+        nodes[requiredCourse].neighbors.push(nodes[course]);
     }
     return nodes;
 }
@@ -42,9 +50,13 @@ var canFinish = function(numCourses, prerequisites) {
     var nodes = constructGraph(numCourses, prerequisites);
 
     for (var i = 0; i < nodes.length; i++) {
-        console.log('nodes i',nodes[i])
-        var hasCycle = dfs(nodes[i], []);
+        var parent = [];
+        var hasCycle = dfs(nodes[i], parent);
+
+        console.log(hasCycle, i, nodes[i], parent)
         if (hasCycle) return false;
     }
     return true;
-};
+};
+
+canFinish(5, [[0,1],[1,2],[1,3],[1,4],[2,3]])

215 Kth Largest Element in an Array.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def findKthLargest(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: int
+        """
+
+        pivot = random.choice(nums);
+        nums1, nums2 = [], []
+        for num in nums:
+          if num > pivot:
+            nums1.append(num)
+          elif num < pivot:
+            nums2.append(num)
+
+        if k <= len(nums1):
+          return self.findKthLargest(nums1, k)
+        if k > len(nums) - len(nums2): # draw a graph to visualize it! It's not in the top k assortment, but in the small section
+          return self.findKthLargest(nums2, k - (len(nums) - len(nums2)))
+
+        return pivot

289. Game of Life.js

@@ -0,0 +1,67 @@
+/**
+ * @param {number[][]} board
+ * @return {void} Do not return anything, modify board in-place instead.
+ */
+var gameOfLife = function(board) {
+    // 3 over-population or under population
+    // 2 means reproduction
+    // 1 is alive
+    // 0 is dead
+    // if mod 2 === 1 means the current state is alive else dead
+    
+    
+    var rows = board.length;
+    var cols = board[0].length;
+    
+    for(var i = 0; i < rows; i++) {
+        for(var j = 0; j < cols; j++) {
+            var cur = board[i][j];
+            var count = 0;
+            
+            if(i - 1 >= 0 && j -1 >= 0 && (board[i - 1][j - 1])%2 === 1) {
+                count++;
+            }
+            if(i - 1 >= 0 && (board[i - 1][j])%2 === 1) {
+                count++;
+            }
+            if(i - 1 >= 0 && j + 1 < cols && (board[i - 1][j + 1])%2 === 1) {
+                count++;
+            }
+            if(j - 1 >= 0 && (board[i][j - 1])%2 === 1) {
+                count++;
+            }
+            if(j + 1 < cols && (board[i][j + 1])%2 === 1) {
+                count++;
+            }
+            if(i + 1 < rows && j - 1 >= 0 && (board[i + 1][j - 1])%2 === 1) {
+                count++;
+            }
+            if(i + 1 < rows && (board[i + 1][j])%2 === 1) {
+                count++;
+            }
+            if(i + 1 < rows && j + 1 < cols && (board[i + 1][j + 1])%2 === 1) {
+                count++;
+            }
+            
+            if(board[i][j] === 1) {
+                if(count > 3 || count < 2) {
+                    board[i][j] = 3;
+                }
+            } else {
+                if(count === 3) {
+                    board[i][j] = 2;
+                }
+            }
+        }
+    }
+      
+    for(i = 0; i < rows; i++) {
+        for(j = 0; j < cols; j++) {
+            if(board[i][j] === 3) {
+                board[i][j] = 0;
+            } else if(board[i][j] === 2) {
+                board[i][j] = 1;
+            }
+        }
+    }
+};

300 Longest Increasing Subsequence.js

@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var lengthOfLIS = function(nums) {
+    var size = nums.length;
+    
+    if(size === 0) {
+        return 0;
+    }
+    
+    var dp = Array.from({length: size}, () => 1);
+    
+    for(var i = 0; i < size; i++) {
+        for(var j = 0; j < i; j++) {
+            if(nums[i] > nums[j]) {
+                dp[i] = Math.max(dp[i], dp[j] + 1);
+            }
+        }
+    }
+    
+    return Math.max.apply(null, dp);
+};

335 Self Crossing.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} x
+ * @return {boolean}
+ */
+ 
+//  http://www.cnblogs.com/grandyang/p/5216856.html
+var isSelfCrossing = function(x) {
+    
+    for(var i = 3; i < x.length; i++) {
+        if (x[i] >= x[i - 2] && x[i - 3] >= x[i - 1]) {
+            return true;
+        }
+        if(i >= 4 && x[i-1] == x[i-3] && x[i] >= (x[i-2] - x[i-4])) {
+            return true;
+        }
+        if(i >= 5 && x[i-2] >= x[i-4] && x[i-3] >= x[i-1] && x[i-1] >= (x[i-3] - x[i-5]) && x[i] >= (x[i-2] - x[i-4])) {
+            return true;
+        }
+    }
+    
+    return false;
+};

37 Sudoku Solver.js

@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+ 
+// http://blog.csdn.net/yutianzuijin/article/details/11499917
+var findMedianSortedArrays = function(nums1, nums2) {
+    var m = nums1.length;
+    var n = nums2.length;
+    var total = m + n;
+    
+    if(total%2 === 1) {
+        return findKth(nums1, m, nums2, n, parseInt(total/2) + 1);
+    } else {
+        return (findKth(nums1, m, nums2, n, parseInt(total/2)) + findKth(nums1, m, nums2, n, parseInt(total/2) + 1))/2;
+    }
+};
+
+
+function findKth(a, m, b, n, k) {
+    // always assume that m is equal or smaller than n
+    if(m > n) {
+        return findKth(b, n, a, m, k);
+    }
+    
+    if(m === 0) {
+        return b[k-1];
+    }
+    
+    if(k === 1) {
+        return Math.min(a[0],b[0]);
+    }
+    
+    // divide k into two parts
+    var pa = Math.min(parseInt(k/2), m);
+    var pb = k - pa;
+    
+    if(a[pa - 1] < b[pb - 1]) {
+        return findKth(a.slice(pa), m - pa, b, n, k - pa);
+    } else if(a[pa - 1] > b[pb - 1]) {
+        return findKth(a, m, b.slice(pb), n - pb, k - pb);
+    } else {
+        return a[pa - 1];
+    }
+}