Skip to content

Commit 594029a

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.2137 (doocs#1290)
No.2137.Pour Water Between Buckets to Make Water Levels Equal
1 parent e56cf67 commit 594029a

File tree

8 files changed

+330
-6
lines changed

8 files changed

+330
-6
lines changed

‎solution/1500-1599/1570.Dot Product of Two Sparse Vectors/README.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -140,7 +140,7 @@ class SparseVector {
140140
public:
141141
unordered_map<int, int> d;
142142

143-
SparseVector(vector<int> &nums) {
143+
SparseVector(vector<int>& nums) {
144144
for (int i = 0; i < nums.size(); ++i) {
145145
if (nums[i]) {
146146
d[i] = nums[i];

‎solution/1500-1599/1570.Dot Product of Two Sparse Vectors/README_EN.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -122,7 +122,7 @@ class SparseVector {
122122
public:
123123
unordered_map<int, int> d;
124124

125-
SparseVector(vector<int> &nums) {
125+
SparseVector(vector<int>& nums) {
126126
for (int i = 0; i < nums.size(); ++i) {
127127
if (nums[i]) {
128128
d[i] = nums[i];

‎solution/2100-2199/2137.Pour Water Between Buckets to Make Water Levels Equal/README.md

Lines changed: 119 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -56,27 +56,143 @@
5656

5757
<!-- 这里可写通用的实现逻辑 -->
5858

59+
**方法一：二分查找（浮点数二分）**
60+
61+
我们注意到，如果一个水量 $x$ 满足条件，那么所有小于 $x$ 的水量也满足条件。因此我们可以使用二分查找的方法找到最大的满足条件的水量。
62+
63+
我们定义二分查找的左边界 $l=0$，右边界 $r=\max(buckets)$。每次二分查找时，我们取 $l$ 和 $r$ 的中点 $m$，判断 $m$ 是否满足条件。如果满足条件，那么我们将 $l$ 更新为 $m$，否则我们将 $r$ 更新为 $m$。在二分查找结束后，最大的满足条件的水量即为 $l$。
64+
65+
问题的关键转换为如果判断一个水量 $v$ 是否满足条件。我们可以遍历所有水桶，对于每个水桶，如果其水量大于 $v$，那么需要倒出 $x-v$ 的水量；如果其水量小于 $v$，那么需要向其中倒入 $(v-x)\times\frac{100}{100-\textit{loss}}$ 的水量。如果倒出的水量大于等于倒入的水量，那么说明 $v$ 满足条件。
66+
67+
时间复杂度 $O(n \times \log M)$，其中 $n$ 和 $M$ 分别是数组 $buckets$ 的长度和最大值。二分查找的时间复杂度为 $O(\log M)$，每次二分查找需要遍历数组 $buckets$，时间复杂度为 $O(n)$。空间复杂度 $O(1)$。
68+
5969
<!-- tabs:start -->
6070

6171
### **Python3**
6272

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

6575
```python
66-
76+
class Solution:
77+
def equalizeWater(self, buckets: List[int], loss: int) -> float:
78+
def check(v):
79+
a = b = 0
80+
for x in buckets:
81+
if x >= v:
82+
a += x - v
83+
else:
84+
b += (v - x) * 100 / (100 - loss)
85+
return a >= b
86+
87+
l, r = 0, max(buckets)
88+
while r - l > 1e-5:
89+
mid = (l + r) / 2
90+
if check(mid):
91+
l = mid
92+
else:
93+
r = mid
94+
return l
6795
```
6896

6997
### **Java**
7098

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

73101
```java
102+
class Solution {
103+
public double equalizeWater(int[] buckets, int loss) {
104+
double l = 0, r = Arrays.stream(buckets).max().getAsInt();
105+
while (r - l > 1e-5) {
106+
double mid = (l + r) / 2;
107+
if (check(buckets, loss, mid)) {
108+
l = mid;
109+
} else {
110+
r = mid;
111+
}
112+
}
113+
return l;
114+
}
115+
116+
private boolean check(int[] buckets, int loss, double v) {
117+
double a = 0;
118+
double b = 0;
119+
for (int x : buckets) {
120+
if (x > v) {
121+
a += x - v;
122+
} else {
123+
b += (v - x) * 100 / (100 - loss);
124+
}
125+
}
126+
return a >= b;
127+
}
128+
}
129+
```
74130

131+
### **C++**
132+
133+
```cpp
134+
class Solution {
135+
public:
136+
double equalizeWater(vector<int>& buckets, int loss) {
137+
double l = 0, r = *max_element(buckets.begin(), buckets.end());
138+
auto check = [&](double v) {
139+
double a = 0, b = 0;
140+
for (int x : buckets) {
141+
if (x > v) {
142+
a += x - v;
143+
} else {
144+
b += (v - x) * 100 / (100 - loss);
145+
}
146+
}
147+
return a >= b;
148+
};
149+
while (r - l > 1e-5) {
150+
double mid = (l + r) / 2;
151+
if (check(mid)) {
152+
l = mid;
153+
} else {
154+
r = mid;
155+
}
156+
}
157+
return l;
158+
}
159+
};
75160
```
76161
77-
### **TypeScript**
162+
### **Go**
163+
164+
```go
165+
func equalizeWater(buckets []int, loss int) float64 {
166+
var l, r float64
167+
for _, x := range buckets {
168+
r = math.Max(r, float64(x))
169+
}
170+
171+
check := func(v float64) bool {
172+
var a, b float64
173+
for _, x := range buckets {
174+
if float64(x) >= v {
175+
a += float64(x) - v
176+
} else {
177+
b += (v - float64(x)) * 100 / float64(100-loss)
178+
}
179+
}
180+
return a >= b
181+
}
182+
183+
for r-l > 1e-5 {
184+
mid := (l + r) / 2
185+
if check(mid) {
186+
l = mid
187+
} else {
188+
r = mid
189+
}
190+
}
191+
return l
192+
}
193+
```
78194

79-
<!-- 这里可写当前语言的特殊实现逻辑 -->
195+
### **TypeScript**
80196

81197
```ts
82198

‎solution/2100-2199/2137.Pour Water Between Buckets to Make Water Levels Equal/README_EN.md

Lines changed: 109 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,13 +58,121 @@ All buckets have 3.5 gallons of water in them so return 3.5.
5858
### **Python3**
5959

6060
```python
61-
61+
class Solution:
62+
def equalizeWater(self, buckets: List[int], loss: int) -> float:
63+
def check(v):
64+
a = b = 0
65+
for x in buckets:
66+
if x >= v:
67+
a += x - v
68+
else:
69+
b += (v - x) * 100 / (100 - loss)
70+
return a >= b
71+
72+
l, r = 0, max(buckets)
73+
while r - l > 1e-5:
74+
mid = (l + r) / 2
75+
if check(mid):
76+
l = mid
77+
else:
78+
r = mid
79+
return l
6280
```
6381

6482
### **Java**
6583

6684
```java
85+
class Solution {
86+
public double equalizeWater(int[] buckets, int loss) {
87+
double l = 0, r = Arrays.stream(buckets).max().getAsInt();
88+
while (r - l > 1e-5) {
89+
double mid = (l + r) / 2;
90+
if (check(buckets, loss, mid)) {
91+
l = mid;
92+
} else {
93+
r = mid;
94+
}
95+
}
96+
return l;
97+
}
98+
99+
private boolean check(int[] buckets, int loss, double v) {
100+
double a = 0;
101+
double b = 0;
102+
for (int x : buckets) {
103+
if (x > v) {
104+
a += x - v;
105+
} else {
106+
b += (v - x) * 100 / (100 - loss);
107+
}
108+
}
109+
return a >= b;
110+
}
111+
}
112+
```
113+
114+
### **C++**
115+
116+
```cpp
117+
class Solution {
118+
public:
119+
double equalizeWater(vector<int>& buckets, int loss) {
120+
double l = 0, r = *max_element(buckets.begin(), buckets.end());
121+
auto check = [&](double v) {
122+
double a = 0, b = 0;
123+
for (int x : buckets) {
124+
if (x > v) {
125+
a += x - v;
126+
} else {
127+
b += (v - x) * 100 / (100 - loss);
128+
}
129+
}
130+
return a >= b;
131+
};
132+
while (r - l > 1e-5) {
133+
double mid = (l + r) / 2;
134+
if (check(mid)) {
135+
l = mid;
136+
} else {
137+
r = mid;
138+
}
139+
}
140+
return l;
141+
}
142+
};
143+
```
67144
145+
### **Go**
146+
147+
```go
148+
func equalizeWater(buckets []int, loss int) float64 {
149+
var l, r float64
150+
for _, x := range buckets {
151+
r = math.Max(r, float64(x))
152+
}
153+
154+
check := func(v float64) bool {
155+
var a, b float64
156+
for _, x := range buckets {
157+
if float64(x) >= v {
158+
a += float64(x) - v
159+
} else {
160+
b += (v - float64(x)) * 100 / float64(100-loss)
161+
}
162+
}
163+
return a >= b
164+
}
165+
166+
for r-l > 1e-5 {
167+
mid := (l + r) / 2
168+
if check(mid) {
169+
l = mid
170+
} else {
171+
r = mid
172+
}
173+
}
174+
return l
175+
}
68176
```
69177

70178
### **TypeScript**

‎solution/2100-2199/2137.Pour Water Between Buckets to Make Water Levels Equal/Solution.cpp

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
double equalizeWater(vector<int>& buckets, int loss) {
4+
double l = 0, r = *max_element(buckets.begin(), buckets.end());
5+
auto check = [&](double v) {
6+
double a = 0, b = 0;
7+
for (int x : buckets) {
8+
if (x > v) {
9+
a += x - v;
10+
} else {
11+
b += (v - x) * 100 / (100 - loss);
12+
}
13+
}
14+
return a >= b;
15+
};
16+
while (r - l > 1e-5) {
17+
double mid = (l + r) / 2;
18+
if (check(mid)) {
19+
l = mid;
20+
} else {
21+
r = mid;
22+
}
23+
}
24+
return l;
25+
}
26+
};

‎solution/2100-2199/2137.Pour Water Between Buckets to Make Water Levels Equal/Solution.go

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
func equalizeWater(buckets []int, loss int) float64 {
2+
var l, r float64
3+
for _, x := range buckets {
4+
r = math.Max(r, float64(x))
5+
}
6+
7+
check := func(v float64) bool {
8+
var a, b float64
9+
for _, x := range buckets {
10+
if float64(x) >= v {
11+
a += float64(x) - v
12+
} else {
13+
b += (v - float64(x)) * 100 / float64(100-loss)
14+
}
15+
}
16+
return a >= b
17+
}
18+
19+
for r-l > 1e-5 {
20+
mid := (l + r) / 2
21+
if check(mid) {
22+
l = mid
23+
} else {
24+
r = mid
25+
}
26+
}
27+
return l
28+
}

‎solution/2100-2199/2137.Pour Water Between Buckets to Make Water Levels Equal/Solution.java

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
class Solution {
2+
public double equalizeWater(int[] buckets, int loss) {
3+
double l = 0, r = Arrays.stream(buckets).max().getAsInt();
4+
while (r - l > 1e-5) {
5+
double mid = (l + r) / 2;
6+
if (check(buckets, loss, mid)) {
7+
l = mid;
8+
} else {
9+
r = mid;
10+
}
11+
}
12+
return l;
13+
}
14+
15+
private boolean check(int[] buckets, int loss, double v) {
16+
double a = 0;
17+
double b = 0;
18+
for (int x : buckets) {
19+
if (x > v) {
20+
a += x - v;
21+
} else {
22+
b += (v - x) * 100 / (100 - loss);
23+
}
24+
}
25+
return a >= b;
26+
}
27+
}

‎solution/2100-2199/2137.Pour Water Between Buckets to Make Water Levels Equal/Solution.py

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution:
2+
def equalizeWater(self, buckets: List[int], loss: int) -> float:
3+
def check(v):
4+
a = b = 0
5+
for x in buckets:
6+
if x >= v:
7+
a += x - v
8+
else:
9+
b += (v - x) * 100 / (100 - loss)
10+
return a >= b
11+
12+
l, r = 0, max(buckets)
13+
while r - l > 1e-5:
14+
mid = (l + r) / 2
15+
if check(mid):
16+
l = mid
17+
else:
18+
r = mid
19+
return l

0 commit comments

Comments
 (0)