Description#
You are given two jugs with capacities jug1Capacity and jug2Capacity liters. There is an infinite amount of water supply available. Determine whether it is possible to measure exactly targetCapacity liters using these two jugs.
If targetCapacity liters of water are measurable, you must have targetCapacity liters of water contained within one or both buckets by the end.
Operations allowed:
- Fill any of the jugs with water.
- Empty any of the jugs.
- Pour water from one jug into another till the other jug is completely full, or the first jug itself is empty.
Example 1:
Input: jug1Capacity = 3, jug2Capacity = 5, targetCapacity = 4
Output: true
Explanation: The famous Die Hard example
Example 2:
Input: jug1Capacity = 2, jug2Capacity = 6, targetCapacity = 5
Output: false
Example 3:
Input: jug1Capacity = 1, jug2Capacity = 2, targetCapacity = 3
Output: true
Constraints:
1 <= jug1Capacity, jug2Capacity, targetCapacity <= 106
Solutions#
Solution 1#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| class Solution:
def canMeasureWater(
self, jug1Capacity: int, jug2Capacity: int, targetCapacity: int
) -> bool:
stk, seen = [], set()
stk.append([0, 0])
def get_hash(nums):
return nums[0] * 10000006 + nums[1]
while stk:
if get_hash(stk[-1]) in seen:
stk.pop()
continue
seen.add(get_hash(stk[-1]))
cur = stk.pop()
cur1, cur2 = cur[0], cur[1]
if (
cur1 == targetCapacity
or cur2 == targetCapacity
or cur1 + cur2 == targetCapacity
):
return True
stk.append([jug1Capacity, cur2])
stk.append([0, cur2])
stk.append([cur1, jug2Capacity])
stk.append([cur1, 0])
if cur1 + cur2 > jug1Capacity:
stk.append([jug1Capacity, cur2 - jug1Capacity + cur1])
else:
stk.append([cur1 + cur2, 0])
if cur1 + cur2 > jug2Capacity:
stk.append([cur1 - jug2Capacity + cur2, jug2Capacity])
else:
stk.append([0, cur1 + cur2])
return False
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| class Solution {
public boolean canMeasureWater(int jug1Capacity, int jug2Capacity, int targetCapacity) {
Deque<int[]> stk = new ArrayDeque<>();
stk.add(new int[] {0, 0});
Set<Long> seen = new HashSet<>();
while (!stk.isEmpty()) {
if (seen.contains(hash(stk.peek()))) {
stk.pop();
continue;
}
int[] cur = stk.pop();
seen.add(hash(cur));
int cur1 = cur[0], cur2 = cur[1];
if (cur1 == targetCapacity || cur2 == targetCapacity || cur1 + cur2 == targetCapacity) {
return true;
}
stk.offer(new int[] {jug1Capacity, cur2});
stk.offer(new int[] {0, cur2});
stk.offer(new int[] {cur1, jug1Capacity});
stk.offer(new int[] {cur2, 0});
if (cur1 + cur2 > jug1Capacity) {
stk.offer(new int[] {jug1Capacity, cur2 - jug1Capacity + cur1});
} else {
stk.offer(new int[] {cur1 + cur2, 0});
}
if (cur1 + cur2 > jug2Capacity) {
stk.offer(new int[] {cur1 - jug2Capacity + cur2, jug2Capacity});
} else {
stk.offer(new int[] {0, cur1 + cur2});
}
}
return false;
}
public long hash(int[] nums) {
return nums[0] * 10000006L + nums[1];
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
| class Solution {
public:
bool canMeasureWater(int jug1Capacity, int jug2Capacity, int targetCapacity) {
if (jug1Capacity + jug2Capacity < targetCapacity) return false;
if (jug1Capacity == 0 || jug2Capacity == 0)
return targetCapacity == 0 || jug1Capacity + jug2Capacity == targetCapacity;
return targetCapacity % gcd(jug1Capacity, jug2Capacity) == 0;
}
int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| func canMeasureWater(jug1Capacity int, jug2Capacity int, targetCapacity int) bool {
if jug1Capacity+jug2Capacity < targetCapacity {
return false
}
if jug1Capacity == 0 || jug2Capacity == 0 {
return targetCapacity == 0 || jug1Capacity+jug2Capacity == targetCapacity
}
var gcd func(a, b int) int
gcd = func(a, b int) int {
if b == 0 {
return a
}
return gcd(b, a%b)
}
return targetCapacity%gcd(jug1Capacity, jug2Capacity) == 0
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| using System;
public class Solution {
public bool CanMeasureWater(int x, int y, int z) {
if (x == 0 || y == 0) return z == x || z == y;
var gcd = GetGcd(x, y);
return z >= 0 && z <= x + y && z % gcd == 0;
}
private int GetGcd(int x, int y)
{
while (x > 0)
{
var quotient = x / y;
var reminder = x % y;
if (reminder == 0)
{
return y;
}
x = y;
y = reminder;
}
throw new Exception("Invalid x or y");
}
}
|
Solution 2#
1
2
3
4
5
6
7
8
9
| class Solution:
def canMeasureWater(
self, jug1Capacity: int, jug2Capacity: int, targetCapacity: int
) -> bool:
if jug1Capacity + jug2Capacity < targetCapacity:
return False
if jug1Capacity == 0 or jug2Capacity == 0:
return targetCapacity == 0 or jug1Capacity + jug2Capacity == targetCapacity
return targetCapacity % gcd(jug1Capacity, jug2Capacity) == 0
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| class Solution {
public boolean canMeasureWater(int jug1Capacity, int jug2Capacity, int targetCapacity) {
if (jug1Capacity + jug2Capacity < targetCapacity) {
return false;
}
if (jug1Capacity == 0 || jug2Capacity == 0) {
return targetCapacity == 0 || jug1Capacity + jug2Capacity == targetCapacity;
}
return targetCapacity % gcd(jug1Capacity, jug2Capacity) == 0;
}
private int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
}
|
