牛客题解 | water

合集 - 牛客笔试大厂真题题解1(90)

1.牛客题解 | 5-血型遗传检测03-032.牛客题解 | 61-递归和动态规划-汉诺塔II03-033.牛客题解 | Anniversary03-034.牛客题解 | BST判定03-035.牛客题解 | CCNumber03-036.牛客题解 | CIDR去重03-037.牛客题解 | DNA序列03-038.牛客题解 | D塔203-039.牛客题解 | Fibonacci数列03-0310.牛客题解 | K 的倍数03-0311.牛客题解 | Kolakoski 序列03-0312.牛客题解 | LRU Cache03-0313.牛客题解 | LUCKY STRING03-0314.牛客题解 | N-GCD03-0315.牛客题解 | Numeric Keypad03-0316.牛客题解 | Shopee的办公室（二）03-0317.牛客题解 | Spring Outing03-0318.牛客题解 | UTF-8 编码验证03-0319.牛客题解 | Unix路径简化03-0320.牛客题解 | bit count03-0321.牛客题解 | bit位数03-0322.牛客题解 | filename extension03-0323.牛客题解 | geohash编码03-0324.牛客题解 | ipv4地址白名单03-0325.牛客题解 | ipv4地址白名单_103-0326.牛客题解 | k倍多重正整数集合03-0327.牛客题解 | n个数里出现次数大于等于n除以2的数03-0328.牛客题解 | n个数里最小的k个03-03

29.牛客题解 | water03-03

30.牛客题解 | xor03-0331.牛客题解 | ん...红茶？03-0332.牛客题解 | 一封奇怪的信03-0333.牛客题解 | 一组带数字编号的球，其中有两个编号只出现了一次，把它们找出来03-0334.牛客题解 | 万万没想到之抓捕孔连顺03-0335.牛客题解 | 万万没想到之聪明的编辑03-0336.牛客题解 | 上台阶03-0337.牛客题解 | 上高楼03-0338.牛客题解 | 下厨房03-0339.牛客题解 | 不想出差的HR03-0340.牛客题解 | 不要二03-0341.牛客题解 | 丢失的三个数03-0342.牛客题解 | 两两配对差值最小03-0343.牛客题解 | 两个子串03-0344.牛客题解 | 两个整数二进制位不同个数03-0345.牛客题解 | 两种排序方法03-0346.牛客题解 | 中位数03-0347.牛客题解 | 中缀表达式转后缀表达式03-0348.牛客题解 | 丰收03-0349.牛客题解 | 串的模式匹配03-0350.牛客题解 | 之字形打印矩阵03-0351.牛客题解 | 乔乔的包03-0352.牛客题解 | 乘坐公交03-0353.牛客题解 | 乘方取模03-0354.牛客题解 | 买房03-0355.牛客题解 | 买橘子03-0356.牛客题解 | 买苹果03-0357.牛客题解 | 买面包03-0358.牛客题解 | 争吵03-0359.牛客题解 | 二分图判定03-0360.牛客题解 | 二分图判定_103-0361.牛客题解 | 二分查找03-0362.牛客题解 | 二叉搜索树判定03-0363.牛客题解 | 二叉树的序列化03-0364.牛客题解 | 二维数组打印03-0365.牛客题解 | 二进制中有多少个103-0366.牛客题解 | 交叉线03-0367.牛客题解 | 交换查询03-0368.牛客题解 | 交错01串03-0369.牛客题解 | 交错序列03-0370.牛客题解 | 代价03-0371.牛客题解 | 任务调度03-0372.牛客题解 | 优雅的点03-0373.牛客题解 | 会话列表03-0374.牛客题解 | 会话列表_103-0375.牛客题解 | 伪正则表达式03-0376.牛客题解 | 俄罗斯方块03-0377.牛客题解 | 保卫方案03-0378.牛客题解 | 保留最大的数03-0379.牛客题解 | 信用卡推荐客户列表03-0380.牛客题解 | 倒水03-0381.牛客题解 | 倒着输出整数03-0382.牛客题解 | 倒置字符串03-0383.牛客题解 | 公交车03-0384.牛客题解 | 公平划分03-0385.牛客题解 | 公约数03-0386.牛客题解 | 六一儿童节03-0387.牛客题解 | 共享单车03-0388.牛客题解 | 关灯游戏03-0389.牛客题解 | 冒泡排序03-0390.牛客题解 | 写一段程序判断IP字符串是否属于内网IP03-03

收起

题目

题目链接

解题思路

这是一道经典的倒水问题，需要通过BFS搜索来找到从初始状态到目标状态的最短路径。主要思路如下：

1. 使用四维布尔数组 $mem[64][64][64][64]$ 记录状态是否访问过
2. 使用 tuple<int,int,int,int> 表示四个杯子的状态，简化状态传递
3. 使用BFS搜索所有可能的状态转移，每次可以:
   • 将任意杯子装满水
   • 将任意杯子倒空
   • 将一个杯子的水倒入另一个杯子
4. 特殊情况处理：如果初始容量全为0且不等于目标状态，直接返回-1

---

代码

#include<bits/stdc++.h>
using namespace std;

bool mem[64][64][64][64] = {false};

bool equal(int s[4], int T[4]){
    return (s[0]==T[0])&&(s[1]==T[1])&&(s[2]==T[2])&&(s[3]==T[3]);
}

int bfs(int S[4], int T[4]){
    queue<tuple<int,int,int,int>> q;
    auto x = make_tuple(0,0,0,0);
    q.push(x);
    mem[0][0][0][0] = true;
    int step = 0, cap[4]={0};
    
    while(!q.empty()){
        int size = q.size();
        while(size--){
            tie(cap[0],cap[1],cap[2],cap[3]) = q.front(); q.pop();
            if(equal(cap, T)){
                return step;
            }
            
            for(int i=0; i<3; ++i){
                switch(i){
                    case 0: // 将某个杯子倒满
                        for(int j=0, tmp=0; j<4; ++j){
                            tmp = cap[j];
                            cap[j] = S[j];
                            x = make_tuple(cap[0], cap[1], cap[2], cap[3]);
                            if(!mem[cap[0]][cap[1]][cap[2]][cap[3]]){
                                mem[cap[0]][cap[1]][cap[2]][cap[3]]=true;
                                q.push(x);
                            }
                            cap[j] = tmp;
                        }
                        break;
                    case 1: // 将某个杯子倒空
                        for(int j=0, tmp=0; j<4; ++j){
                            tmp = cap[j];
                            cap[j] = 0;
                            x = make_tuple(cap[0], cap[1], cap[2], cap[3]);
                            if(!mem[cap[0]][cap[1]][cap[2]][cap[3]]){
                                mem[cap[0]][cap[1]][cap[2]][cap[3]]=true;
                                q.push(x);
                            }
                            cap[j] = tmp;
                        }
                        break;
                    case 2: // 将杯子j倒向杯子z
                        for(int j=0; j<4; ++j){
                            int tmp1,tmp2,need;
                            for(int z=0; z<4; ++z){
                                if(j==z) continue;
                                tmp1=cap[j], tmp2=cap[z];
                                need = min(cap[j], S[z]-cap[z]);
                                cap[j] -= need;
                                cap[z] += need;
                                x = make_tuple(cap[0], cap[1], cap[2], cap[3]);
                                if(!mem[cap[0]][cap[1]][cap[2]][cap[3]]){
                                    mem[cap[0]][cap[1]][cap[2]][cap[3]]=true;
                                    q.push(x);
                                }
                                cap[j]=tmp1, cap[z]=tmp2;
                            }
                        }
                }
            }
        }
        ++step;
    }
    return -1;
}

int main(){
    int S[4]={0}, T[4]={0};
    cin>> S[0] >> S[1] >> S[2] >> S[3];
    cin>> T[0] >> T[1] >> T[2] >> T[3];
    
    // 特殊情况处理
    if(S[0]==0 && S[1]==0 && S[2]==0 && S[3]==0 && !equal(S,T)){
        cout<< -1 << endl;
    }else{
        int ret = bfs(S, T);
        cout<< ret << endl;
    }
    return 0;
}

import java.util.*;

public class Main {
    static boolean[][][][] mem = new boolean[64][64][64][64];
    
    static boolean equal(int[] s, int[] t) {
        return s[0] == t[0] && s[1] == t[1] && s[2] == t[2] && s[3] == t[3];
    }
    
    static int bfs(int[] S, int[] T) {
        Queue<int[]> q = new LinkedList<>();
        q.offer(new int[]{0,0,0,0});
        mem[0][0][0][0] = true;
        int step = 0;
        
        while(!q.isEmpty()) {
            int size = q.size();
            while(size-- > 0) {
                int[] cap = q.poll();
                if(equal(cap, T)) {
                    return step;
                }
                
                for(int i = 0; i < 3; i++) {
                    switch(i) {
                        case 0: // 将某个杯子倒满
                            for(int j = 0; j < 4; j++) {
                                int tmp = cap[j];
                                cap[j] = S[j];
                                if(!mem[cap[0]][cap[1]][cap[2]][cap[3]]) {
                                    mem[cap[0]][cap[1]][cap[2]][cap[3]] = true;
                                    q.offer(cap.clone());
                                }
                                cap[j] = tmp;
                            }
                            break;
                        case 1: // 将某个杯子倒空
                            for(int j = 0; j < 4; j++) {
                                int tmp = cap[j];
                                cap[j] = 0;
                                if(!mem[cap[0]][cap[1]][cap[2]][cap[3]]) {
                                    mem[cap[0]][cap[1]][cap[2]][cap[3]] = true;
                                    q.offer(cap.clone());
                                }
                                cap[j] = tmp;
                            }
                            break;
                        case 2: // 将杯子j倒向杯子z
                            for(int j = 0; j < 4; j++) {
                                for(int z = 0; z < 4; z++) {
                                    if(j == z) continue;
                                    int tmp1 = cap[j], tmp2 = cap[z];
                                    int need = Math.min(cap[j], S[z]-cap[z]);
                                    cap[j] -= need;
                                    cap[z] += need;
                                    if(!mem[cap[0]][cap[1]][cap[2]][cap[3]]) {
                                        mem[cap[0]][cap[1]][cap[2]][cap[3]] = true;
                                        q.offer(cap.clone());
                                    }
                                    cap[j] = tmp1;
                                    cap[z] = tmp2;
                                }
                            }
                    }
                }
            }
            step++;
        }
        return -1;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] S = new int[4];
        int[] T = new int[4];
        
        for(int i = 0; i < 4; i++) S[i] = sc.nextInt();
        for(int i = 0; i < 4; i++) T[i] = sc.nextInt();
        
        if(S[0] == 0 && S[1] == 0 && S[2] == 0 && S[3] == 0 && !equal(S,T)) {
            System.out.println(-1);
        } else {
            System.out.println(bfs(S, T));
        }
    }
}

from collections import deque

def equal(s, t):
    return s[0] == t[0] and s[1] == t[1] and s[2] == t[2] and s[3] == t[3]

def bfs(S, T):
    mem = [[[[ False for _ in range(64)] for _ in range(64)] for _ in range(64)] for _ in range(64)]
    q = deque([(0,0,0,0)])
    mem[0][0][0][0] = True
    step = 0
    
    while q:
        size = len(q)
        for _ in range(size):
            cap = list(q.popleft())
            if equal(cap, T):
                return step
                
            for i in range(3):
                if i == 0:  # 将某个杯子倒满
                    for j in range(4):
                        tmp = cap[j]
                        cap[j] = S[j]
                        if not mem[cap[0]][cap[1]][cap[2]][cap[3]]:
                            mem[cap[0]][cap[1]][cap[2]][cap[3]] = True
                            q.append(tuple(cap))
                        cap[j] = tmp
                        
                elif i == 1:  # 将某个杯子倒空
                    for j in range(4):
                        tmp = cap[j]
                        cap[j] = 0
                        if not mem[cap[0]][cap[1]][cap[2]][cap[3]]:
                            mem[cap[0]][cap[1]][cap[2]][cap[3]] = True
                            q.append(tuple(cap))
                        cap[j] = tmp
                        
                else:  # 将杯子j倒向杯子z
                    for j in range(4):
                        for z in range(4):
                            if j == z:
                                continue
                            tmp1, tmp2 = cap[j], cap[z]
                            need = min(cap[j], S[z]-cap[z])
                            cap[j] -= need
                            cap[z] += need
                            if not mem[cap[0]][cap[1]][cap[2]][cap[3]]:
                                mem[cap[0]][cap[1]][cap[2]][cap[3]] = True
                                q.append(tuple(cap))
                            cap[j], cap[z] = tmp1, tmp2
        step += 1
    return -1

if __name__ == "__main__":
    S = list(map(int, input().split()))
    T = list(map(int, input().split()))
    
    if S == [0,0,0,0] and not equal(S,T):
        print(-1)
    else:
        print(bfs(S, T))

---

算法及复杂度分析

优化要点：

1. 使用四维布尔数组替代哈希表，大幅提升访问效率
2. 使用tuple简化状态表示和传递
3. 使用switch-case结构清晰地划分三种操作
4. 提前处理特殊情况（全0初始状态）

复杂度分析：

• 时间复杂度：$\mathcal{O}(V+E)$，其中 $V$ 是状态数（最大 $64^4$），$E$ 是状态转移数
• 空间复杂度：$\mathcal{O}(64^4)$，使用固定大小的四维数组