feat: add solutions to lc problem: No.1854

No.1854.Maximum Population Year

Author: yanglbme

solution/1800-1899/1850.Minimum Adjacent Swaps to Reach the Kth Smallest Number/README.md

@@ -12,15 +12,13 @@
 
 <ul>
 	<li>例如，<code>num = "5489355142"</code> ：
-
     <ul>
     	<li>第 1 个最小妙数是 <code>"5489355214"</code></li>
     	<li>第 2 个最小妙数是 <code>"5489355241"</code></li>
     	<li>第 3 个最小妙数是 <code>"5489355412"</code></li>
     	<li>第 4 个最小妙数是 <code>"5489355421"</code></li>
     </ul>
     </li>
-
 </ul>
 
 <p>返回要得到第 <code>k</code> 个 <strong>最小妙数</strong> 需要对 <code>num</code> 执行的 <strong>相邻位数字交换的最小次数</strong> 。</p>

solution/1800-1899/1850.Minimum Adjacent Swaps to Reach the Kth Smallest Number/README_EN.md

@@ -10,15 +10,13 @@
 
 <ul>
 	<li>For example, when <code>num = &quot;5489355142&quot;</code>:
-
     <ul>
     	<li>The 1<sup>st</sup> smallest wonderful integer is <code>&quot;5489355214&quot;</code>.</li>
     	<li>The 2<sup>nd</sup> smallest wonderful integer is <code>&quot;5489355241&quot;</code>.</li>
     	<li>The 3<sup>rd</sup> smallest wonderful integer is <code>&quot;5489355412&quot;</code>.</li>
     	<li>The 4<sup>th</sup> smallest wonderful integer is <code>&quot;5489355421&quot;</code>.</li>
     </ul>
     </li>
-
 </ul>
 
 <p>Return <em>the <strong>minimum number of adjacent digit swaps</strong> that needs to be applied to </em><code>num</code><em> to reach the </em><code>k<sup>th</sup></code><em><strong> smallest wonderful</strong> integer</em>.</p>

solution/1800-1899/1854.Maximum Population Year/README.md

@@ -44,6 +44,12 @@
 
 **方法一：差分数组**
 
+我们注意到，年份的范围是 $[1950,..2050]$，因此我们可以将这些年份映射到一个长度为 $101$ 的数组 $d$ 中，数组的下标表示年份减去 $1950$ 的值。
+
+接下来遍历 $logs$，对于每个人，我们将 $d[birth_i - 1950]$ 加 $1$，将 $d[death_i - 1950]$ 减 $1$。最后遍历数组 $d$，求出前缀和的最大值，即为人口最多的年份，再加上 $1950$ 即为答案。
+
+时间复杂度 $O(n)$，空间复杂度 $O(C)$。其中 $n$ 为数组 $logs$ 的长度；而 $C$ 为年份的范围大小，即 $2050 - 1950 + 1 = 101$。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -53,18 +59,18 @@
 ```python
 class Solution:
     def maximumPopulation(self, logs: List[List[int]]) -> int:
-        delta = [0] * 2055
-        for birth, death in logs:
-            delta[birth] += 1
-            delta[death] -= 1
-
-        mx = res = cur = 0
-        for i, v in enumerate(delta):
-            cur += v
-            if mx < cur:
-                mx = cur
-                res = i
-        return res
+        d = [0] * 101
+        offset = 1950
+        for a, b in logs:
+            a, b = a - offset, b - offset
+            d[a] += 1
+            d[b] -= 1
+        s = mx = j = 0
+        for i, x in enumerate(d):
+            s += x
+            if mx < s:
+                mx, j = s, i
+        return j + offset
 ```
 
 ### **Java**
@@ -74,74 +80,52 @@ class Solution:
 ```java
 class Solution {
     public int maximumPopulation(int[][] logs) {
-        int[] delta = new int[2055];
-        for (int[] log : logs) {
-            ++delta[log[0]];
-            --delta[log[1]];
+        int[] d = new int[101];
+        final int offset = 1950;
+        for (var log : logs) {
+            int a = log[0] - offset;
+            int b = log[1] - offset;
+            ++d[a];
+            --d[b];
         }
-        int res = 0, mx = 0, cur = 0;
-        for (int i = 0; i < delta.length; ++i) {
-            cur += delta[i];
-            if (cur > mx) {
-                mx = cur;
-                res = i;
+        int s = 0, mx = 0;
+        int j = 0;
+        for (int i = 0; i < d.length; ++i) {
+            s += d[i];
+            if (mx < s) {
+                mx = s;
+                j = i;
             }
         }
-        return res;
+        return j + offset;
     }
 }
 ```
 
-### **JavaScript**
-
-```js
-/**
- * @param {number[][]} logs
- * @return {number}
- */
-var maximumPopulation = function (logs) {
-    const offset = 1950;
-    const len = 2050 - 1950 + 1;
-    let delta = new Array(len).fill(0);
-    for (let log of logs) {
-        delta[log[0] - offset] += 1;
-        delta[log[1] - offset] -= 1;
-    }
-    let max = 0;
-    let total = 0;
-    let index = 0;
-    for (let i = 0; i < len; i++) {
-        total += delta[i];
-        if (total > max) {
-            max = total;
-            index = i;
-        }
-    }
-    return index + offset;
-};
-```
-
 ### **C++**
 
 ```cpp
 class Solution {
 public:
     int maximumPopulation(vector<vector<int>>& logs) {
-        vector<int> delta(101, 0);
-        int offset = 1950;
-        for (auto log : logs) {
-            ++delta[log[0] - offset];
-            --delta[log[1] - offset];
+        int d[101]{};
+        const int offset = 1950;
+        for (auto& log : logs) {
+            int a = log[0] - offset;
+            int b = log[1] - offset;
+            ++d[a];
+            --d[b];
         }
-        int res = 0, mx = 0, cur = 0;
-        for (int i = 0; i < delta.size(); ++i) {
-            cur += delta[i];
-            if (cur > mx) {
-                mx = cur;
-                res = i;
+        int s = 0, mx = 0;
+        int j = 0;
+        for (int i = 0; i < 101; ++i) {
+            s += d[i];
+            if (mx < s) {
+                mx = s;
+                j = i;
             }
         }
-        return res + offset;
+        return j + offset;
     }
 };
 ```
@@ -150,21 +134,72 @@ public:
 
 ```go
 func maximumPopulation(logs [][]int) int {
-	delta := make([]int, 101)
+	d := [101]int{}
 	offset := 1950
 	for _, log := range logs {
-		delta[log[0]-offset]++
-		delta[log[1]-offset]--
+		a, b := log[0]-offset, log[1]-offset
+		d[a]++
+		d[b]--
 	}
-	res, mx, cur := 0, 0, 0
-	for i := 0; i < len(delta); i++ {
-		cur += delta[i]
-		if cur > mx {
-			mx = cur
-			res = i
+	var s, mx, j int
+	for i, x := range d {
+		s += x
+		if mx < s {
+			mx = s
+			j = i
 		}
 	}
-	return res + offset
+	return j + offset
+}
+```
+
+### **JavaScript**
+
+```js
+/**
+ * @param {number[][]} logs
+ * @return {number}
+ */
+var maximumPopulation = function (logs) {
+    const d = new Array(101).fill(0);
+    const offset = 1950;
+    for (let [a, b] of logs) {
+        a -= offset;
+        b -= offset;
+        d[a]++;
+        d[b]--;
+    }
+    let j = 0;
+    for (let i = 0, s = 0, mx = 0; i < 101; ++i) {
+        s += d[i];
+        if (mx < s) {
+            mx = s;
+            j = i;
+        }
+    }
+    return j + offset;
+};
+```
+
+### **TypeScript**
+
+```ts
+function maximumPopulation(logs: number[][]): number {
+    const d: number[] = new Array(101).fill(0);
+    const offset = 1950;
+    for (const [birth, death] of logs) {
+        d[birth - offset]++;
+        d[death - offset]--;
+    }
+    let j = 0;
+    for (let i = 0, s = 0, mx = 0; i < d.length; ++i) {
+        s += d[i];
+        if (mx < s) {
+            mx = s;
+            j = i;
+        }
+    }
+    return j + offset;
 }
 ```