Added Meeting Rooms II to Intervals

Author: SamsonPN

.ipynb_checkpoints/Intervals-checkpoint.ipynb

@@ -371,10 +371,98 @@
     "};"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "24c37b4d",
+   "metadata": {},
+   "source": [
+    "## Meeting Rooms II\n",
+    "\n",
+    "* https://www.lintcode.com/problem/919/description\n",
+    "***\n",
+    "* Time Complexity: O(nlogn)\n",
+    "    - traverse through all intervals and push the start/end times into an arr: O(n)\n",
+    "    - sort the meetings arr: O(nlogn)\n",
+    "        * the # of entries in the meetings arr is actually 2n b/c we push both start and end times separately\n",
+    "* Space Complexity: O(n)\n",
+    "    - needs space for the meetings arr\n",
+    "***\n",
+    "* similar to Kadane's algorithm\n",
+    "* we traverse through the intervals arr and push the start times and end times for each interval separately\n",
+    "    - [interval.start, 1] and [interval.end, -1]\n",
+    "    - a start time indicates a meeting starting and an end time indicates a meeting ending\n",
+    "    - so the 1 and -1 respectively will adjust the # of meetings going on at a time, which corresponds to the # of conference rooms\n",
+    "* once we have filled up the meetings arr, we sort it\n",
+    "    - we do this b/c we want to determine how many concurrent meetings, and therefore conference rooms being used, there are\n",
+    "    - so if we have 2 start times in a row, that tells us that there are 2 meetings happening at the same time, which require 2 conference rooms\n",
+    "    - however, if the next time is an end time, then we know that a meeting has ended and the # of meetings and conference rooms have gone down\n",
+    "* as we traverse meetings, the # of meetings/conference rooms will reach a peak then go down to 0 b/c all meetings have ended by the time we have traversed the entire meetings arr\n",
+    "    - therefore, we must take the max # of meetings after every loop to ensure we get our # of conference rooms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "493fe650",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "/**\n",
+    " * Definition of Interval:\n",
+    " * class Interval {\n",
+    " *   constructor(start, end) {\n",
+    " *     this.start = start;\n",
+    " *     this.end = end;\n",
+    " *   }\n",
+    " * }\n",
+    " */\n",
+    "\n",
+    "var Solution = class {\n",
+    "  /**\n",
+    "   * @param intervals: an array of meeting time intervals\n",
+    "   * @return: the minimum number of conference rooms required\n",
+    "   */\n",
+    "  minMeetingRooms(intervals) {\n",
+    "    const n = intervals.length;\n",
+    "    if (n === 1) return 1;\n",
+    "\n",
+    "    // essentially, every time a meeting starts, we increment # of meetings by 1\n",
+    "    // and every time a meeting ends, we decrement # of meetings by 1\n",
+    "    // so we keep track of these in an arr\n",
+    "    const meetings = [];\n",
+    "    intervals.forEach(interval => {\n",
+    "      meetings.push([interval.start, 1]);\n",
+    "      meetings.push([interval.end, -1]);\n",
+    "    })\n",
+    "\n",
+    "    // we then sort the meetings arr by their time\n",
+    "    meetings.sort((a, b) => a[0] - b[0]);\n",
+    "\n",
+    "    // pretty similar to Kadane's algorithm\n",
+    "    // we aren't looking for overlaps here!\n",
+    "    // we know that a meeting HAS to start and it HAS to end\n",
+    "    // if a meeting starts and then another meeting starts after it with the previous one not ending yet,\n",
+    "    // then we'll need 2 conference rooms\n",
+    "    // but if one of them ends, then we only have need for 1 conference room\n",
+    "    \n",
+    "    // the reason why we need to take the max every time is b/c by the end of all meetings, it'll be back to 0\n",
+    "    // so we must look at the max concurrent meetings\n",
+    "    let maxMeetings = 0;\n",
+    "    let runningMeetings = 0;\n",
+    "    for (let [_, delta] of meetings) {\n",
+    "      runningMeetings += delta;\n",
+    "      maxMeetings = Math.max(maxMeetings, runningMeetings);\n",
+    "    }\n",
+    "\n",
+    "    return maxMeetings;\n",
+    "  }\n",
+    "}"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "57fccd86",
+   "id": "4bd16fdb",
    "metadata": {},
    "outputs": [],
    "source": []

Intervals.ipynb

@@ -371,10 +371,98 @@
     "};"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "24c37b4d",
+   "metadata": {},
+   "source": [
+    "## Meeting Rooms II\n",
+    "\n",
+    "* https://www.lintcode.com/problem/919/description\n",
+    "***\n",
+    "* Time Complexity: O(nlogn)\n",
+    "    - traverse through all intervals and push the start/end times into an arr: O(n)\n",
+    "    - sort the meetings arr: O(nlogn)\n",
+    "        * the # of entries in the meetings arr is actually 2n b/c we push both start and end times separately\n",
+    "* Space Complexity: O(n)\n",
+    "    - needs space for the meetings arr\n",
+    "***\n",
+    "* similar to Kadane's algorithm\n",
+    "* we traverse through the intervals arr and push the start times and end times for each interval separately\n",
+    "    - [interval.start, 1] and [interval.end, -1]\n",
+    "    - a start time indicates a meeting starting and an end time indicates a meeting ending\n",
+    "    - so the 1 and -1 respectively will adjust the # of meetings going on at a time, which corresponds to the # of conference rooms\n",
+    "* once we have filled up the meetings arr, we sort it\n",
+    "    - we do this b/c we want to determine how many concurrent meetings, and therefore conference rooms being used, there are\n",
+    "    - so if we have 2 start times in a row, that tells us that there are 2 meetings happening at the same time, which require 2 conference rooms\n",
+    "    - however, if the next time is an end time, then we know that a meeting has ended and the # of meetings and conference rooms have gone down\n",
+    "* as we traverse meetings, the # of meetings/conference rooms will reach a peak then go down to 0 b/c all meetings have ended by the time we have traversed the entire meetings arr\n",
+    "    - therefore, we must take the max # of meetings after every loop to ensure we get our # of conference rooms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "493fe650",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "/**\n",
+    " * Definition of Interval:\n",
+    " * class Interval {\n",
+    " *   constructor(start, end) {\n",
+    " *     this.start = start;\n",
+    " *     this.end = end;\n",
+    " *   }\n",
+    " * }\n",
+    " */\n",
+    "\n",
+    "var Solution = class {\n",
+    "  /**\n",
+    "   * @param intervals: an array of meeting time intervals\n",
+    "   * @return: the minimum number of conference rooms required\n",
+    "   */\n",
+    "  minMeetingRooms(intervals) {\n",
+    "    const n = intervals.length;\n",
+    "    if (n === 1) return 1;\n",
+    "\n",
+    "    // essentially, every time a meeting starts, we increment # of meetings by 1\n",
+    "    // and every time a meeting ends, we decrement # of meetings by 1\n",
+    "    // so we keep track of these in an arr\n",
+    "    const meetings = [];\n",
+    "    intervals.forEach(interval => {\n",
+    "      meetings.push([interval.start, 1]);\n",
+    "      meetings.push([interval.end, -1]);\n",
+    "    })\n",
+    "\n",
+    "    // we then sort the meetings arr by their time\n",
+    "    meetings.sort((a, b) => a[0] - b[0]);\n",
+    "\n",
+    "    // pretty similar to Kadane's algorithm\n",
+    "    // we aren't looking for overlaps here!\n",
+    "    // we know that a meeting HAS to start and it HAS to end\n",
+    "    // if a meeting starts and then another meeting starts after it with the previous one not ending yet,\n",
+    "    // then we'll need 2 conference rooms\n",
+    "    // but if one of them ends, then we only have need for 1 conference room\n",
+    "    \n",
+    "    // the reason why we need to take the max every time is b/c by the end of all meetings, it'll be back to 0\n",
+    "    // so we must look at the max concurrent meetings\n",
+    "    let maxMeetings = 0;\n",
+    "    let runningMeetings = 0;\n",
+    "    for (let [_, delta] of meetings) {\n",
+    "      runningMeetings += delta;\n",
+    "      maxMeetings = Math.max(maxMeetings, runningMeetings);\n",
+    "    }\n",
+    "\n",
+    "    return maxMeetings;\n",
+    "  }\n",
+    "}"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "57fccd86",
+   "id": "4bd16fdb",
    "metadata": {},
    "outputs": [],
    "source": []