feat: add solutions to lc problem: No.0629

No.0629.K Inverse Pairs Array

Author: yanglbme

solution/0600-0699/0629.K Inverse Pairs Array/README.md

@@ -78,6 +78,46 @@ class Solution:
         return dp[k]
 ```
 
+`dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1] + dp[i - 1][j - 2] + ... + dp[i - 1][j - (i - 1)]` ①
+
+`dp[i][j - 1] =            dp[i - 1][j - 1] + dp[i - 1][j - 2] + ... + dp[i - 1][j - (i - 1)] + dp[i - 1][j - i]` ②
+
+① - ②，得 `dp[i][j] = dp[i][j - 1] + dp[i - 1][j] - dp[i - 1][j - i]`
+
+```python
+class Solution:
+    def kInversePairs(self, n: int, k: int) -> int:
+        N, MOD = 1010, int(1e9) + 7
+        dp = [[0] * N for _ in range(N)]
+        dp[1][0] = 1
+        for i in range(2, n + 1):
+            dp[i][0] = 1
+            for j in range(1, k + 1):
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+                if j >= i:
+                    dp[i][j] -= dp[i - 1][j - i]
+                dp[i][j] %= MOD
+        return dp[n][k]
+```
+
+空间优化：
+
+```python
+class Solution:
+    def kInversePairs(self, n: int, k: int) -> int:
+        N, MOD = 1010, int(1e9) + 7
+        dp = [0] * N
+        dp[0] = 1
+        for i in range(2, n + 1):
+            t = dp.copy()
+            for j in range(1, k + 1):
+                dp[j] = t[j] + dp[j - 1]
+                if j >= i:
+                    dp[j] -= t[j - i]
+                dp[j] %= MOD
+        return dp[k]
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -107,6 +147,26 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int kInversePairs(int n, int k) {
+        int N = 1010, MOD = (int) (1e9 + 7);
+        int[][] dp = new int[N][N];
+        dp[1][0] = 1;
+        for (int i = 2; i < n + 1; ++i) {
+            dp[i][0] = 1;
+            for (int j = 1; j < k + 1; ++j) {
+                dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % MOD;
+                if (j >= i) {
+                    dp[i][j] = (dp[i][j] - dp[i - 1][j - i] + MOD) % MOD;
+                }
+            }
+        }
+        return dp[n][k];
+    }
+}
+```
+
 ### **Go**
 
 ```go

solution/0600-0699/0629.K Inverse Pairs Array/README_EN.md

@@ -6,20 +6,12 @@
 
 <p>Given two integers <code>n</code> and <code>k</code>, find how many different arrays consist of numbers from <code>1</code> to <code>n</code> such that there are exactly <code>k</code> inverse pairs.</p>
 
-
-
 <p>We define an inverse pair as following: For <code>i<sub>th</sub></code> and <code>j<sub>th</sub></code> element in the array, if <code>i</code> &lt; <code>j</code> and <code>a[i]</code> &gt; <code>a[j]</code> then it&#39;s an inverse pair; Otherwise, it&#39;s not.</p>
 
-
-
 <p>Since the answer may be very large, the answer should be modulo 10<sup>9</sup> + 7.</p>
 
-
-
 <p><b>Example 1:</b></p>
 
-
-
 <pre>
 
 <b>Input:</b> n = 3, k = 0
@@ -32,16 +24,10 @@ Only the array [1,2,3] which consists of numbers from 1 to 3 has exactly 0 inver
 
 </pre>
 
-
-
 <p>&nbsp;</p>
 
-
-
 <p><b>Example 2:</b></p>
 
-
-
 <pre>
 
 <b>Input:</b> n = 3, k = 1
@@ -54,26 +40,16 @@ The array [1,3,2] and [2,1,3] have exactly 1 inverse pair.
 
 </pre>
 
-
-
 <p>&nbsp;</p>
 
-
-
 <p><b>Note:</b></p>
 
-
-
 <ol>
 	<li>The integer <code>n</code> is in the range [1, 1000] and <code>k</code> is in the range [0, 1000].</li>
 </ol>
 
-
-
 <p>&nbsp;</p>
 
-
-
 ## Solutions
 
 <!-- tabs:start -->
@@ -98,6 +74,44 @@ class Solution:
         return dp[k]
 ```
 
+`dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1] + dp[i - 1][j - 2] + ... + dp[i - 1][j - (i - 1)]` ①
+
+`dp[i][j - 1] = dp[i - 1][j - 1] + dp[i - 1][j - 2] + ... + dp[i - 1][j - (i - 1)] + dp[i - 1][j - i]` ②
+
+① - ②, `dp[i][j] = dp[i][j - 1] + dp[i - 1][j] - dp[i - 1][j - i]`
+
+```python
+class Solution:
+    def kInversePairs(self, n: int, k: int) -> int:
+        N, MOD = 1010, int(1e9) + 7
+        dp = [[0] * N for _ in range(N)]
+        dp[1][0] = 1
+        for i in range(2, n + 1):
+            dp[i][0] = 1
+            for j in range(1, k + 1):
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+                if j >= i:
+                    dp[i][j] -= dp[i - 1][j - i]
+                dp[i][j] %= MOD
+        return dp[n][k]
+```
+
+```python
+class Solution:
+    def kInversePairs(self, n: int, k: int) -> int:
+        N, MOD = 1010, int(1e9) + 7
+        dp = [0] * N
+        dp[0] = 1
+        for i in range(2, n + 1):
+            t = dp.copy()
+            for j in range(1, k + 1):
+                dp[j] = t[j] + dp[j - 1]
+                if j >= i:
+                    dp[j] -= t[j - i]
+                dp[j] %= MOD
+        return dp[k]
+```
+
 ### **Java**
 
 ```java
@@ -125,6 +139,26 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int kInversePairs(int n, int k) {
+        int N = 1010, MOD = (int) (1e9 + 7);
+        int[][] dp = new int[N][N];
+        dp[1][0] = 1;
+        for (int i = 2; i < n + 1; ++i) {
+            dp[i][0] = 1;
+            for (int j = 1; j < k + 1; ++j) {
+                dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % MOD;
+                if (j >= i) {
+                    dp[i][j] = (dp[i][j] - dp[i - 1][j - i] + MOD) % MOD;
+                }
+            }
+        }
+        return dp[n][k];
+    }
+}
+```
+
 ### **Go**
 
 ```go