feat: add solutions to lcci problems: No.16.10,16.11 (#1769)

* No.16.10.Living People
* No.16.11.Diving Board

Author: yanglbme

lcci/16.10.Living People/README.md

@@ -5,6 +5,7 @@
 ## 题目描述
 
 <!-- 这里写题目描述 -->
+
 <p>给定N个人的出生年份和死亡年份，第<code>i</code>个人的出生年份为<code>birth[i]</code>，死亡年份为<code>death[i]</code>，实现一个方法以计算生存人数最多的年份。</p>
 <p>你可以假设所有人都出生于1900年至2000年（含1900和2000）之间。如果一个人在某一年的任意时期都处于生存状态，那么他们应该被纳入那一年的统计中。例如，生于1908年、死于1909年的人应当被列入1908年和1909年的计数。</p>
 <p>如果有多个年份生存人数相同且均为最大值，输出其中最小的年份。</p>
@@ -24,13 +25,15 @@ death = {1948, 1951, 2000}
 
 <!-- 这里可写通用的实现逻辑 -->
 
-不在乎某个区间，而是某一年的最多存活人数。
+**方法一：差分数组**
+
+题目实际上是对一个连续的区间进行加减操作，然后求最大值。这种情况下可以使用差分数组来解决。
 
-可以使用哈希表来统计每年的存活人数，当 `birth[i] >= year && year <= death[i]`，该年份的存活人数加一。
+由于题目中的年份范围是固定的，所以可以使用一个长度为 $102$ 的数组来表示 $1900$ 年到 $2000$ 年的人口变化情况。数组中的每个元素表示该年份的人口变化，正数表示出生人数，负数表示死亡人数。
 
-> 只有 `birth` 和 `death` 当中的出现过的年份才是有效年份，或者说，可能成为返回值的年份。
+遍历每个人的出生年份和死亡年份，对应的年份的人口变化加一和减一。然后遍历差分数组，求出差分数组的前缀和的最大值，最大值对应的年份即为答案。
 
-题目当中已说明年份范围是 `1900 ~ 2000`，对此也可以使用数组进行计数（`year - 1900`）。
+时间复杂度 $O(n)$，空间复杂度 $O(C)$。其中 $n$ 是出生年份和死亡年份的长度，而 $C$ 是年份的范围。
 
 <!-- tabs:start -->
 
@@ -41,19 +44,19 @@ death = {1948, 1951, 2000}
 ```python
 class Solution:
     def maxAliveYear(self, birth: List[int], death: List[int]) -> int:
-        years = [0] * 101
-        for i in range(len(birth)):
-            start = birth[i] - 1900
-            end = death[i] - 1900
-            for j in range(start, end + 1):
-                years[j] += 1
-        max_v = years[0]
-        res = 0
-        for i in range(1, 101):
-            if years[i] > max_v:
-                max_v = years[i]
-                res = i
-        return 1900 + res
+        base = 1900
+        d = [0] * 102
+        for a, b in zip(birth, death):
+            d[a - base] += 1
+            d[b + 1 - base] -= 1
+        s = mx = 0
+        ans = 0
+        for i, x in enumerate(d):
+            s += x
+            if mx < s:
+                mx = s
+                ans = base + i
+        return ans
 ```
 
 ### **Java**
@@ -63,58 +66,101 @@ class Solution:
 ```java
 class Solution {
     public int maxAliveYear(int[] birth, int[] death) {
-        int[] years = new int[101];
-        int n = birth.length;
-        for (int i = 0; i < n; ++i) {
-            int start = birth[i] - 1900;
-            int end = death[i] - 1900;
-            for (int j = start; j <= end; ++j) {
-                ++years[j];
+        int base = 1900;
+        int[] d = new int[102];
+        for (int i = 0; i < birth.length; ++i) {
+            int a = birth[i] - base;
+            int b = death[i] - base;
+            ++d[a];
+            --d[b + 1];
+        }
+        int s = 0, mx = 0;
+        int ans = 0;
+        for (int i = 0; i < d.length; ++i) {
+            s += d[i];
+            if (mx < s) {
+                mx = s;
+                ans = base + i;
             }
         }
-        int max = years[0];
-        int res = 0;
-        for (int i = 1; i < 101; ++i) {
-            if (years[i] > max) {
-                max = years[i];
-                res = i;
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int maxAliveYear(vector<int>& birth, vector<int>& death) {
+        int base = 1900;
+        int d[102]{};
+        for (int i = 0; i < birth.size(); ++i) {
+            int a = birth[i] - base;
+            int b = death[i] - base;
+            ++d[a];
+            --d[b + 1];
+        }
+        int s = 0, mx = 0;
+        int ans = 0;
+        for (int i = 0; i < 102; ++i) {
+            s += d[i];
+            if (mx < s) {
+                mx = s;
+                ans = base + i;
             }
         }
-        return 1900 + res;
+        return ans;
     }
+};
+```
+
+### **Go**
+
+```go
+func maxAliveYear(birth []int, death []int) (ans int) {
+	base := 1900
+	d := [102]int{}
+	for i, a := range birth {
+		a -= base
+		b := death[i] - base
+		d[a]++
+		d[b+1]--
+	}
+	mx, s := 0, 0
+	for i, x := range d {
+		s += x
+		if mx < s {
+			mx = s
+			ans = base + i
+		}
+	}
+	return
 }
 ```
 
 ### **TypeScript**
 
 ```ts
 function maxAliveYear(birth: number[], death: number[]): number {
-    const n = birth.length;
-    const counter = new Map<number, number>();
-    for (let i = 0; i < n; i++) {
-        counter.set(birth[i], 0);
-        counter.set(death[i], 0);
+    const base = 1900;
+    const d: number[] = Array(102).fill(0);
+    for (let i = 0; i < birth.length; ++i) {
+        const [a, b] = [birth[i] - base, death[i] - base];
+        ++d[a];
+        --d[b + 1];
     }
-    for (let i = 0; i < n; i++) {
-        const start = birth[i];
-        const end = death[i];
-        for (const key of counter.keys()) {
-            if (key >= start && key <= end) {
-                counter.set(key, (counter.get(key) ?? 0) + 1);
-            }
-        }
-    }
-    let res = 0;
-    let max = 0;
-    for (const [key, val] of counter) {
-        if (val === max) {
-            res = Math.min(res, key);
-        } else if (val > max) {
-            res = key;
-            max = Math.max(max, val);
+    let [s, mx] = [0, 0];
+    let ans = 0;
+    for (let i = 0; i < d.length; ++i) {
+        s += d[i];
+        if (mx < s) {
+            mx = s;
+            ans = base + i;
         }
     }
-    return res;
+    return ans;
 }
 ```
 
@@ -124,22 +170,23 @@ function maxAliveYear(birth: number[], death: number[]): number {
 impl Solution {
     pub fn max_alive_year(birth: Vec<i32>, death: Vec<i32>) -> i32 {
         let n = birth.len();
-        let mut counter = vec![0; 101];
+        let mut d = vec![0; 102];
+        let base = 1900;
         for i in 0..n {
-            let (start, end) = (birth[i] - 1900, death[i] - 1900);
-            for j in start..=end {
-                counter[j as usize] += 1;
-            }
+            d[(birth[i] - base) as usize] += 1;
+            d[(death[i] - base + 1) as usize] -= 1;
         }
-        let mut res = 0;
-        let mut max = 0;
-        for (i, count) in counter.iter().enumerate() {
-            if *count > max {
-                res = i;
-                max = *count;
+        let mut ans = 0;
+        let mut mx = 0;
+        let mut s = 0;
+        for i in 0..102 {
+            s += d[i];
+            if mx < s {
+                mx = s;
+                ans = base + i as i32;
             }
         }
-        (res + 1900) as i32
+        ans
     }
 }
 ```