Skip to content

Commit ea37ddc

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2638
No.2638.Count the Number of K-Free Subsets
1 parent feefabb commit ea37ddc

File tree

7 files changed

+375
-6
lines changed

7 files changed

+375
-6
lines changed

‎solution/2600-2699/2638.Count the Number of K-Free Subsets/README.md

+133-3
Original file line numberDiff line numberDiff line change
@@ -52,34 +52,164 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
**方法一：分组 + 动态规划**
56+
57+
我们先将数组 $nums$ 按照升序排序，然后将数组中的元素按照模 $k$ 分组，即 $nums[i] \bmod k$ 相同的元素放在同一组中。那么对于任意两个不同组的元素，它们的差值的绝对值一定不等于 $k$。因此，我们可以求出每一组的子集个数，然后将每一组的子集个数相乘即可得到答案。
58+
59+
对于每一组 $arr$，我们可以使用动态规划求出子集个数。设 $f[i]$ 表示前 $i$ 个元素的子集个数，初始时 $f[0] = 1$，而 $f[1]=2$。当 $i \geq 2$ 时，如果 $arr[i-1]-arr[i-2]=k$，如果我们选择 $arr[i-1]$，那么 $f[i]=f[i-2]$；如果我们不选择 $arr[i-1]$，那么 $f[i]=f[i-1]$。因此，当 $arr[i-1]-arr[i-2]=k$ 时，有 $f[i]=f[i-1]+f[i-2]$；否则 $f[i] = f[i - 1] \times 2$。这一组的子集个数即为 $f[m]$，其中 $m$ 为数组 $arr$ 的长度。
60+
61+
最后，我们将每一组的子集个数相乘即可得到答案。
62+
63+
时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
64+
5565
<!-- tabs:start -->
5666

5767
### **Python3**
5868

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

6171
```python
62-
72+
class Solution:
73+
def countTheNumOfKFreeSubsets(self, nums: List[int], k: int) -> int:
74+
nums.sort()
75+
g = defaultdict(list)
76+
for x in nums:
77+
g[x % k].append(x)
78+
ans = 1
79+
for arr in g.values():
80+
m = len(arr)
81+
f = [0] * (m + 1)
82+
f[0] = 1
83+
f[1] = 2
84+
for i in range(2, m + 1):
85+
if arr[i - 1] - arr[i - 2] == k:
86+
f[i] = f[i - 1] + f[i - 2]
87+
else:
88+
f[i] = f[i - 1] * 2
89+
ans *= f[m]
90+
return ans
6391
```
6492

6593
### **Java**
6694

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

6997
```java
70-
98+
class Solution {
99+
public long countTheNumOfKFreeSubsets(int[] nums, int k) {
100+
Arrays.sort(nums);
101+
Map<Integer, List<Integer>> g = new HashMap<>();
102+
for (int i = 0; i < nums.length; ++i) {
103+
g.computeIfAbsent(nums[i] % k, x -> new ArrayList<>()).add(nums[i]);
104+
}
105+
long ans = 1;
106+
for (var arr : g.values()) {
107+
int m = arr.size();
108+
long[] f = new long[m + 1];
109+
f[0] = 1;
110+
f[1] = 2;
111+
for (int i = 2; i <= m; ++i) {
112+
if (arr.get(i - 1) - arr.get(i - 2) == k) {
113+
f[i] = f[i - 1] + f[i - 2];
114+
} else {
115+
f[i] = f[i - 1] * 2;
116+
}
117+
}
118+
ans *= f[m];
119+
}
120+
return ans;
121+
}
122+
}
71123
```
72124

73125
### **C++**
74126

75127
```cpp
76-
128+
class Solution {
129+
public:
130+
long long countTheNumOfKFreeSubsets(vector<int>& nums, int k) {
131+
sort(nums.begin(), nums.end());
132+
unordered_map<int, vector<int>> g;
133+
for (int i = 0; i < nums.size(); ++i) {
134+
g[nums[i] % k].push_back(nums[i]);
135+
}
136+
long long ans = 1;
137+
for (auto& [_, arr] : g) {
138+
int m = arr.size();
139+
long long f[m + 1];
140+
f[0] = 1;
141+
f[1] = 2;
142+
for (int i = 2; i <= m; ++i) {
143+
if (arr[i - 1] - arr[i - 2] == k) {
144+
f[i] = f[i - 1] + f[i - 2];
145+
} else {
146+
f[i] = f[i - 1] * 2;
147+
}
148+
}
149+
ans *= f[m];
150+
}
151+
return ans;
152+
}
153+
};
77154
```
78155
79156
### **Go**
80157
81158
```go
159+
func countTheNumOfKFreeSubsets(nums []int, k int) int64 {
160+
sort.Ints(nums)
161+
g := map[int][]int{}
162+
for _, x := range nums {
163+
g[x%k] = append(g[x%k], x)
164+
}
165+
ans := int64(1)
166+
for _, arr := range g {
167+
m := len(arr)
168+
f := make([]int64, m+1)
169+
f[0] = 1
170+
f[1] = 2
171+
for i := 2; i <= m; i++ {
172+
if arr[i-1]-arr[i-2] == k {
173+
f[i] = f[i-1] + f[i-2]
174+
} else {
175+
f[i] = f[i-1] * 2
176+
}
177+
}
178+
ans *= f[m]
179+
}
180+
return ans
181+
}
182+
```
82183

184+
### **TypeScript**
185+
186+
```ts
187+
function countTheNumOfKFreeSubsets(nums: number[], k: number): number {
188+
nums.sort((a, b) => a - b);
189+
const g: Map<number, number[]> = new Map();
190+
for (const x of nums) {
191+
const y = x % k;
192+
if (!g.has(y)) {
193+
g.set(y, []);
194+
}
195+
g.get(y)!.push(x);
196+
}
197+
let ans: number = 1;
198+
for (const [_, arr] of g) {
199+
const m = arr.length;
200+
const f: number[] = new Array(m + 1).fill(1);
201+
f[1] = 2;
202+
for (let i = 2; i <= m; ++i) {
203+
if (arr[i - 1] - arr[i - 2] === k) {
204+
f[i] = f[i - 1] + f[i - 2];
205+
} else {
206+
f[i] = f[i - 1] * 2;
207+
}
208+
}
209+
ans *= f[m];
210+
}
211+
return ans;
212+
}
83213
```
84214

85215
### **...**

‎solution/2600-2699/2638.Count the Number of K-Free Subsets/README_EN.md

+123-3
Original file line numberDiff line numberDiff line change
@@ -53,25 +53,145 @@
5353
### **Python3**
5454

5555
```python
56-
56+
class Solution:
57+
def countTheNumOfKFreeSubsets(self, nums: List[int], k: int) -> int:
58+
nums.sort()
59+
g = defaultdict(list)
60+
for x in nums:
61+
g[x % k].append(x)
62+
ans = 1
63+
for arr in g.values():
64+
m = len(arr)
65+
f = [0] * (m + 1)
66+
f[0] = 1
67+
f[1] = 2
68+
for i in range(2, m + 1):
69+
if arr[i - 1] - arr[i - 2] == k:
70+
f[i] = f[i - 1] + f[i - 2]
71+
else:
72+
f[i] = f[i - 1] * 2
73+
ans *= f[m]
74+
return ans
5775
```
5876

5977
### **Java**
6078

6179
```java
62-
80+
class Solution {
81+
public long countTheNumOfKFreeSubsets(int[] nums, int k) {
82+
Arrays.sort(nums);
83+
Map<Integer, List<Integer>> g = new HashMap<>();
84+
for (int i = 0; i < nums.length; ++i) {
85+
g.computeIfAbsent(nums[i] % k, x -> new ArrayList<>()).add(nums[i]);
86+
}
87+
long ans = 1;
88+
for (var arr : g.values()) {
89+
int m = arr.size();
90+
long[] f = new long[m + 1];
91+
f[0] = 1;
92+
f[1] = 2;
93+
for (int i = 2; i <= m; ++i) {
94+
if (arr.get(i - 1) - arr.get(i - 2) == k) {
95+
f[i] = f[i - 1] + f[i - 2];
96+
} else {
97+
f[i] = f[i - 1] * 2;
98+
}
99+
}
100+
ans *= f[m];
101+
}
102+
return ans;
103+
}
104+
}
63105
```
64106

65107
### **C++**
66108

67109
```cpp
68-
110+
class Solution {
111+
public:
112+
long long countTheNumOfKFreeSubsets(vector<int>& nums, int k) {
113+
sort(nums.begin(), nums.end());
114+
unordered_map<int, vector<int>> g;
115+
for (int i = 0; i < nums.size(); ++i) {
116+
g[nums[i] % k].push_back(nums[i]);
117+
}
118+
long long ans = 1;
119+
for (auto& [_, arr] : g) {
120+
int m = arr.size();
121+
long long f[m + 1];
122+
f[0] = 1;
123+
f[1] = 2;
124+
for (int i = 2; i <= m; ++i) {
125+
if (arr[i - 1] - arr[i - 2] == k) {
126+
f[i] = f[i - 1] + f[i - 2];
127+
} else {
128+
f[i] = f[i - 1] * 2;
129+
}
130+
}
131+
ans *= f[m];
132+
}
133+
return ans;
134+
}
135+
};
69136
```
70137
71138
### **Go**
72139
73140
```go
141+
func countTheNumOfKFreeSubsets(nums []int, k int) int64 {
142+
sort.Ints(nums)
143+
g := map[int][]int{}
144+
for _, x := range nums {
145+
g[x%k] = append(g[x%k], x)
146+
}
147+
ans := int64(1)
148+
for _, arr := range g {
149+
m := len(arr)
150+
f := make([]int64, m+1)
151+
f[0] = 1
152+
f[1] = 2
153+
for i := 2; i <= m; i++ {
154+
if arr[i-1]-arr[i-2] == k {
155+
f[i] = f[i-1] + f[i-2]
156+
} else {
157+
f[i] = f[i-1] * 2
158+
}
159+
}
160+
ans *= f[m]
161+
}
162+
return ans
163+
}
164+
```
74165

166+
### **TypeScript**
167+
168+
```ts
169+
function countTheNumOfKFreeSubsets(nums: number[], k: number): number {
170+
nums.sort((a, b) => a - b);
171+
const g: Map<number, number[]> = new Map();
172+
for (const x of nums) {
173+
const y = x % k;
174+
if (!g.has(y)) {
175+
g.set(y, []);
176+
}
177+
g.get(y)!.push(x);
178+
}
179+
let ans: number = 1;
180+
for (const [_, arr] of g) {
181+
const m = arr.length;
182+
const f: number[] = new Array(m + 1).fill(1);
183+
f[1] = 2;
184+
for (let i = 2; i <= m; ++i) {
185+
if (arr[i - 1] - arr[i - 2] === k) {
186+
f[i] = f[i - 1] + f[i - 2];
187+
} else {
188+
f[i] = f[i - 1] * 2;
189+
}
190+
}
191+
ans *= f[m];
192+
}
193+
return ans;
194+
}
75195
```
76196

77197
### **...**

‎solution/2600-2699/2638.Count the Number of K-Free Subsets/Solution.cpp

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
long long countTheNumOfKFreeSubsets(vector<int>& nums, int k) {
4+
sort(nums.begin(), nums.end());
5+
unordered_map<int, vector<int>> g;
6+
for (int i = 0; i < nums.size(); ++i) {
7+
g[nums[i] % k].push_back(nums[i]);
8+
}
9+
long long ans = 1;
10+
for (auto& [_, arr] : g) {
11+
int m = arr.size();
12+
long long f[m + 1];
13+
f[0] = 1;
14+
f[1] = 2;
15+
for (int i = 2; i <= m; ++i) {
16+
if (arr[i - 1] - arr[i - 2] == k) {
17+
f[i] = f[i - 1] + f[i - 2];
18+
} else {
19+
f[i] = f[i - 1] * 2;
20+
}
21+
}
22+
ans *= f[m];
23+
}
24+
return ans;
25+
}
26+
};

‎solution/2600-2699/2638.Count the Number of K-Free Subsets/Solution.go

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
func countTheNumOfKFreeSubsets(nums []int, k int) int64 {
2+
sort.Ints(nums)
3+
g := map[int][]int{}
4+
for _, x := range nums {
5+
g[x%k] = append(g[x%k], x)
6+
}
7+
ans := int64(1)
8+
for _, arr := range g {
9+
m := len(arr)
10+
f := make([]int64, m+1)
11+
f[0] = 1
12+
f[1] = 2
13+
for i := 2; i <= m; i++ {
14+
if arr[i-1]-arr[i-2] == k {
15+
f[i] = f[i-1] + f[i-2]
16+
} else {
17+
f[i] = f[i-1] * 2
18+
}
19+
}
20+
ans *= f[m]
21+
}
22+
return ans
23+
}

‎solution/2600-2699/2638.Count the Number of K-Free Subsets/Solution.java

+25
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
class Solution {
2+
public long countTheNumOfKFreeSubsets(int[] nums, int k) {
3+
Arrays.sort(nums);
4+
Map<Integer, List<Integer>> g = new HashMap<>();
5+
for (int i = 0; i < nums.length; ++i) {
6+
g.computeIfAbsent(nums[i] % k, x -> new ArrayList<>()).add(nums[i]);
7+
}
8+
long ans = 1;
9+
for (var arr : g.values()) {
10+
int m = arr.size();
11+
long[] f = new long[m + 1];
12+
f[0] = 1;
13+
f[1] = 2;
14+
for (int i = 2; i <= m; ++i) {
15+
if (arr.get(i - 1) - arr.get(i - 2) == k) {
16+
f[i] = f[i - 1] + f[i - 2];
17+
} else {
18+
f[i] = f[i - 1] * 2;
19+
}
20+
}
21+
ans *= f[m];
22+
}
23+
return ans;
24+
}
25+
}

0 commit comments

Comments
 (0)