feat: update solutions to lc problem: No.1109

No.1109.Corporate Flight Bookings

Author: yanglbme

solution/1100-1199/1109.Corporate Flight Bookings/README.md

@@ -59,11 +59,17 @@
 
 **方法一：差分数组**
 
-时间复杂度 O(n)。
+我们注意到，每一次预订都是在某个区间 `[first, last]` 内的所有航班上预订了 `seats` 个座位。因此，我们可以利用差分数组的思想，对于每一次预订，将 `first` 位置的数加上 `seats`，将 `last + 1` 位置的数减去 `seats`。最后，对差分数组求前缀和，即可得到每个航班预定的座位总数。
+
+时间复杂度 $O(n)$，其中 $n$ 为航班数。忽略答案的空间消耗，空间复杂度 $O(1)$。
 
 **方法二：树状数组 + 差分思想**
 
-时间复杂度 O(nlogn)。
+我们也可以利用树状数组，结合差分的思想，来实现上述操作。我们可以将每一次预订看作是在某个区间 `[first, last]` 内的所有航班上预订了 `seats` 个座位。因此，我们可以对每一次预订，对树状数组的 `first` 位置加上 `seats`，对树状数组的 `last + 1` 位置减去 `seats`。最后，对树状数组每个位置求前缀和，即可得到每个航班预定的座位总数。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为航班数。
+
+以下是树状数组的基本介绍：
 
 树状数组，也称作“二叉索引树”（Binary Indexed Tree）或 Fenwick 树。 它可以高效地实现如下两个操作：
 
@@ -78,41 +84,33 @@
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-差分数组：
-
 ```python
 class Solution:
     def corpFlightBookings(self, bookings: List[List[int]], n: int) -> List[int]:
-        delta = [0] * n
+        ans = [0] * n
         for first, last, seats in bookings:
-            delta[first - 1] += seats
+            ans[first - 1] += seats
             if last < n:
-                delta[last] -= seats
-        return list(accumulate(delta))
+                ans[last] -= seats
+        return list(accumulate(ans))
 ```
 
-树状数组：
-
 ```python
 class BinaryIndexedTree:
     def __init__(self, n):
         self.n = n
         self.c = [0] * (n + 1)
 
-    @staticmethod
-    def lowbit(x):
-        return x & -x
-
     def update(self, x, delta):
         while x <= self.n:
             self.c[x] += delta
-            x += BinaryIndexedTree.lowbit(x)
+            x += x & -x
 
     def query(self, x):
         s = 0
         while x:
             s += self.c[x]
-            x -= BinaryIndexedTree.lowbit(x)
+            x -= x & -x
         return s
 
 
@@ -129,35 +127,31 @@ class Solution:
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
-差分数组：
-
 ```java
 class Solution {
     public int[] corpFlightBookings(int[][] bookings, int n) {
-        int[] delta = new int[n];
-        for (int[] booking : bookings) {
-            int first = booking[0], last = booking[1], seats = booking[2];
-            delta[first - 1] += seats;
+        int[] ans = new int[n];
+        for (var e : bookings) {
+            int first = e[0], last = e[1], seats = e[2];
+            ans[first - 1] += seats;
             if (last < n) {
-                delta[last] -= seats;
+                ans[last] -= seats;
             }
         }
-        for (int i = 0; i < n - 1; ++i) {
-            delta[i + 1] += delta[i];
+        for (int i = 1; i < n; ++i) {
+            ans[i] += ans[i - 1];
         }
-        return delta;
+        return ans;
     }
 }
 ```
 
-树状数组：
-
 ```java
 class Solution {
     public int[] corpFlightBookings(int[][] bookings, int n) {
         BinaryIndexedTree tree = new BinaryIndexedTree(n);
-        for (int[] booking : bookings) {
-            int first = booking[0], last = booking[1], seats = booking[2];
+        for (var e : bookings) {
+            int first =e[0], last = e[1], seats = e[2];
             tree.update(first, seats);
             tree.update(last + 1, -seats);
         }
@@ -181,147 +175,106 @@ class BinaryIndexedTree {
     public void update(int x, int delta) {
         while (x <= n) {
             c[x] += delta;
-            x += lowbit(x);
+            x += x & -x;
         }
     }
 
     public int query(int x) {
         int s = 0;
         while (x > 0) {
             s += c[x];
-            x -= lowbit(x);
+            x -= x & -x;
         }
         return s;
     }
-
-    public static int lowbit(int x) {
-        return x & -x;
-    }
 }
 ```
 
-### **JavaScript**
-
-差分数组：
-
-```js
-/**
- * @param {number[][]} bookings
- * @param {number} n
- * @return {number[]}
- */
-var corpFlightBookings = function (bookings, n) {
-    let delta = new Array(n).fill(0);
-    for (let [start, end, num] of bookings) {
-        delta[start - 1] += num;
-        if (end != n) {
-            delta[end] -= num;
-        }
-    }
-    for (let i = 1; i < n; ++i) {
-        delta[i] += delta[i - 1];
-    }
-    return delta;
-};
-```
-
 ### **C++**
 
-差分数组：
-
 ```cpp
 class Solution {
 public:
     vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {
-        vector<int> delta(n);
-        for (auto& booking : bookings) {
-            int first = booking[0], last = booking[1], seats = booking[2];
-            delta[first - 1] += seats;
+        vector<int> ans(n);
+        for (auto& e : bookings) {
+            int first = e[0], last = e[1], seats = e[2];
+            ans[first - 1] += seats;
             if (last < n) {
-                delta[last] -= seats;
+                ans[last] -= seats;
             }
         }
-        for (int i = 0; i < n - 1; ++i) {
-            delta[i + 1] += delta[i];
+        for (int i = 1; i < n; ++i) {
+            ans[i] += ans[i - 1];
         }
-        return delta;
+        return ans;
     }
 };
 ```
 
-树状数组：
-
 ```cpp
 class BinaryIndexedTree {
 public:
-    int n;
-    vector<int> c;
-
     BinaryIndexedTree(int _n): n(_n), c(_n + 1){}
 
     void update(int x, int delta) {
-        while (x <= n)
-        {
+        while (x <= n) {
             c[x] += delta;
-            x += lowbit(x);
+            x += x & -x;
         }
     }
 
     int query(int x) {
         int s = 0;
-        while (x > 0)
-        {
+        while (x) {
             s += c[x];
-            x -= lowbit(x);
+            x -= x & -x;
         }
         return s;
     }
 
-    int lowbit(int x) {
-        return x & -x;
-    }
+private:
+    int n;
+    vector<int> c;
 };
 
 class Solution {
 public:
     vector<int> corpFlightBookings(vector<vector<int>>& bookings, int n) {
         BinaryIndexedTree* tree = new BinaryIndexedTree(n);
-        for (auto& booking : bookings)
-        {
-            int first = booking[0], last = booking[1], seats = booking[2];
+        for (auto& e : bookings) {
+            int first = e[0], last = e[1], seats = e[2];
             tree->update(first, seats);
             tree->update(last + 1, -seats);
         }
-        vector<int> ans;
-        for (int i = 0; i < n; ++i) ans.push_back(tree->query(i + 1));
+        vector<int> ans(n);
+        for (int i = 0; i < n; ++i) {
+            ans[i] = tree->query(i + 1);
+        }
         return ans;
     }
 };
 ```
 
 ### **Go**
 
-差分数组：
-
 ```go
 func corpFlightBookings(bookings [][]int, n int) []int {
-	delta := make([]int, n)
-	for _, booking := range bookings {
-		first, last, seats := booking[0], booking[1], booking[2]
-		delta[first-1] += seats
+	ans := make([]int, n)
+	for _, e := range bookings {
+		first, last, seats := e[0], e[1], e[2]
+		ans[first-1] += seats
 		if last < n {
-			delta[last] -= seats
+			ans[last] -= seats
 		}
 	}
-	for i := 0; i < n-1; i++ {
-		delta[i+1] += delta[i]
+	for i := 1; i < n; i++ {
+		ans[i] += ans[i-1]
 	}
-	return delta
+	return ans
 }
 ```
 
-树状数组：
-
 ```go
 type BinaryIndexedTree struct {
 	n int
@@ -333,30 +286,26 @@ func newBinaryIndexedTree(n int) *BinaryIndexedTree {
 	return &BinaryIndexedTree{n, c}
 }
 
-func (this *BinaryIndexedTree) lowbit(x int) int {
-	return x & -x
-}
-
 func (this *BinaryIndexedTree) update(x, delta int) {
 	for x <= this.n {
 		this.c[x] += delta
-		x += this.lowbit(x)
+		x += x & -x
 	}
 }
 
 func (this *BinaryIndexedTree) query(x int) int {
 	s := 0
 	for x > 0 {
 		s += this.c[x]
-		x -= this.lowbit(x)
+		x -= x & -x
 	}
 	return s
 }
 
 func corpFlightBookings(bookings [][]int, n int) []int {
 	tree := newBinaryIndexedTree(n)
-	for _, booking := range bookings {
-		first, last, seats := booking[0], booking[1], booking[2]
+	for _, e := range bookings {
+		first, last, seats := e[0], e[1], e[2]
 		tree.update(first, seats)
 		tree.update(last+1, -seats)
 	}
@@ -368,6 +317,29 @@ func corpFlightBookings(bookings [][]int, n int) []int {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {number[][]} bookings
+ * @param {number} n
+ * @return {number[]}
+ */
+var corpFlightBookings = function (bookings, n) {
+    const ans = new Array(n).fill(0);
+    for (const [first, last, seats] of bookings) {
+        ans[first - 1] += seats;
+        if (last < n) {
+            ans[last] -= seats;
+        }
+    }
+    for (let i = 1; i < n; ++i) {
+        ans[i] += ans[i - 1];
+    }
+    return ans;
+};
+```
+
 ### **...**
 
 ```