feat: add solutions to lc problem: No.3193 (doocs#3156)

No.3193.Count the Number of Inversions

Author: yanglbme

solution/0400-0499/0419.Battleships in a Board/README.md

@@ -25,7 +25,7 @@ tags:
 <p>&nbsp;</p>
 
 <p><strong>示例 1：</strong></p>
-<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0400-0499/0419.Battleships%20in%20a%20Board/images/battelship-grid.jpg" style="width: 333px; height: 333px;" />
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0400-0499/0419.Battleships%20in%20a%20Board/images/1719200420-KKnzye-image.png" style="width: 333px; height: 333px;" />
 <pre>
 <strong>输入：</strong>board = [["X",".",".","X"],[".",".",".","X"],[".",".",".","X"]]
 <strong>输出：</strong>2

solution/0400-0499/0419.Battleships in a Board/images/1719200420-KKnzye-image.png

@@ -18,46 +18,46 @@ tags:
 
 <!-- description:start -->
 
-<p>给定一个由整数数组组成的数组<code>arrays</code>，其中<code>arrays[i]</code>是严格递增排序的，返回一个表示所有数组之间的最长公共子序列的整数数组。</p>
+<p>给定一个由整数数组组成的数组&nbsp;<code>arrays</code>，其中&nbsp;<code>arrays[i]</code>&nbsp;是 <strong>严格递增</strong> 排序的，返回一个表示 <strong>所有</strong> 数组之间的 <strong>最长公共子序列</strong> 的整数数组。</p>
 
-<p>子序列是从另一个序列派生出来的序列，删除一些元素或不删除任何元素，而不改变其余元素的顺序。</p>
+<p><strong>子序列</strong> 是从另一个序列派生出来的序列，删除一些元素或不删除任何元素，而不改变其余元素的顺序。</p>
 
 <p><strong>示例1:</strong></p>
 
 <pre>
-<strong>输入:</strong> arrays = [[<strong><em>1</em></strong>,3,<strong><em>4</em></strong>],
-               [<strong><em>1</em></strong>,<strong><em>4</em></strong>,7,9]]
+<strong>输入:</strong> arrays = [[<u>1</u>,3,<u>4</u>],
+&nbsp;              [<u>1</u>,<u>4</u>,7,9]]
 <strong>输出:</strong> [1,4]
-<strong>解释:</strong> 这两个数组中的最长子序列是[1,4]。
+<strong>解释:</strong>&nbsp;这两个数组中的最长子序列是[1,4]。
 </pre>
 
 <p><strong>示例 2:</strong></p>
 
 <pre>
-<strong>输入:</strong> arrays = [[<strong><em>2</em></strong>,<strong><em>3</em></strong>,<strong><em>6</em></strong>,8],
-               [1,<strong><em>2</em></strong>,<strong><em>3</em></strong>,5,<strong><em>6</em></strong>,7,10],
-               [<strong><em>2</em></strong>,<strong><em>3</em></strong>,4,<em><strong>6</strong></em>,9]]
+<strong>输入:</strong> arrays = [[<u>2</u>,<u>3</u>,<u>6</u>,8],
+&nbsp;              [1,<u>2</u>,<u>3</u>,5,<u>6</u>,7,10],
+&nbsp;              [<u>2</u>,<u>3</u>,4,<u>6</u>,9]]
 <strong>输出:</strong> [2,3,6]
-<strong>解释:</strong> 这三个数组中的最长子序列是[2,3,6]。
+<strong>解释:</strong>&nbsp;这三个数组中的最长子序列是 [2,3,6]。
 </pre>
 
 <p><strong>示例 3:</strong></p>
 
 <pre>
 <strong>输入:</strong> arrays = [[1,2,3,4,5],
-               [6,7,8]]
+&nbsp;              [6,7,8]]
 <strong>输出:</strong> []
-<strong>解释:</strong> 这两个数组之间没有公共子序列。
+<strong>解释:</strong>&nbsp;这两个数组之间没有公共子序列。
 </pre>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>限制条件:</strong></p>
 
 <ul>
-	<li><code>2 <= arrays.length <= 100</code></li>
-	<li><code>1 <= arrays[i].length <= 100</code></li>
-	<li><code>1 <= arrays[i][j] <= 100</code></li>
+	<li><code>2 &lt;= arrays.length &lt;= 100</code></li>
+	<li><code>1 &lt;= arrays[i].length &lt;= 100</code></li>
+	<li><code>1 &lt;= arrays[i][j] &lt;= 100</code></li>
 	<li><code>arrays[i]</code> 是严格递增排序.</li>
 </ul>
 

solution/1900-1999/1940.Longest Common Subsequence Between Sorted Arrays/README.md

@@ -18,7 +18,7 @@ tags:
 
 <!-- description:start -->
 
-<p>Given an array of integer arrays <code>arrays</code> where each <code>arrays[i]</code> is sorted in <strong>strictly increasing</strong> order, return <em>an integer array representing the <strong>longest common subsequence</strong> between <strong>all</strong> the arrays</em>.</p>
+<p>Given an array of integer arrays <code>arrays</code> where each <code>arrays[i]</code> is sorted in <strong>strictly increasing</strong> order, return <em>an integer array representing the <strong>longest common subsequence</strong> among&nbsp;<strong>all</strong> the arrays</em>.</p>
 
 <p>A <strong>subsequence</strong> is a sequence that can be derived from another sequence by deleting some elements (possibly none) without changing the order of the remaining elements.</p>
 

solution/1900-1999/1940.Longest Common Subsequence Between Sorted Arrays/README_EN.md

@@ -25,7 +25,7 @@ tags:
 
 <p>The <strong>cost</strong> of going from a position <code>(x1, y1)</code> to any other position in the space <code>(x2, y2)</code> is <code>|x2 - x1| + |y2 - y1|</code>.</p>
 
-<p>There are also some <strong>special roads</strong>. You are given a 2D array <code>specialRoads</code> where <code>specialRoads[i] = [x1<sub>i</sub>, y1<sub>i</sub>, x2<sub>i</sub>, y2<sub>i</sub>, cost<sub>i</sub>]</code> indicates that the <code>i<sup>th</sup></code> special road goes in <strong>on direction</strong> from <code>(x1<sub>i</sub>, y1<sub>i</sub>)</code> to <code>(x2<sub>i</sub>, y2<sub>i</sub>)</code> with a cost equal to <code>cost<sub>i</sub></code>. You can use each special road any number of times.</p>
+<p>There are also some <strong>special roads</strong>. You are given a 2D array <code>specialRoads</code> where <code>specialRoads[i] = [x1<sub>i</sub>, y1<sub>i</sub>, x2<sub>i</sub>, y2<sub>i</sub>, cost<sub>i</sub>]</code> indicates that the <code>i<sup>th</sup></code> special road goes in <strong>one direction</strong> from <code>(x1<sub>i</sub>, y1<sub>i</sub>)</code> to <code>(x2<sub>i</sub>, y2<sub>i</sub>)</code> with a cost equal to <code>cost<sub>i</sub></code>. You can use each special road any number of times.</p>
 
 <p>Return the <strong>minimum</strong> cost required to go from <code>(startX, startY)</code> to <code>(targetX, targetY)</code>.</p>
 

solution/2600-2699/2662.Minimum Cost of a Path With Special Roads/README_EN.md

@@ -116,32 +116,181 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3193.Co
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：动态规划
+
+我们定义 $f[i][j]$ 表示 $[0..i]$ 的排列中，逆序对数量为 $j$ 的排列数。考虑下标为 $i$ 的数 $a_i$ 与前面 $i$ 个数的大小关系。如果 $a_i$ 比前面 $k$ 个数小，那么前面的 $k$ 个数与 $a_i$ 都构成了逆序对，逆序对数量为 $k$。因此，我们可以得到状态转移方程：
+
+$$
+f[i][j] = \sum_{k=0}^{\min(i, j)} f[i-1][j-k]
+$$
+
+由于题目要求 $[0..\text{end}_i]$ 的逆序对数量为 $\text{cnt}_i$，因此，当我们计算 $i = \text{end}_i$ 时，我们只需要计算 $f[i][\text{cnt}_i]$ 即可。其余的 $f[i][..]$ 都为 $0$。
+
+时间复杂度 $O(n \times m \times \min(n, m))$，空间复杂度 $O(n \times m)$。其中 $m$ 是逆序对数量的最大值。本题中 $m \le 400$。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def numberOfPermutations(self, n: int, requirements: List[List[int]]) -> int:
+        req = [-1] * n
+        for end, cnt in requirements:
+            req[end] = cnt
+        if req[0] > 0:
+            return 0
+        req[0] = 0
+        mod = 10**9 + 7
+        m = max(req)
+        f = [[0] * (m + 1) for _ in range(n)]
+        f[0][0] = 1
+        for i in range(1, n):
+            l, r = 0, m
+            if req[i] >= 0:
+                l = r = req[i]
+            for j in range(l, r + 1):
+                for k in range(min(i, j) + 1):
+                    f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod
+        return f[n - 1][req[n - 1]]
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int numberOfPermutations(int n, int[][] requirements) {
+        int[] req = new int[n];
+        Arrays.fill(req, -1);
+        int m = 0;
+        for (var r : requirements) {
+            req[r[0]] = r[1];
+            m = Math.max(m, r[1]);
+        }
+        if (req[0] > 0) {
+            return 0;
+        }
+        req[0] = 0;
+        final int mod = (int) 1e9 + 7;
+        int[][] f = new int[n][m + 1];
+        f[0][0] = 1;
+        for (int i = 1; i < n; ++i) {
+            int l = 0, r = m;
+            if (req[i] >= 0) {
+                l = r = req[i];
+            }
+            for (int j = l; j <= r; ++j) {
+                for (int k = 0; k <= Math.min(i, j); ++k) {
+                    f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod;
+                }
+            }
+        }
+        return f[n - 1][req[n - 1]];
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int numberOfPermutations(int n, vector<vector<int>>& requirements) {
+        vector<int> req(n, -1);
+        int m = 0;
+        for (const auto& r : requirements) {
+            req[r[0]] = r[1];
+            m = max(m, r[1]);
+        }
+        if (req[0] > 0) {
+            return 0;
+        }
+        req[0] = 0;
+        const int mod = 1e9 + 7;
+        vector<vector<int>> f(n, vector<int>(m + 1, 0));
+        f[0][0] = 1;
+        for (int i = 1; i < n; ++i) {
+            int l = 0, r = m;
+            if (req[i] >= 0) {
+                l = r = req[i];
+            }
+            for (int j = l; j <= r; ++j) {
+                for (int k = 0; k <= min(i, j); ++k) {
+                    f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod;
+                }
+            }
+        }
+        return f[n - 1][req[n - 1]];
+    }
+};
 ```
 
 #### Go
 
 ```go
+func numberOfPermutations(n int, requirements [][]int) int {
+	req := make([]int, n)
+	for i := range req {
+		req[i] = -1
+	}
+	for _, r := range requirements {
+		req[r[0]] = r[1]
+	}
+	if req[0] > 0 {
+		return 0
+	}
+	req[0] = 0
+	m := slices.Max(req)
+	const mod = int(1e9 + 7)
+	f := make([][]int, n)
+	for i := range f {
+		f[i] = make([]int, m+1)
+	}
+	f[0][0] = 1
+	for i := 1; i < n; i++ {
+		l, r := 0, m
+		if req[i] >= 0 {
+			l, r = req[i], req[i]
+		}
+		for j := l; j <= r; j++ {
+			for k := 0; k <= min(i, j); k++ {
+				f[i][j] = (f[i][j] + f[i-1][j-k]) % mod
+			}
+		}
+	}
+	return f[n-1][req[n-1]]
+}
+```
 
+#### TypeScript
+
+```ts
+function numberOfPermutations(n: number, requirements: number[][]): number {
+    const req: number[] = Array(n).fill(-1);
+    for (const [end, cnt] of requirements) {
+        req[end] = cnt;
+    }
+    if (req[0] > 0) {
+        return 0;
+    }
+    req[0] = 0;
+    const m = Math.max(...req);
+    const mod = 1e9 + 7;
+    const f = Array.from({ length: n }, () => Array(m + 1).fill(0));
+    f[0][0] = 1;
+    for (let i = 1; i < n; ++i) {
+        let [l, r] = [0, m];
+        if (req[i] >= 0) {
+            l = r = req[i];
+        }
+        for (let j = l; j <= r; ++j) {
+            for (let k = 0; k <= Math.min(i, j); ++k) {
+                f[i][j] = (f[i][j] + f[i - 1][j - k]) % mod;
+            }
+        }
+    }
+    return f[n - 1][req[n - 1]];
+}
 ```
 
 <!-- tabs:end -->