有两个水壶，容量分别为 jug1Capacity 和 jug2Capacity 升。水的供应是无限的。确定是否有可能使用这两个壶准确得到 targetCapacity 升。

如果可以得到 targetCapacity 升水，最后请用以上水壶中的一或两个来盛放取得的 targetCapacity 升水。

你可以：

• 装满任意一个水壶
• 清空任意一个水壶
• 从一个水壶向另外一个水壶倒水，直到装满或者倒空

示例 1:

输入: jug1Capacity = 3, jug2Capacity = 5, targetCapacity = 4
输出: true
解释：来自著名的 “Die Hard”

示例 2:

输入: jug1Capacity = 2, jug2Capacity = 6, targetCapacity = 5
输出: false

示例 3:

输入: jug1Capacity = 1, jug2Capacity = 2, targetCapacity = 3
输出: true

提示:

1 < = jug1Capacity, jug2Capacity, targetCapacity < = 106

方法一：深度优先搜索

思路及算法

首先对题目进行建模。观察题目可知，在任意一个时刻，此问题的状态可以由两个数字决定：X 壶中的水量，以及 Y 壶中的水量。

在任意一个时刻，我们可以且仅可以采取以下几种操作：

• 把 X 壶的水灌进 Y 壶，直至灌满或倒空；
• 把 Y 壶的水灌进 X 壶，直至灌满或倒空；
• 把 X 壶灌满；
• 把 Y 壶灌满；
• 把 X 壶倒空；
• 把 Y 壶倒空。

水壶问题是一个经典的数学问题，给定两个水壶的容量x和y，需要判断是否能够通过倒水的方式，将其中一个水壶中的水量准确地测量为z升。

代码中的_gen_states函数用于生成所有可能的状态。每个状态都是一个元组，表示两个水壶中的水量。函数中列举了六种可能的状态：

• 清空A杯：将A杯中的水倒空，即(0, b)
• 清空B杯：将B杯中的水倒空，即(a, 0)
• 把A杯装满：将A杯装满，即(x, b)
• 把B杯装满：将B杯装满，即(a, y)
• 把A杯倒入B杯，直到B杯满：将A杯中的水倒入B杯，直到B杯满。如果倒入后A杯中的水量加上B杯中的水量小于B杯的容量，那么状态为(0, a + b)，否则状态为(a + b - y, y)。
• 把B杯倒入A杯，直到A杯满：将B杯中的水倒入A杯，直到A杯满。如果倒入后A杯中的水量加上B杯中的水量小于A杯的容量，那么状态为(a + b, 0)，否则状态为(x, a + b - x)。

canMeasureWater函数使用BFS搜索状态空间，判断是否存在解。首先判断特殊情况，如果z小于0或者x和y的和小于z，那么肯定无法得到z升水量，直接返回False。然后使用队列q进行BFS，初始状态为0，表示两个水壶都是空的。使用集合visited记录已经访问过的状态，初始时将0加入visited。在BFS过程中，每次从队列中取出当前节点current_sum，如果current_sum等于z，那么找到了解，返回True。否则，根据current_sum生成下一层可能的状态，并判断是否已经访问过，如果没有访问过，则将其加入visited并加入队列q。如果遍历完所有可能的状态，仍然没有找到解，那么返回False。

在主函数中，创建了一个Solution对象sol，并分别调用了三个示例的测试用例。输出结果为True、False、True，分别表示第一个和第三个测试用例存在解，而第二个测试用例不存在解。

python

import math
import collections

# 生成所有可能的状态
def _gen_states(a, b, x, y):
    return [
        (0, b),  # 清空A杯
        (a, 0),  # 清空B杯
        (x, b),  # 把A杯装满
        (a, y),  # 把B杯装满
        (0, a + b) if a + b < y else (a + b - y, y),  # 把A杯倒入B杯，直到B杯满
        (a + b, 0) if a + b < x else (x, a + b - x)  # 把B杯倒入A杯，直到A杯满
    ]

class Solution(object):
    # 使用BFS搜索状态空间
    def canMeasureWater(self, x, y, z):
        if z < 0 or x + y < z:
            return False

        # 使用队列进行BFS
        q = collections.deque([0])
        visited = {0}

        while len(q):
            # 当前节点处理
            current_sum = q.popleft()
            if current_sum == z:
                return True

            # 生成下一层节点
            states = _gen_states(current_sum, y - current_sum, x, y)
            for state in states:
                if state not in visited:
                    visited.add(state)
                    q.append(sum(state))

        return False


if __name__ == '__main__':
    sol = Solution()
    print(sol.canMeasureWater(3, 5, 4))
    print(sol.canMeasureWater(1, 2, 3))
    print(sol.canMeasureWater(2, 6, 5))

方法二：数学法 - 最大公约数

思路

这是一道关于数论的题目，确切地说是关于裴蜀定理

摘自wiki的定义：
.
对任意两个整数 a、b，设 d是它们的最大公约数。那么关于未知数 x和 y的线性丢番图方程（称为裴蜀等式）：
ax+by=m
.
有整数解 (x,y) 当且仅当 m是 d的整数倍。裴蜀等式有解时必然有无穷多个解。

因此这道题可以完全转化为裴蜀定理。还是以题目给的例子x = 3, y = 5, z = 4，我们其实可以表示成3 * 3 - 1 * 5 = 4, 即3 * x - 1 * y = z。我们用a和b分别表示3
升的水壶和5升的水壶。那么我们可以：

• 倒满a（1）
• 将a倒到b
• 再次倒满a（2）
• 再次将a倒到b（a这个时候还剩下1升）
• 倒空b（-1）
• 将剩下的1升倒到b
• 将a倒满（3）
• 将a倒到b
• b此时正好是4升

上面的过程就是3 * x - 1 * y = z的具体过程解释。

也就是说我们只需要求出x和y的最大公约数d，并判断z是否是d的整数倍即可。

JavaScript

/**
 * @param {number} x
 * @param {number} y
 * @param {number} z
 * @return {boolean}
 */
var canMeasureWater = function(x, y, z) {
  if (x + y < z) return false;

  if (z === 0) return true;

  if (x === 0) return y === z;

  if (y === 0) return x === z;

  function GCD(a, b) {
    let min = Math.min(a, b);
    while (min) {
      if (a % min === 0 && b % min === 0) return min;
      min--;
    }
    return 1;
  }

  return z % GCD(x, y) === 0;
};

实际上求最大公约数还有更好的方式，比如辗转相除法：

def GCD(a, b):
    if b == 0: return a
    return GCD(b, a % b)

复杂度分析

• 时间复杂度：O(log(max(a,b)))O(log(max(a, b)))O(log(max(a,b)))
• 空间复杂度：空间复杂度取决于递归的深度，因此空间复杂度为 O(log(max(a,b)))O(log(max(a, b)))O(log(max(a,b)))。
• 如果将上述过程改成迭代，那么可以降低到O(1)O(1)O(1)，也不难

BFS、DFS模板