Skip to content

Commit 733ef7a

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0416.Partition Equal Subset Sum
1 parent 2c1bafc commit 733ef7a

File tree

6 files changed

+304
-2
lines changed

6 files changed

+304
-2
lines changed

‎solution/0400-0499/0416.Partition Equal Subset Sum/README.md

Lines changed: 114 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -34,27 +34,140 @@
3434
<li><code>1 <= nums[i] <= 100</code></li>
3535
</ul>
3636

37-
3837
## 解法
3938

4039
<!-- 这里可写通用的实现逻辑 -->
4140

41+
题目可以转换为 `0-1` 背包问题，在 m 个数字中选出一些数字（每个数字只能使用一次），这些数字之和恰好等于 `s / 2`（s 表示所有数字之和）。
42+
4243
<!-- tabs:start -->
4344

4445
### **Python3**
4546

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

4849
```python
50+
class Solution:
51+
def canPartition(self, nums: List[int]) -> bool:
52+
s = sum(nums)
53+
if s % 2 != 0:
54+
return False
55+
56+
m, n = len(nums), (s >> 1) + 1
57+
dp = [[False] * n for _ in range(m)]
58+
for i in range(m):
59+
dp[i][0] = True
60+
if nums[0] < n:
61+
dp[0][nums[0]] = True
62+
63+
for i in range(1, m):
64+
for j in range(n):
65+
dp[i][j] = dp[i - 1][j]
66+
if not dp[i][j] and nums[i] <= j:
67+
dp[i][j] = dp[i - 1][j - nums[i]]
68+
return dp[-1][-1]
69+
```
70+
71+
空间优化：
4972

73+
```python
74+
class Solution:
75+
def canPartition(self, nums: List[int]) -> bool:
76+
s = sum(nums)
77+
if s % 2 != 0:
78+
return False
79+
80+
m, n = len(nums), (s >> 1) + 1
81+
dp = [False] * n
82+
dp[0] = True
83+
if nums[0] < n:
84+
dp[nums[0]] = True
85+
86+
for i in range(1, m):
87+
for j in range(n - 1, nums[i] - 1, -1):
88+
dp[j] = dp[j] or dp[j - nums[i]]
89+
return dp[-1]
5090
```
5191

5292
### **Java**
5393

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

5696
```java
97+
class Solution {
98+
public boolean canPartition(int[] nums) {
99+
int s = 0;
100+
for (int x : nums) {
101+
s += x;
102+
}
103+
if (s % 2 != 0) {
104+
return false;
105+
}
106+
int m = nums.length, n = (s >> 1) + 1;
107+
boolean[] dp = new boolean[n];
108+
dp[0] = true;
109+
if (nums[0] < n) {
110+
dp[nums[0]] = true;
111+
}
112+
for (int i = 1; i < m; ++i) {
113+
for (int j = n - 1; j >= nums[i]; --j) {
114+
dp[j] = dp[j] || dp[j - nums[i]];
115+
}
116+
}
117+
return dp[n - 1];
118+
}
119+
}
120+
```
121+
122+
### **C++**
123+
124+
```cpp
125+
class Solution {
126+
public:
127+
bool canPartition(vector<int>& nums) {
128+
int s = 0;
129+
for (int x : nums) s += x;
130+
if (s % 2 != 0) return false;
131+
int m = nums.size(), n = (s >> 1) + 1;
132+
vector<bool> dp(n);
133+
dp[0] = true;
134+
if (nums[0] < n) dp[nums[0]] = true;
135+
for (int i = 1; i < m; ++i)
136+
{
137+
for (int j = n - 1; j >= nums[i]; --j)
138+
{
139+
dp[j] = dp[j] || dp[j - nums[i]];
140+
}
141+
}
142+
return dp[n - 1];
143+
}
144+
};
145+
```
57146
147+
### **Go**
148+
149+
```go
150+
func canPartition(nums []int) bool {
151+
s := 0
152+
for _, x := range nums {
153+
s += x
154+
}
155+
if s%2 != 0 {
156+
return false
157+
}
158+
m, n := len(nums), (s>>1)+1
159+
dp := make([]bool, n)
160+
dp[0] = true
161+
if nums[0] < n {
162+
dp[nums[0]] = true
163+
}
164+
for i := 1; i < m; i++ {
165+
for j := n - 1; j >= nums[i]; j-- {
166+
dp[j] = dp[j] || dp[j-nums[i]]
167+
}
168+
}
169+
return dp[n-1]
170+
}
58171
```
59172

60173
### **...**

‎solution/0400-0499/0416.Partition Equal Subset Sum/README_EN.md

Lines changed: 110 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -31,21 +31,130 @@
3131
<li><code>1 &lt;= nums[i] &lt;= 100</code></li>
3232
</ul>
3333

34-
3534
## Solutions
3635

3736
<!-- tabs:start -->
3837

3938
### **Python3**
4039

4140
```python
41+
class Solution:
42+
def canPartition(self, nums: List[int]) -> bool:
43+
s = sum(nums)
44+
if s % 2 != 0:
45+
return False
46+
47+
m, n = len(nums), (s >> 1) + 1
48+
dp = [[False] * n for _ in range(m)]
49+
for i in range(m):
50+
dp[i][0] = True
51+
if nums[0] < n:
52+
dp[0][nums[0]] = True
53+
54+
for i in range(1, m):
55+
for j in range(n):
56+
dp[i][j] = dp[i - 1][j]
57+
if not dp[i][j] and nums[i] <= j:
58+
dp[i][j] = dp[i - 1][j - nums[i]]
59+
return dp[-1][-1]
60+
```
4261

62+
```python
63+
class Solution:
64+
def canPartition(self, nums: List[int]) -> bool:
65+
s = sum(nums)
66+
if s % 2 != 0:
67+
return False
68+
69+
m, n = len(nums), (s >> 1) + 1
70+
dp = [False] * n
71+
dp[0] = True
72+
if nums[0] < n:
73+
dp[nums[0]] = True
74+
75+
for i in range(1, m):
76+
for j in range(n - 1, nums[i] - 1, -1):
77+
dp[j] = dp[j] or dp[j - nums[i]]
78+
return dp[-1]
4379
```
4480

4581
### **Java**
4682

4783
```java
84+
class Solution {
85+
public boolean canPartition(int[] nums) {
86+
int s = 0;
87+
for (int x : nums) {
88+
s += x;
89+
}
90+
if (s % 2 != 0) {
91+
return false;
92+
}
93+
int m = nums.length, n = (s >> 1) + 1;
94+
boolean[] dp = new boolean[n];
95+
dp[0] = true;
96+
if (nums[0] < n) {
97+
dp[nums[0]] = true;
98+
}
99+
for (int i = 1; i < m; ++i) {
100+
for (int j = n - 1; j >= nums[i]; --j) {
101+
dp[j] = dp[j] || dp[j - nums[i]];
102+
}
103+
}
104+
return dp[n - 1];
105+
}
106+
}
107+
```
108+
109+
### **C++**
110+
111+
```cpp
112+
class Solution {
113+
public:
114+
bool canPartition(vector<int>& nums) {
115+
int s = 0;
116+
for (int x : nums) s += x;
117+
if (s % 2 != 0) return false;
118+
int m = nums.size(), n = (s >> 1) + 1;
119+
vector<bool> dp(n);
120+
dp[0] = true;
121+
if (nums[0] < n) dp[nums[0]] = true;
122+
for (int i = 1; i < m; ++i)
123+
{
124+
for (int j = n - 1; j >= nums[i]; --j)
125+
{
126+
dp[j] = dp[j] || dp[j - nums[i]];
127+
}
128+
}
129+
return dp[n - 1];
130+
}
131+
};
132+
```
48133
134+
### **Go**
135+
136+
```go
137+
func canPartition(nums []int) bool {
138+
s := 0
139+
for _, x := range nums {
140+
s += x
141+
}
142+
if s%2 != 0 {
143+
return false
144+
}
145+
m, n := len(nums), (s>>1)+1
146+
dp := make([]bool, n)
147+
dp[0] = true
148+
if nums[0] < n {
149+
dp[nums[0]] = true
150+
}
151+
for i := 1; i < m; i++ {
152+
for j := n - 1; j >= nums[i]; j-- {
153+
dp[j] = dp[j] || dp[j-nums[i]]
154+
}
155+
}
156+
return dp[n-1]
157+
}
49158
```
50159

51160
### **...**

‎solution/0400-0499/0416.Partition Equal Subset Sum/Solution.cpp

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
class Solution {
2+
public:
3+
bool canPartition(vector<int>& nums) {
4+
int s = 0;
5+
for (int x : nums) s += x;
6+
if (s % 2 != 0) return false;
7+
int m = nums.size(), n = (s >> 1) + 1;
8+
vector<bool> dp(n);
9+
dp[0] = true;
10+
if (nums[0] < n) dp[nums[0]] = true;
11+
for (int i = 1; i < m; ++i)
12+
{
13+
for (int j = n - 1; j >= nums[i]; --j)
14+
{
15+
dp[j] = dp[j] || dp[j - nums[i]];
16+
}
17+
}
18+
return dp[n - 1];
19+
}
20+
};

‎solution/0400-0499/0416.Partition Equal Subset Sum/Solution.go

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
func canPartition(nums []int) bool {
2+
s := 0
3+
for _, x := range nums {
4+
s += x
5+
}
6+
if s%2 != 0 {
7+
return false
8+
}
9+
m, n := len(nums), (s>>1)+1
10+
dp := make([]bool, n)
11+
dp[0] = true
12+
if nums[0] < n {
13+
dp[nums[0]] = true
14+
}
15+
for i := 1; i < m; i++ {
16+
for j := n - 1; j >= nums[i]; j-- {
17+
dp[j] = dp[j] || dp[j-nums[i]]
18+
}
19+
}
20+
return dp[n-1]
21+
}

‎solution/0400-0499/0416.Partition Equal Subset Sum/Solution.java

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public boolean canPartition(int[] nums) {
3+
int s = 0;
4+
for (int x : nums) {
5+
s += x;
6+
}
7+
if (s % 2 != 0) {
8+
return false;
9+
}
10+
int m = nums.length, n = (s >> 1) + 1;
11+
boolean[] dp = new boolean[n];
12+
dp[0] = true;
13+
if (nums[0] < n) {
14+
dp[nums[0]] = true;
15+
}
16+
for (int i = 1; i < m; ++i) {
17+
for (int j = n - 1; j >= nums[i]; --j) {
18+
dp[j] = dp[j] || dp[j - nums[i]];
19+
}
20+
}
21+
return dp[n - 1];
22+
}
23+
}

‎solution/0400-0499/0416.Partition Equal Subset Sum/Solution.py

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
class Solution:
2+
def canPartition(self, nums: List[int]) -> bool:
3+
s = sum(nums)
4+
if s % 2 != 0:
5+
return False
6+
7+
m, n = len(nums), (s >> 1) + 1
8+
dp = [False] * n
9+
dp[0] = True
10+
if nums[0] < n:
11+
dp[nums[0]] = True
12+
13+
for i in range(1, m):
14+
for j in range(n - 1, nums[i] - 1, -1):
15+
dp[j] = dp[j] or dp[j - nums[i]]
16+
return dp[-1]

0 commit comments

Comments
 (0)