update to change tracking

Author: jsgoller1

implementations/Technique - Interval Sweep .ipynb renamed to implementations/Technique - Change Tracking.ipynb

@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Technique - Interval Sweep\n",
+    "## Technique - Change Tracking\n",
     "\n",
     "This is a cool trick I learned from [@lee215](https://leetcode.com/problems/maximum-sum-obtained-of-any-permutation/discuss/854206/JavaC++Python-Sweep-Line) on LeetCode for efficiently handling some types of overlapping interval problems. \n",
     "\n",
@@ -70,11 +70,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Interval sweep technique\n",
+    "## Tracking changes technique\n",
     "\n",
-    "Consider that each time we see a range, all values between the start and the end have are now present in one range (plus any others). We can only get around the quadratic complexity by skipping these middle values. Let's keep a Counter `bounds_counts`; for each range given, `bounds_count[range[0]] += 1` and `bounds_count[range[0]+1] -= 1` (this may sound weird, but hang on). \n",
+    "Consider that each time we see a range, all values between the start and the end have are now present in one range (plus any others). We can only get around the quadratic complexity by skipping these middle values. So instead, what if we keep track of the boundaries of each range, and then just track the number of times an interval begins or ends on a particular boundary? Then we can go linearly through the bounds and just look at the changes in the number of covering intervals at each index.\n",
     "\n",
-    "If our ranges are `[[1,3],[2,4]]`, then the correct result would be `{1:1, 2:2, 3:2, 4:1}`. Using this strategy, `bounds_counts` looks like the following:\n",
+    "Let's keep a Counter `bounds_counts`; for each range given, `bounds_count[range[0]] += 1` and `bounds_count[range[0]+1] -= 1` (this may sound weird, but hang on). If our ranges are `[[1,3],[2,4]]`, then the correct result would be `{1:1, 2:2, 3:2, 4:1}`. Using this strategy, `bounds_counts` looks like the following:\n",
     "```\n",
     "[1,3] -> {1:1, 4:-1}\n",
     "[2,4] -> {1:1, 2:1, 4: -1, 5:-1}\n",
@@ -89,7 +89,7 @@
     "4        1 (-1)       {1:1, 2:2, 3:2, 4:1}\n",
     "5        0 (-1)       same as above; don't include values with frequency 0. \n",
     "```\n",
-    "so frequencies now corretly reflects the count of intervals covering each value, and calculates it in linear time. In code:"
+    "so frequencies now correctly reflects the count of intervals covering each value, and calculates it in linear time. In code:"
    ]
   },
   {
@@ -142,14 +142,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": 54,
    "metadata": {},
    "outputs": [],
    "source": [
     "from collections import Counter\n",
     "from typing import List\n",
     "\n",
-    "def interval_sweep(requests):\n",
+    "def interval_sweep_shitty(requests):\n",
     "    \"\"\"\n",
     "    Given a list of ranges, return an array\n",
     "    where arr[i] equals the number of ranges\n",
@@ -171,12 +171,26 @@
     "    return overlap_count\n",
     "\n",
     "\n",
+    "def interval_sweep(nums_len, requests):\n",
+    "    \"\"\"\n",
+    "    Same as above, but borrowing from @lee215's\n",
+    "    technique which is faster.\n",
+    "    \"\"\"\n",
+    "    counts = [0] * (nums_len+1)\n",
+    "    for start,end in requests:\n",
+    "        counts[start] += 1\n",
+    "        counts[end+1] -= 1\n",
+    "\n",
+    "    for i in range(1, nums_len+1):\n",
+    "        counts[i] += counts[i-1]\n",
+    "    return counts\n",
+    "\n",
     "class Solution:\n",
     "    def maxSumRangeQuery(self, nums: List[int], requests: List[List[int]]) -> int:\n",
     "        nums.sort(reverse=True)\n",
-    "        overlap_count = interval_sweep(requests)        \n",
+    "        overlap_count = interval_sweep(len(nums), requests)        \n",
     "        max_sum = 0\n",
-    "        for i, frequency in enumerate(sorted(overlap_count, reverse=True)):\n",
+    "        for i, frequency in enumerate(sorted(overlap_count[:-1], reverse=True)):\n",
     "            max_sum += frequency*nums[i]\n",
     "        return max_sum % (10**9 + 7)\n",
     "            \n",
@@ -191,12 +205,82 @@
     "    assert actual == expected, f\"{nums, requests}: {expected} != {actual}\""
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## [Corporate Flight Bookings](https://leetcode.com/problems/corporate-flight-bookings/)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Solution:\n",
+    "    def corpFlightBookings(self, bookings: List[List[int]], n: int) -> List[int]:\n",
+    "        flights = [0] * (n+1)\n",
+    "        for first,last,count in bookings:\n",
+    "            flights[first-1] += count\n",
+    "            flights[last] -= count \n",
+    "        for i in range(1, n):\n",
+    "            flights[i] += flights[i-1]\n",
+    "        return flights[:-1]\n",
+    "\n",
+    "s = Solution()\n",
+    "cases = [\n",
+    "    ([[1,2,10],[2,3,20],[2,5,25]], 5, [10,55,45,25,25])\n",
+    "]\n",
+    "for bookings, n, expected in cases:\n",
+    "    actual = s.corpFlightBookings(bookings, n)\n",
+    "    assert actual == expected, f\"{bookings, n}: {expected} != {actual}\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## [Car Pooling](https://leetcode.com/problems/car-pooling/)"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 70,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "from collections import Counter\n",
+    "\n",
+    "class Solution:\n",
+    "    def carPooling(self, trips: List[List[int]], capacity: int) -> bool:\n",
+    "        first, last = float('inf'), -float('inf')\n",
+    "        stops = Counter()\n",
+    "        for passengers, start, end in trips: \n",
+    "            stops[start] += passengers\n",
+    "            stops[end] -= passengers\n",
+    "            first = min(first, start)\n",
+    "            last = max(last, end)\n",
+    "\n",
+    "        seats = 0\n",
+    "        for i in range(first, last+1):\n",
+    "            seats += stops[i]\n",
+    "            if seats > capacity:\n",
+    "                return False\n",
+    "        return True\n",
+    "\n",
+    "s = Solution()\n",
+    "cases = [\n",
+    "    ([[2,1,5],[3,3,7]], 4, False),\n",
+    "    ([[2,1,5],[3,3,7]], 5, True),\n",
+    "    ([[2,1,5],[3,5,7]], 3, True),\n",
+    "    ([[3,2,7],[3,7,9],[8,3,9]], 11, True),\n",
+    "]\n",
+    "        \n",
+    "for trips, capacity, expected in cases:\n",
+    "    actual = s.carPooling(trips, capacity)\n",
+    "    assert actual == expected, f\"{trips, capacity}: {expected} != {actual}\""
+   ]
   }
  ],
  "metadata": {