蓝桥杯倒水问题：BFS算法解析与Python实现-代码聚汇网

蓝桥杯倒水问题：BFS算法解析与Python实现

广度优先搜索BFS算法蓝桥杯

|难度：普通|阅读约 13 分钟

1. 题目背景与核心需求解析

"倒水"问题是蓝桥杯竞赛中经典的算法题型，属于数学建模与逻辑推理类题目。这类问题通常描述为：给定若干不同容量的容器，通过一系列倒水操作（装满、倒空、互相倾倒），最终在某个容器中得到特定量的水。

从题目编号P12167和"2025省C/Python A"的信息可以推断，这是蓝桥杯省级选拔赛的一道中高难度题目，主要考察参赛者的以下能力：

数学建模能力（将实际问题抽象为数学模型）
广度优先搜索（BFS）算法的应用
状态空间的分析与优化
编程实现中的边界条件处理

典型的问题描述可能如下：
"有两个无刻度容器，容量分别为A升和B升（A和B为正整数）。允许进行以下操作：

装满任意一个容器
倒空任意一个容器
将一个容器的水倒入另一个容器，直到倒出容器为空或倒入容器满
问最少需要多少步操作，可以在其中一个容器中得到恰好C升水？"

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 解题思路与算法选择

2.1 状态空间建模

这类问题的标准解法是将每种水量组合视为图中的一个节点，操作视为边，转化为图的最短路径问题。具体而言：

状态表示：(x, y)，其中x为第一个容器的当前水量，y为第二个容器的当前水量
初始状态：(0, 0)
目标状态：任意一个容器中的水量等于C（即x==C或y==C）
合法操作：共6种基本操作：
1. 填满A：(x,y) → (A,y)
2. 填满B：(x,y) → (x,B)
3. 倒空A：(x,y) → (0,y)
4. 倒空B：(x,y) → (x,0)
5. A倒入B：转移量为min(x, B-y) → (x-transfer, y+transfer)
6. B倒入A：转移量为min(y, A-x) → (x+transfer, y-transfer)

2.2 广度优先搜索(BFS)实现

BFS是解决此类问题的最佳选择，因为它能保证找到最少操作步数。算法框架如下：

初始化队列，放入初始状态(0,0)
使用visited集合记录已访问状态
对于队列中的每个状态，尝试所有可能的操作生成新状态
如果新状态未访问过且合法，则加入队列
遇到目标状态立即返回当前步数
队列耗尽仍未找到则返回无解

关键点：必须使用BFS而非DFS，因为DFS无法保证找到的路径是最短的。同时要注意状态判重的效率问题。

3. Python实现详解

3.1 基础BFS实现

python复制from collections import deque

def water_pouring(A, B, C):
    queue = deque()
    queue.append((0, 0, 0))  # (a, b, steps)
    visited = set()
    visited.add((0, 0))
    
    while queue:
        a, b, steps = queue.popleft()
        
        # 检查是否达到目标
        if a == C or b == C:
            return steps
        
        # 生成所有可能的新状态
        next_states = []
        # 1. 填满A
        next_states.append((A, b))
        # 2. 填满B
        next_states.append((a, B))
        # 3. 倒空A
        next_states.append((0, b))
        # 4. 倒空B
        next_states.append((a, 0))
        # 5. A倒入B
        transfer = min(a, B - b)
        next_states.append((a - transfer, b + transfer))
        # 6. B倒入A
        transfer = min(b, A - a)
        next_states.append((a + transfer, b - transfer))
        
        # 处理新状态
        for state in next_states:
            if state not in visited:
                visited.add(state)
                queue.append((state[0], state[1], steps + 1))
    
    return -1  # 无解

3.2 优化与边界处理

实际竞赛中需要考虑以下优化和边界情况：

提前终止条件：如果C > max(A,B)，直接返回-1
贝祖定理检查：只有当C是A和B的最大公约数的倍数时才有解
状态压缩：对于大容量容器，可以使用更高效的状态表示方法
路径记录：如果需要输出具体操作步骤，需额外维护路径信息

优化后的实现：

python复制import math
from collections import deque

def water_pouring_optimized(A, B, C):
    # 提前检查无解情况
    if C > max(A, B) or C % math.gcd(A, B) != 0:
        return -1
    
    queue = deque([(0, 0, 0)])
    visited = set([(0, 0)])
    
    while queue:
        a, b, steps = queue.popleft()
        
        if a == C or b == C:
            return steps
        
        # 使用生成器减少内存占用
        def generate_states(a, b):
            yield (A, b)    # 填满A
            yield (a, B)    # 填满B
            yield (0, b)    # 倒空A
            yield (a, 0)    # 倒空B
            transfer = min(a, B - b)
            yield (a - transfer, b + transfer)  # A→B
            transfer = min(b, A - a)
            yield (a + transfer, b - transfer)  # B→A
        
        for new_a, new_b in generate_states(a, b):
            if (new_a, new_b) not in visited:
                visited.add((new_a, new_b))
                queue.append((new_a, new_b, steps + 1))
    
    return -1

4. C语言实现要点

对于C语言实现，需要特别注意：

数据结构选择：C中没有内置的队列和集合，需要手动实现
状态表示：可以使用结构体表示状态
哈希处理：简单的状态可以用整数编码实现快速判重

示例核心结构：

c复制#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 10000

typedef struct {
    int a;
    int b;
    int steps;
} State;

State queue[MAX_SIZE];
int front = 0, rear = 0;
int visited[MAX_SIZE][MAX_SIZE];

void enqueue(State s) {
    queue[rear++] = s;
}

State dequeue() {
    return queue[front++];
}

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

int water_pouring(int A, int B, int C) {
    if (C > (A > B ? A : B) || C % gcd(A, B) != 0) {
        return -1;
    }
    
    State initial = {0, 0, 0};
    enqueue(initial);
    visited[0][0] = 1;
    
    while (front != rear) {
        State current = dequeue();
        
        if (current.a == C || current.b == C) {
            return current.steps;
        }
        
        // 生成所有可能状态并处理...
        // 类似Python版本的逻辑，需要手动实现状态生成和判重
    }
    
    return -1;
}

5. 竞赛技巧与常见错误

5.1 时间优化技巧

双向BFS：从初始状态和目标状态同时开始搜索，可以显著减少搜索空间
数学性质利用：对于特定情况（如一个容器是另一个的倍数）可以直接计算步数
优先队列：某些变种问题可以使用优先队列优化

5.2 常见错误与调试

状态判重遗漏：忘记记录已访问状态会导致无限循环
边界条件处理不足：未考虑C=0或C等于容器容量的情况
操作生成不全：漏掉某些合法的倒水操作
整数溢出：对于大容量容器，状态表示可能超出整数范围

5.3 蓝桥杯评分要点

根据蓝桥杯评分规则，此类题目通常考察：

正确性（60%）：是否能正确处理各种测试用例
效率（30%）：算法时间空间复杂度是否最优
代码规范（10%）：变量命名、注释等是否符合规范

建议在实现后测试以下典型用例：

A=3, B=5, C=4（常规情况）
A=2, B=6, C=5（无解情况）
A=1, B=1, C=1（边界情况）
A=100, B=50, C=25（大数情况）

6. 算法扩展与变种

6.1 多容器问题

当容器数量增加到3个或更多时，基本思路不变但状态维度增加。例如三个容器的状态表示为(a,b,c)，操作种类也会相应增多。

6.2 带约束条件的变种

某些变种问题会添加额外约束，如：

限制总操作步数
某些操作有额外代价（步数加权）
只能使用特定顺序的操作

这类问题通常需要调整状态表示或使用更复杂的搜索策略（如A*算法）。

6.3 实际应用场景

倒水问题的算法思想可以应用于：

资源分配问题
工业生产中的液体调配
游戏AI中的状态空间搜索
密码学中的某些数学问题

我在实际训练中发现，这类问题的难点不在于算法本身，而在于如何准确建模和高效实现状态转移。建议初学者从2容器问题开始，逐步增加复杂度，同时注意培养严谨的边界条件检查习惯