倒水问题BFS CS精英挑战营

本文探讨了倒水问题的算法解决策略,分析了六种基本操作并对比了暴力枚举、动态规划与最优算法的效率。介绍了如何通过优化操作减少冗余步骤,最终实现O(nm)的时间复杂度。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

倒水问题

在这里插入图片描述

问题分析
操作分类:本质上是六种操作。
如果采用暴力枚举的方法,O(6^t) (t<=4 可以用搜索算法)
采用动态规划算法。 与记忆化搜索类似。通过搜索算法去优化。 只要A杯水u中和B杯水v中的量是相同的,并且操作数为i,dp[i][u][v],那么就可以认为是相同的状态。dp[i+1][x][y] 来表示下一次可以到达的水量x,y。 若为零则表示不能到达。若为一,则表示能到达。O(nmt)—>该法可以通过前十个测试点
最优算法:考虑操作中存在空操作步骤,因此可以优化第一步操作。复杂度O(nm)。也就是下面所列的算法。

//#include <bits/stdc++.h>
#include <stdio.h>
#include <utility>
#include <math.h>
#include <algorithm>
#include <string.h>
using namespace std;

// ================= 代码实现开始 =================

typedef pair<int, int> pii;
#define fi first
#define se second

const int N=2003;

//mind:mind[i][j] 表示从初始状态到达状态(i,j)需要的最少步数
//q:用数组模拟队列
//qh:队头下标
//qt:队尾下标

int mind[N][N];
pii q[N*N];
int qh,qt;

//倒水函数,表示状态p经过第k中策略倒水后的状态
//p:初始状态
//k:策略(在下面进行详细阐述)
//n,m:两杯子容量
//返回值:最终状态

pii to(pii p, int k, int n, int m){
    if(k == 0) //倒空杯子一
        return pii(0, p.se);
    else if(k==1) //倒空杯子二
        return pii(p.fi, 0);
    else if(k==2) //倒满杯子一
        return pii(n, p.se);
    else if(k==3) //倒满杯子二
        return pii(p.fi, m);
    else if(k==4) //将杯子二的水向杯子一倒
        return (n-p.fi < p.se) ? pii(n,p.fi+p.se-n): pii(p.fi+p.se,0); //写法二:pii( min(p.fi+p.se,n), max(0,p.fi+p.se-n) ) 
    else if(k==5) //将杯子一的水向杯子二倒
        return (m-p.se < p.fi) ? pii(p.fi+p.se-m,m): pii(0,p.fi+p.se); //写法二:pii( max(0,p.fi+p.se-m), min(p.fi+p.se,m) ) 
    else
        return p;
}

// 计算答案的函数
// n, m, t, d:意义均与题目描述一致
// 返回值:即为答案
int getAnswer(int n, int m, int t, int d) {
    //初始化,清空队列,将mind所有位置为 -1 表示未访问
    memset(mind,-1,sizeof(mind));
    qh = qt = 0;
    q[++qt] = pii(0,0); //初始化两个水杯容量,均为空。
    mind[0][0] = 0;

    // 进行BFS
    while(qh<qt){
        pii u = q[++qh]; //取出队头元素
        if(mind[u.fi][u.se]==t)
            break;//如果已经进行了t步,那么没必要继续搜索了,退出循环即可
        for(int k=0; k<6; ++k){     //枚举6种策略
            pii v = to(u,k,n,m);
            if( mind[v.fi][v.se]!=-1 ) //判断目标状态是否曾经到达过
                continue;
            q[++qt] = v; //加入队列
//            mind[v.fi][v.se] = qh; //记录mind的倒水次数
            mind[v.fi][v.se] = mind[u.fi][u.se]+1;
        }
    }

    int ans = d;
    for(int i = 0; i<=n; ++i)
        for(int j=0; j<=m; ++j)
            if(mind[i][j] != -1)
                ans = min(ans, abs(i+j-d) );
    return ans;
}

// ================= 代码实现结束 =================

int main() {
    int n, m, t, d;
    scanf("%d%d%d%d", &n, &m, &t, &d);
    int ans = getAnswer(n, m, t, d);
    printf("%d\n", ans);
    return 0;
}

<think>嗯,用户想用C++的BFS算法来解决倒水问题倒水问题应该就是经典的罐子倒水问题吧,比如有三个罐子,容量不同,通过倒水得到特定容量的水。首先,我需要回忆一下BFS的基本结构。BFS是广度优先搜索,用队列来实现,逐层探索可能的节点,直到找到解决方案。这样的话,每个状态都是一个节点,节点之间通过不同倒水操作连接。 接下来,我得确定如何表示罐子的状态。假设有两个罐子,容量分别是A和B,当前水量分别是a和b,那么状态可以用一个pair或者结构体来保存(a, b)。这样的话,每次操作可以有几种可能性:倒满一个罐子、倒空一个罐子、将一个罐子的水倒入另一个直到倒满或者倒空。这些操作会产生新的状态,需要将这些状态加入队列中。 然后,我需要考虑如何避免重复访问已经处理过的状态。可以用一个二维数组或者哈希表来记录已经访问过的状态,比如visited[A+1][B+1],因为每个罐子的水量不会超过其容量。 然后,BFS的队列初始化的时候应该是初始状态,比如两个罐子都是空的,或者根据问题具体情况来定。例如,题目可能是要得到某个罐子中有特定容量的水,比如其中一个罐子有C升水。这时候,每次从队列取出一个状态时,都要检查是否满足条件,如果满足就返回当前的步数或者路径。 不过用户提到的是倒水问题,可能是指经典的水壶问题。比如,给定两个罐子的容量,如何通过倒水得到恰好某个容量的水。这时候,可能的操作包括: 1. 倒满一个罐子。 2. 倒空一个罐子。 3. 将水从一个罐子倒入另一个,直到倒出罐子空或者倒入罐子满。 所以,每个状态转换需要生成所有可能的操作后的新状态,并加入队列中。 接下来,我需要考虑如何用C++代码实现这个逻辑。首先定义状态结构体或者用pair<int, int>,然后队列存储这些状态。同时维护一个访问数组来记录是否已经处理过该状态。 举个例子,假设罐子的容量是x和y,目标容量是z。初始状态是(0,0)。然后,每次从队列取出一个状态,生成所有可能的下一步状态,比如: - 倒满第一个罐子:(x, b) - 倒满第二个罐子:(a, y) - 倒空第一个罐子:(0, b) - 倒空第二个罐子:(a, 0) - 将第一个罐子的水倒入第二个罐子,直到第二个满或者第一个空。这时候,转移后的水量需要计算。比如,倒入后的第二个罐子的水量是min(b + a, y),而第一个罐子的剩余水量是a - (y - b) 如果倒不满,否则0。或者,更准确的是,倒入量是min(a, y - b),所以新的状态是(a -倒入量, b +倒入量)。 - 同样,将第二个罐子的水倒入第一个罐子。 这样,每个状态可以生成最多6种可能的新状态。不过需要注意,比如倒满或倒空操作可能生成与原状态相同的状态,这时候需要跳过,避免重复。 然后,BFS每次处理一个节点,记录步数,当达到目标状态时,返回当前步数。如果队列空了还没找到,说明无解。 代码的大体结构应该是这样的: struct State { int a; int b; int steps; }; 然后队列里保存这个结构体。初始状态是(0,0),steps为0。每次处理队列中的一个节点,检查是否满足条件(比如a == z或者 b == z或者 a + b == z,视具体问题而定),如果满足则返回steps。否则,生成所有可能的下一步状态,并检查是否已经被访问过,如果没有则加入队列,并标记为已访问。 需要注意的是,如果罐子数量不是两个而是更多,比如三个,那么状态结构会更复杂,但用户的问题可能是指两个罐子的情况。 可能用户的问题是要解决特定的倒水问题,比如给定两个罐子的容量,如何得到某个目标容量。所以,代码需要根据这个逻辑来写。 另外,在BFS中,每个状态的steps需要正确记录,确保每次操作增加一步。 现在,我需要将这些思路整理成C++代码。例如: #include <iostream> #include <queue> #include <set> using namespace std; struct State { int jugA; int jugB; int steps; }; int bfs(int capacityA, int capacityB, int target) { queue<State> q; set<pair<int, int>> visited; q.push({0, 0, 0}); visited.insert({0, 0}); while (!q.empty()) { State current = q.front(); q.pop(); if (current.jugA == target || current.jugB == target || current.jugA + current.jugB == target) { return current.steps; } // 生成所有可能的状态 vector<State> nextStates; // 倒满A nextStates.push_back({capacityA, current.jugB, current.steps + 1}); // 倒满B nextStates.push_back({current.jugA, capacityB, current.steps + 1}); // 倒空A nextStates.push_back({0, current.jugB, current.steps + 1}); // 倒空B nextStates.push_back({current.jugA, 0, current.steps + 1}); // A倒到B int pour = min(current.jugA, capacityB - current.jugB); nextStates.push_back({current.jugA - pour, current.jugB + pour, current.steps + 1}); // B倒到A pour = min(current.jugB, capacityA - current.jugA); nextStates.push_back({current.jugA + pour, current.jugB - pour, current.steps + 1}); for (const auto& state : nextStates) { pair<int, int> key = {state.jugA, state.jugB}; if (visited.find(key) == visited.end()) { visited.insert(key); q.push(state); } } } return -1; // 无解 } int main() { int A = 5, B = 3, target = 4; int result = bfs(A, B, target); if (result != -1) { cout << "最少需要 " << result << " 步" << endl; } else { cout << "无解" << endl; } return 0; } 不过可能还需要测试,比如当罐子容量为5和3,目标是4的时候,是否正确返回步骤数。例如,可能的步骤是: 1. 填满5升罐子,倒入3升,剩下2。 2. 倒空3,将5中的2倒入3。 3. 填满5,倒入3,此时3中有2,倒入后3满,5剩下4。 这样需要6步?或者可能更少? 不过代码的逻辑是否正确呢?可能需要注意状态转换是否正确。比如,在倒水的时候,计算倒入的量是否正确。 此外,是否需要在每次操作后检查是否达到目标?比如,可能在中间步骤就满足了目标,例如当倒满其中一个罐子时刚好等于目标。 另外,访问过的状态需要用pair来记录,确保不会重复处理同样的状态。 这样,用户的问题应该可以通过这个BFS算法解决。不过需要根据具体的问题要求调整目标判断条件。比如,有些问题可能要求其中一个罐子正好是目标量,或者总共有目标量。 总结来说,BFS适用于这类状态转换问题,因为可以找到最少步骤的解。需要注意的是状态的正确生成和避免重复访问。</think>### C++ BFS算法解决倒水问题 倒水问题要求通过两个水壶的操作得到特定容量的水。以下是基于BFS的解决方案: #### **1. 状态表示与操作** 用结构体`JugsState`记录当前状态: ```cpp struct JugsState { int jugA; // 当前A壶水量 int jugB; // 当前B壶水量 int steps; // 已用步数 }; ``` **六种可能操作**: 1. 倒满A壶:$(a, b) \rightarrow (A_{max}, b)$ 2. 倒满B壶:$(a, b) \rightarrow (a, B_{max})$ 3. 倒空A壶:$(a, b) \rightarrow (0, b)$ 4. 倒空B壶:$(a, b) \rightarrow (a, 0)$ 5. A倒入B:$a_{\text{新}} = \max(0, a - (B_{max} - b))$,$b_{\text{新}} = \min(B_{max}, b + a)$ 6. B倒入A:$b_{\text{新}} = \max(0, b - (A_{max} - a))$,$a_{\text{新}} = \min(A_{max}, a + b)$ #### **2. BFS实现模板** ```cpp #include <iostream> #include <queue> #include <set> using namespace std; struct JugsState { int jugA, jugB, steps; }; int water_jug_bfs(int capacityA, int capacityB, int target) { queue<JugsState> q; set<pair<int, int>> visited; q.push({0, 0, 0}); visited.insert({0, 0}); while (!q.empty()) { JugsState current = q.front(); q.pop(); // 终止条件:任一壶或总水量等于目标 if (current.jugA == target || current.jugB == target || current.jugA + current.jugB == target) { return current.steps; } // 生成所有操作后的状态 vector<JugsState> next_states = { {capacityA, current.jugB, current.steps + 1}, // 倒满A {current.jugA, capacityB, current.steps + 1}, // 倒满B {0, current.jugB, current.steps + 1}, // 倒空A {current.jugA, 0, current.steps + 1}, // 倒空B {max(0, current.jugA - (capacityB - current.jugB)), min(capacityB, current.jugB + current.jugA), current.steps + 1}, // A→B {min(capacityA, current.jugA + current.jugB), max(0, current.jugB - (capacityA - current.jugA)), current.steps + 1} // B→A }; // 检查并加入队列 for (const auto& state : next_states) { pair<int, int> key(state.jugA, state.jugB); if (!visited.count(key)) { visited.insert(key); q.push(state); } } } return -1; // 无解 } ``` #### **3. 示例调用** ```cpp int main() { int steps = water_jug_bfs(5, 3, 4); if (steps != -1) cout << "最少步数: " << steps << endl; else cout << "无解" << endl; return 0; } ``` #### **4. 性能与优化** - **时间复杂度**:最坏情况为$O(A \times B)$,其中$A$、$B$为壶的容量[^2]。 - **空间优化**:使用哈希集合`unordered_set`替代`set`可提升速度[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值