【BFS】两壶水倒出k升水

note

凡是"有限状态 + 固定操作 + 最少步数"的问题，本质都是无权图最短路，用 BFS。

文章目录

note
一、题目
二、思路
三、代码

一、题目

两瓶水，和可以接水的水龙头，一瓶水是8升，一瓶是5升，怎么倒出4升的水

二、思路

1、题目本质：在一个有限状态空间里，用一组固定操作，从初始状态走到目标状态，且通常希望步数最少

重点：只要同时满足这 4 点，BFS 就是首选：

状态是离散的、有限的

每一步操作"代价相同"（一次倒水 = 一步）

起点固定（(0,0)）

目标状态明确（x==4 或 y==4）

这和「最短路径 / 最少操作数」在无权图里是完全等价的。

2、状态 = 两个壶当前的水量

python 复制代码

(x, y)
x ∈ [0..8]
y ∈ [0..5]

总状态数最多：9 × 6 = 54（极小）

3、边（Edge）是什么？

从一个状态，通过一次合法操作，能到达的下一个状态。

合法操作永远只有这 6 类（固定、有限）：

操作	描述
Fill A	把 8L 壶装满
Fill B	把 5L 壶装满
Empty A	倒空 8L
Empty B	倒空 5L
Pour A→B	8L 往 5L 倒，直到 A 空或 B 满
Pour B→A	5L 往 8L 倒，直到 B 空或 A 满

关键点：

操作是确定性的

每个操作都算一步

不存在"更贵的操作"

4、图：这是一个：无权图、节点数很小、存在环（比如反复倒来倒去）

一看到"有环 + 要最短步数"，就该想到 visited + BFS：

python 复制代码

(0,0)
  |
  | Fill 5
  v
(0,5)
  |
  | Pour 5->8
  v
(5,0)
  ...

三、代码

python 复制代码

from collections import deque

A, B = 8, 5  # 壶容量：8L 和 5L
TARGET = 4

def neighbors(state):
    x, y = state
    res = []

    # 1) 装满
    res.append(((A, y), f"Fill 8L -> ({A}, {y})"))
    res.append(((x, B), f"Fill 5L -> ({x}, {B})"))

    # 2) 倒空
    res.append(((0, y), f"Empty 8L -> (0, {y})"))
    res.append(((x, 0), f"Empty 5L -> ({x}, 0)"))

    # 3) 8 -> 5 倒水
    pour = min(x, B - y)
    nx, ny = x - pour, y + pour
    res.append(((nx, ny), f"Pour 8->5 ({pour}L) -> ({nx}, {ny})"))

    # 4) 5 -> 8 倒水
    pour = min(y, A - x)
    nx, ny = x + pour, y - pour
    res.append(((nx, ny), f"Pour 5->8 ({pour}L) -> ({nx}, {ny})"))

    # 去掉没变化的动作（比如已经满了还 fill）
    res = [(s, a) for s, a in res if s != state]
    return res

def solve():
    start = (0, 0)
    q = deque([start])
    prev = {start: None}          # state -> previous state
    action = {start: None}        # state -> action string

    while q:
        cur = q.popleft()
        x, y = cur
        if x == TARGET or y == TARGET:
            # 回溯路径
            path = []
            while cur != start:
                path.append(action[cur])
                cur = prev[cur]
            path.reverse()
            return path

        for nxt, act in neighbors(cur):
            if nxt not in prev:
                prev[nxt] = cur
                action[nxt] = act
                q.append(nxt)
    return None

if __name__ == "__main__":
    path = solve()
    if not path:
        print("No solution.")
    else:
        print(f"Found solution in {len(path)} steps:")
        for i, step in enumerate(path, 1):
            print(f"{i:02d}. {step}")