Skip to content

Commit a59cc7b

Browse files
maolonglongmaolonglong
committed
feat: add solutions to lc problem: No.0629
No.0629.K Inverse Pairs Array
1 parent 9ddb23d commit a59cc7b

File tree

6 files changed

+288
-4
lines changed

6 files changed

+288
-4
lines changed

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

+108-2
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@
1717
<pre>
1818
<strong>输入:</strong> n = 3, k = 0
1919
<strong>输出:</strong> 1
20-
<strong>解释:</strong>
20+
<strong>解释:</strong>
2121
只有数组 [1,2,3] 包含了从1到3的整数并且正好拥有 0 个逆序对。
2222
</pre>
2323

@@ -26,7 +26,7 @@
2626
<pre>
2727
<strong>输入:</strong> n = 3, k = 1
2828
<strong>输出:</strong> 2
29-
<strong>解释:</strong>
29+
<strong>解释:</strong>
3030
数组 [1,3,2] 和 [2,1,3] 都有 1 个逆序对。
3131
</pre>
3232

@@ -41,22 +41,128 @@
4141

4242
<!-- 这里可写通用的实现逻辑 -->
4343

44+
动态规划，我们规定 `dp[i][j]` 表示 `i` 个数字恰好拥有 `j` 个逆序对的不同数组的个数，最终答案为 `dp[n][k]`
45+
46+
思考如何得到 `dp[i][j]`，假设 `i - 1` 个数字已经确定，现在插入 `i` 一共有 `i` 种情况：
47+
48+
- 放在第一个，由于 `i` 比之前的任何数都大，所以会产生 `i - 1` 个逆序对，为了凑够 `j` 个逆序对，之前确定的数需要产生 `j - (i - 1)` 个逆序对
49+
- 放在第二个，产生 `i - 2` 个逆序对，为了凑够 `j` 个逆序对，之前确定的数需要产生 `j - (i - 2)` 个逆序对
50+
- 放在第三个......同理
51+
- 放在最后一个，产生 `0` 个逆序对，之前确认的数需要产生 `j` 个逆序对
52+
53+
可得状态转移公式：`dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]`
54+
55+
看到这种累加，很容易想到需要用前缀和进行优化。最终 `dp[i][]` 只依赖前缀和数组，甚至连 `dp[i - 1][]` 都不需要，所以可以进一步用一维数组优化空间
56+
4457
<!-- tabs:start -->
4558

4659
### **Python3**
4760

4861
<!-- 这里可写当前语言的特殊实现逻辑 -->
4962

5063
```python
64+
class Solution:
65+
def kInversePairs(self, n: int, k: int) -> int:
66+
mod = 1000000007
67+
dp, pre = [0] * (k + 1), [0] * (k + 2)
68+
for i in range(1, n + 1):
69+
dp[0] = 1
5170

71+
# dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
72+
for j in range(1, k + 1):
73+
dp[j] = (pre[j + 1] - pre[max(0, j - i + 1)] + mod) % mod
74+
75+
for j in range(1, k + 2):
76+
pre[j] = (pre[j - 1] + dp[j - 1]) % mod
77+
78+
return dp[k]
5279
```
5380

5481
### **Java**
5582

5683
<!-- 这里可写当前语言的特殊实现逻辑 -->
5784

5885
```java
86+
class Solution {
87+
88+
private static final int MOD = 1000000007;
89+
90+
public int kInversePairs(int n, int k) {
91+
int[] dp = new int[k + 1];
92+
int[] pre = new int[k + 2];
93+
for (int i = 1; i <= n; i++) {
94+
dp[0] = 1;
95+
96+
// dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
97+
for (int j = 1; j <= k; j++) {
98+
dp[j] = (pre[j + 1] - pre[Math.max(0, j - i + 1)] + MOD) % MOD;
99+
}
100+
101+
for (int j = 1; j <= k + 1; j++) {
102+
pre[j] = (pre[j - 1] + dp[j - 1]) % MOD;
103+
}
104+
}
105+
return dp[k];
106+
}
107+
}
108+
```
109+
110+
### **Go**
111+
112+
```go
113+
const mod int = 1e9 + 7
114+
115+
func kInversePairs(n int, k int) int {
116+
dp := make([]int, k+1)
117+
pre := make([]int, k+2)
118+
for i := 1; i <= n; i++ {
119+
dp[0] = 1
120+
121+
// dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
122+
for j := 1; j <= k; j++ {
123+
dp[j] = (pre[j+1] - pre[max(0, j-i+1)] + mod) % mod
124+
}
125+
126+
for j := 1; j <= k+1; j++ {
127+
pre[j] = (pre[j-1] + dp[j-1]) % mod
128+
}
129+
}
130+
return dp[k]
131+
}
132+
133+
func max(a, b int) int {
134+
if a > b {
135+
return a
136+
}
137+
return b
138+
}
139+
```
59140

141+
### **C++**
142+
143+
```cpp
144+
class Solution {
145+
private:
146+
static constexpr int MOD = 1e9 + 7;
147+
148+
public:
149+
int kInversePairs(int n, int k) {
150+
vector<int> dp(k + 1), pre(k + 2, 0);
151+
for (int i = 1; i <= n; ++i) {
152+
dp[0] = 1;
153+
154+
// dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
155+
for (int j = 1; j <= k; ++j) {
156+
dp[j] = (pre[j + 1] - pre[max(0, j - i + 1)] + MOD) % MOD;
157+
}
158+
159+
for (int j = 1; j <= k + 1; ++j) {
160+
pre[j] = (pre[j - 1] + dp[j - 1]) % MOD;
161+
}
162+
}
163+
return dp[k];
164+
}
165+
};
60166
```
61167

62168
### **...**

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

+95-2
Original file line numberDiff line numberDiff line change
@@ -26,7 +26,7 @@
2626

2727
<b>Output:</b> 1
2828

29-
<b>Explanation:</b>
29+
<b>Explanation:</b>
3030

3131
Only the array [1,2,3] which consists of numbers from 1 to 3 has exactly 0 inverse pair.
3232

@@ -48,7 +48,7 @@ Only the array [1,2,3] which consists of numbers from 1 to 3 has exactly 0 inver
4848

4949
<b>Output:</b> 2
5050

51-
<b>Explanation:</b>
51+
<b>Explanation:</b>
5252

5353
The array [1,3,2] and [2,1,3] have exactly 1 inverse pair.
5454

@@ -81,13 +81,106 @@ The array [1,3,2] and [2,1,3] have exactly 1 inverse pair.
8181
### **Python3**
8282

8383
```python
84+
class Solution:
85+
def kInversePairs(self, n: int, k: int) -> int:
86+
mod = 1000000007
87+
dp, pre = [0] * (k + 1), [0] * (k + 2)
88+
for i in range(1, n + 1):
89+
dp[0] = 1
8490

91+
# dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
92+
for j in range(1, k + 1):
93+
dp[j] = (pre[j + 1] - pre[max(0, j - i + 1)] + mod) % mod
94+
95+
for j in range(1, k + 2):
96+
pre[j] = (pre[j - 1] + dp[j - 1]) % mod
97+
98+
return dp[k]
8599
```
86100

87101
### **Java**
88102

89103
```java
104+
class Solution {
105+
106+
private static final int MOD = 1000000007;
107+
108+
public int kInversePairs(int n, int k) {
109+
int[] dp = new int[k + 1];
110+
int[] pre = new int[k + 2];
111+
for (int i = 1; i <= n; i++) {
112+
dp[0] = 1;
113+
114+
// dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
115+
for (int j = 1; j <= k; j++) {
116+
dp[j] = (pre[j + 1] - pre[Math.max(0, j - i + 1)] + MOD) % MOD;
117+
}
118+
119+
for (int j = 1; j <= k + 1; j++) {
120+
pre[j] = (pre[j - 1] + dp[j - 1]) % MOD;
121+
}
122+
}
123+
return dp[k];
124+
}
125+
}
126+
```
127+
128+
### **Go**
129+
130+
```go
131+
const mod int = 1e9 + 7
132+
133+
func kInversePairs(n int, k int) int {
134+
dp := make([]int, k+1)
135+
pre := make([]int, k+2)
136+
for i := 1; i <= n; i++ {
137+
dp[0] = 1
138+
139+
// dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
140+
for j := 1; j <= k; j++ {
141+
dp[j] = (pre[j+1] - pre[max(0, j-i+1)] + mod) % mod
142+
}
143+
144+
for j := 1; j <= k+1; j++ {
145+
pre[j] = (pre[j-1] + dp[j-1]) % mod
146+
}
147+
}
148+
return dp[k]
149+
}
150+
151+
func max(a, b int) int {
152+
if a > b {
153+
return a
154+
}
155+
return b
156+
}
157+
```
90158

159+
### **C++**
160+
161+
```cpp
162+
class Solution {
163+
private:
164+
static constexpr int MOD = 1e9 + 7;
165+
166+
public:
167+
int kInversePairs(int n, int k) {
168+
vector<int> dp(k + 1), pre(k + 2, 0);
169+
for (int i = 1; i <= n; ++i) {
170+
dp[0] = 1;
171+
172+
// dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
173+
for (int j = 1; j <= k; ++j) {
174+
dp[j] = (pre[j + 1] - pre[max(0, j - i + 1)] + MOD) % MOD;
175+
}
176+
177+
for (int j = 1; j <= k + 1; ++j) {
178+
pre[j] = (pre[j - 1] + dp[j - 1]) % MOD;
179+
}
180+
}
181+
return dp[k];
182+
}
183+
};
91184
```
92185

93186
### **...**

‎solution/0600-0699/0629.K Inverse Pairs Array/Solution.cpp

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
private:
3+
static constexpr int MOD = 1e9 + 7;
4+
5+
public:
6+
int kInversePairs(int n, int k) {
7+
vector<int> dp(k + 1), pre(k + 2, 0);
8+
for (int i = 1; i <= n; ++i) {
9+
dp[0] = 1;
10+
11+
// dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
12+
for (int j = 1; j <= k; ++j) {
13+
dp[j] = (pre[j + 1] - pre[max(0, j - i + 1)] + MOD) % MOD;
14+
}
15+
16+
for (int j = 1; j <= k + 1; ++j) {
17+
pre[j] = (pre[j - 1] + dp[j - 1]) % MOD;
18+
}
19+
}
20+
return dp[k];
21+
}
22+
};

‎solution/0600-0699/0629.K Inverse Pairs Array/Solution.go

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
const mod int = 1e9 + 7
2+
3+
func kInversePairs(n int, k int) int {
4+
dp := make([]int, k+1)
5+
pre := make([]int, k+2)
6+
for i := 1; i <= n; i++ {
7+
dp[0] = 1
8+
9+
// dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
10+
for j := 1; j <= k; j++ {
11+
dp[j] = (pre[j+1] - pre[max(0, j-i+1)] + mod) % mod
12+
}
13+
14+
for j := 1; j <= k+1; j++ {
15+
pre[j] = (pre[j-1] + dp[j-1]) % mod
16+
}
17+
}
18+
return dp[k]
19+
}
20+
21+
func max(a, b int) int {
22+
if a > b {
23+
return a
24+
}
25+
return b
26+
}

‎solution/0600-0699/0629.K Inverse Pairs Array/Solution.java

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
3+
private static final int MOD = 1000000007;
4+
5+
public int kInversePairs(int n, int k) {
6+
int[] dp = new int[k + 1];
7+
int[] pre = new int[k + 2];
8+
for (int i = 1; i <= n; i++) {
9+
dp[0] = 1;
10+
11+
// dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
12+
for (int j = 1; j <= k; j++) {
13+
dp[j] = (pre[j + 1] - pre[Math.max(0, j - i + 1)] + MOD) % MOD;
14+
}
15+
16+
for (int j = 1; j <= k + 1; j++) {
17+
pre[j] = (pre[j - 1] + dp[j - 1]) % MOD;
18+
}
19+
}
20+
return dp[k];
21+
}
22+
}

‎solution/0600-0699/0629.K Inverse Pairs Array/Solution.py

+15
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution:
2+
def kInversePairs(self, n: int, k: int) -> int:
3+
mod = 1000000007
4+
dp, pre = [0] * (k + 1), [0] * (k + 2)
5+
for i in range(1, n + 1):
6+
dp[0] = 1
7+
8+
# dp[i][j] = dp[i - 1][j - (i - 1)] + ... + dp[i - 1][j]
9+
for j in range(1, k + 1):
10+
dp[j] = (pre[j + 1] - pre[max(0, j - i + 1)] + mod) % mod
11+
12+
for j in range(1, k + 2):
13+
pre[j] = (pre[j - 1] + dp[j - 1]) % mod
14+
15+
return dp[k]

0 commit comments

Comments
 (0)