add more solutions

Author: chihungyu1116

10 Regular Expresion Matching.js

@@ -53,7 +53,7 @@ var isMatch = function(s, p) {
                   dp[i][j] = true;
                 }
             } else if(j > 1) { // '*' cannot be the first element      
-                if(dp[i][j-1] || dp[i][j-2]) {
+                if(dp[i][j-2]) { // 0 Occurance
                   dp[i][j] = true;     
                 } else if(i > 0 && (p[j-2] == s[i-1] || p[j-2] == '.') && dp[i-1][j]) {
 

124 Binary Tree Maximum Path Sum.js

@@ -42,7 +42,7 @@ var maxPathSum = function(root) {
 
         // maxVal as if we end counting value here, what will be the maximum val
         // leftVal and rightVal can be negative values
-        maxVal = Math.max(maxVal, Math.max(ps1, ps2));
+        maxVal = Math.max.apply(null, [maxVal, ps1, ps2]);
 
         // return ps1 only since, ps2 cannot be combined with the parent node
         // leftVal and rightVal can be negative values, however, we can to see if combining with values down below can give higher number

133 Clone Graph.js

@@ -21,6 +21,12 @@
 //          / \
 //          \_/
 
+// Pocket Gems Google Uber Facebook
+// Hide Tags Depth-first Search Breadth-first Search Graph
+// Hide Similar Problems (H) Copy List with Random Pointer
+
+
+
 /**
  * Definition for undirected graph.
  * function UndirectedGraphNode(label) {
@@ -42,21 +48,12 @@ var cloneGraph = function(graph) {
     }
 
     function dfs(node){
-        var newNode = null;
-        
-        if(visited[node.label]){
-            newNode = visited[node.label];
-        }else{
-            newNode = new UndirectedGraphNode(node.label);
-            visited[node.label] = newNode;
-        }
+        var newNode = visited[node.label] ? visited[node.label] : new UndirectedGraphNode(node.label);
+        visited[node.label] = newNode;
 
         for(var i = 0; i < node.neighbors.length; i++){
-            if(!visited[node.neighbors[i].label]){
-                newNode.neighbors.push(dfs(node.neighbors[i]));
-            }else{
-                newNode.neighbors.push(visited[node.neighbors[i].label]);
-            }
+            var newNeighbor = visited[node.neighbors[i].label] ? visited[node.neighbors[i].label] : dfs(node.neighbors[i]);
+            newNode.neighbors.push(newNeighbor);
         }
         return newNode; 
     }   

207 Course Schedule.js

@@ -2,6 +2,67 @@
 // Language: Javascript
 // Problem: https://leetcode.com/problems/course-schedule/
 // Author: Chihung Yu
+
+// Non-recursion version 144ms
+// more generic solution to problem that doesn't need information of numCourses and can deal with duplicated prerequisites
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+var canFinish = function(numCourses, prerequisites) {
+    var courseWithOtherCoursesDependOn = {};
+    var courseDependsOnOtherCourses = {};
+    
+    prerequisites.forEach((prerequisite)=> {
+        var prereqCourse = prerequisite[1];
+        var courseToTake = prerequisite[0]
+        
+        
+        courseWithOtherCoursesDependOn[prereqCourse] = courseWithOtherCoursesDependOn[prereqCourse] || new Set();
+        courseWithOtherCoursesDependOn[prereqCourse].add(courseToTake);
+        
+        courseDependsOnOtherCourses[prereqCourse] = courseDependsOnOtherCourses[prereqCourse] || new Set();
+        courseDependsOnOtherCourses[courseToTake] = courseDependsOnOtherCourses[courseToTake] || new Set();
+        courseDependsOnOtherCourses[courseToTake].add(prereqCourse);
+    });
+    
+    var courseWithNoDependencies = [];
+    
+    for(var i in courseDependsOnOtherCourses) {
+        if(courseDependsOnOtherCourses[i].size === 0) {
+            courseWithNoDependencies.push(i);
+        }
+    }
+    
+    while(courseWithNoDependencies.length > 0) {
+        var rootCourse = courseWithNoDependencies.shift();
+        
+        if(courseWithOtherCoursesDependOn[rootCourse]) {
+            courseWithOtherCoursesDependOn[rootCourse].forEach((childCourse)=> {
+                courseDependsOnOtherCourses[childCourse].delete(parseInt(rootCourse));
+                
+                if(courseDependsOnOtherCourses[childCourse].size === 0) {
+                    courseWithNoDependencies.push(childCourse + '');
+                }
+            });
+        }
+    }
+    
+    for(i in courseDependsOnOtherCourses) {
+        if(courseDependsOnOtherCourses[i].size !== 0) {
+            return false;
+        }
+    }
+    
+    return true;
+};
+
+
+
+// recursion 132ms
+
 /**
  * @param {number} numCourses
  * @param {number[][]} prerequisites
@@ -53,10 +114,9 @@ var canFinish = function(numCourses, prerequisites) {
         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]])
+

210 Course Schedule II.js

@@ -0,0 +1,98 @@
+// There are a total of n courses you have to take, labeled from 0 to n - 1.
+
+// Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]
+
+// Given the total number of courses and a list of prerequisite pairs, return the ordering of courses you should take to finish all courses.
+
+// There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all courses, return an empty array.
+
+// For example:
+
+// 2, [[1,0]]
+// There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1]
+
+// 4, [[1,0],[2,0],[3,1],[3,2]]
+// There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].
+
+// Note:
+// The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
+
+// click to show more hints.
+
+// Hide Company Tags Facebook Zenefits
+// Hide Tags Depth-first Search Breadth-first Search Graph Topological Sort
+// Hide Similar Problems (M) Course Schedule (H) Alien Dictionary (M) Minimum Height Trees
+
+
+// 160ms
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {number[]}
+ */
+var findOrder = function(numCourses, prerequisites) {
+    var courseWithOtherCoursesDependOn = {};
+    var courseDependsOnOtherCourses = {};
+    
+    prerequisites.forEach((prerequisite)=> {
+        var prereqCourse = prerequisite[1];
+        var courseToTake = prerequisite[0]
+        
+        
+        courseWithOtherCoursesDependOn[prereqCourse] = courseWithOtherCoursesDependOn[prereqCourse] || new Set();
+        courseWithOtherCoursesDependOn[prereqCourse].add(courseToTake);
+        
+        courseDependsOnOtherCourses[prereqCourse] = courseDependsOnOtherCourses[prereqCourse] || new Set();
+        courseDependsOnOtherCourses[courseToTake] = courseDependsOnOtherCourses[courseToTake] || new Set();
+        courseDependsOnOtherCourses[courseToTake].add(prereqCourse);
+    });
+    
+    var courseWithNoDependencies = [];
+    
+    for(var i in courseDependsOnOtherCourses) {
+        if(courseDependsOnOtherCourses[i].size === 0) {
+            courseWithNoDependencies.push(i);
+        }
+    }
+    
+
+    // pretty much the same as Course Schedule I. Just need to add those non root
+    var courseOrders = [];
+    var hasCourseOrders = {};
+    
+    while(courseWithNoDependencies.length > 0) {
+        var rootCourse = courseWithNoDependencies.shift();
+        
+        courseOrders.push(parseInt(rootCourse));
+        hasCourseOrders[parseInt(rootCourse)] = true;
+        
+        if(courseWithOtherCoursesDependOn[rootCourse]) {
+            courseWithOtherCoursesDependOn[rootCourse].forEach((childCourse)=> {
+                courseDependsOnOtherCourses[childCourse].delete(parseInt(rootCourse));
+                
+                if(courseDependsOnOtherCourses[childCourse].size === 0) {
+                    courseWithNoDependencies.push(childCourse + '');
+                }
+            });
+        }
+    }
+    
+    for(i in courseDependsOnOtherCourses) {
+        if(courseDependsOnOtherCourses[i].size !== 0) {
+            return [];
+        }
+    }
+    
+    if(courseOrders.length < numCourses) {
+        for(i = 0; i < numCourses; i++) {
+            if(!hasCourseOrders[i]) {
+                courseOrders.push(i);
+            }
+        }
+    }
+    
+    return courseOrders;
+};
+
+console.log(findOrder(3, [[1,0]]));

252 Meeting Rooms.js

@@ -0,0 +1,39 @@
+// Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei), determine if a person could attend all meetings.
+
+// For example,
+// Given [[0, 30],[5, 10],[15, 20]],
+// return false.
+
+// Hide Company Tags Facebook
+// Hide Tags Sort
+// Hide Similar Problems (H) Merge Intervals (M) Meeting Rooms II
+
+
+/**
+ * Definition for an interval.
+ * function Interval(start, end) {
+ *     this.start = start;
+ *     this.end = end;
+ * }
+ */
+/**
+ * @param {Interval[]} intervals
+ * @return {boolean}
+ */
+
+// 132 ms
+var canAttendMeetings = function(intervals) {
+    // sort by starting time
+    intervals.sort((interval1, interval2)=> interval1.start > interval2.start ? 1 : -1);
+    
+    for(var i = 1; i < intervals.length; i++) {
+        var pre = intervals[i-1];
+        var cur = intervals[i];
+        
+        if(pre.end > cur.start) {
+            return false;
+        }
+    }
+    
+    return true;
+};

253 Meeting Rooms II.js

@@ -0,0 +1,50 @@
+// Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei), find the minimum number of conference rooms required.
+
+// For example,
+// Given [[0, 30],[5, 10],[15, 20]],
+// return 2.
+
+// Hide Company Tags Google Facebook
+// Hide Tags Heap Greedy Sort
+// Hide Similar Problems (H) Merge Intervals (E) Meeting Rooms
+
+
+/**
+ * Definition for an interval.
+ * function Interval(start, end) {
+ *     this.start = start;
+ *     this.end = end;
+ * }
+ */
+/**
+ * @param {Interval[]} intervals
+ * @return {number}
+ */
+
+var minMeetingRooms = function(intervals) {
+    var schedule = {};
+    
+    intervals.forEach((interval)=>{
+        schedule[interval.start] = schedule[interval.start] || 0;
+        schedule[interval.start]++;
+        
+        schedule[interval.end] = schedule[interval.end] || 0;
+        schedule[interval.end]--;
+    });
+    
+    var maxRooms = 0;
+    var rooms = 0;
+    
+    for(var i in schedule) {
+        rooms += schedule[i];
+        maxRooms = Math.max(maxRooms, rooms);
+    }
+    
+    return maxRooms;
+};
+
+var data = [
+  {start: 2, end: 7},
+]
+
+console.log(minMeetingRooms(data));