[JAVA][2013蓝桥杯模拟赛 JAVA本科B组][第五题：分红酒]

【题目取自CSDN-671coder】

第五题：分红酒

题目描述：

有4个红酒瓶子，它们的容量分别是：9升, 7升, 4升, 2升

开始的状态是 [9,0,0,0]，也就是说：第一个瓶子满着，其它的都空着。

允许把酒从一个瓶子倒入另一个瓶子，但只能把一个瓶子倒满或把一个瓶子倒空，不能有中间状态。这样的一次倒酒动作称为1次操作。
假设瓶子的容量和初始状态不变，对于给定的目标状态，至少需要多少次操作才能实现？
本题就是要求你编程实现最小操作次数的计算。
输入：最终状态（逗号分隔）
输出：最小操作次数（如无法实现，则输出-1）

例如：
输入：
9,0,0,0
应该输出：
0

输入：
6,0,0,3
应该输出：
-1

输入：
7,2,0,0
应该输出：
2

样例输入：

2 4 1 2

3 1 3 2
2 6 1 0

样例输出：

6
9
7

得分：

3组测试数据 正确个数*10.333 满分31

分析：

一直都在写DFS的题目，BFS写的比较少，很明显总体架构就是BFS了。

9000设定为0次操作，然后广度优先搜，将一次操作之后可能的情况再次放入queue，然后取head再次BFS

JAVA的Queue还好会自动扩容，如果是C可能就麻烦很多

另开一个Queue记录操作次数，每次插入tail的时候就将正在BFS过程中情况的操作次数+1塞入操作次数的Queue

每次同步取情况Queue和操作次数Queue

循环如果搜索到EndCondition则输出

或者完全循环直到Queue.isEmpty()成立说明无法找到对应EndCondition则输出-1表示无法找到

【写了三四个小时的程序，BFS实在不熟练，可能程序各方面不够完美。

[java]  view plain copy print ?

1. import java.io.BufferedInputStream;  
2. import java.util.ArrayDeque;  
3. import java.util.Arrays;  
4. import java.util.Queue;  
5. import java.util.Scanner;  
6.   
7. public class Main {  
8.   
9.     static int capacity[] = { 9, 7, 4, 2 };  
10.     static boolean condExisted[] = new boolean[100000];  
11.     static Queue<Integer> q = new ArrayDeque<Integer>();  
12.     static Queue<Integer> times = new ArrayDeque<Integer>();  
13.     static int startCond[] = { 9, 0, 0, 0 };  
14.     static int endCond[] = new int[4];  
15.   
16.     // change the condition array to num  
17.     public static int toNum(int cond[]) {  
18.         int num = 0;  
19.         for (int i = 3; i >= 0; i--) {  
20.             num += cond[3 - i] * Math.pow(10, i);  
21.         }  
22.         return num;  
23.     }  
24.   
25.     // change num to condition array  
26.     public static int[] toCond(int num) {  
27.         int cond[] = new int[4];  
28.         for (int i = 3; i >= 0; i--) {  
29.             cond[i] = num % 10;  
30.             num /= 10;  
31.         }  
32.         return cond;  
33.     }  
34.   
35.     // check if the condition has existed  
36.     public static boolean isExisted(int cond[]) {  
37.         if (condExisted[toNum(cond)]) {  
38.             return true;  
39.         } else {  
40.             return false;  
41.         }  
42.     }  
43.   
44.     // set the condition is existed  
45.     public static void existed(int cond[]) {  
46.         condExisted[toNum(cond)] = true;  
47.     }  
48.   
49.     public static void bfs() {  
50.         while (!q.isEmpty()) {  
51.             int cond[] = toCond(q.poll());  
52.             int t = times.poll();// times of pouring operations  
53.               
54.             if (Arrays.equals(cond, endCond)) {  
55.                 System.out.println(t);  
56.                 System.exit(0);  
57.             }  
58.             existed(cond);  
59.             int i;  
60.   
61.             for (i = 0; i < 4; i++) {  
62.                 if (cond[i] == 0) {  
63.                     continue;  
64.                 }  
65.                 for (int j = 0; j < 4; j++) {  
66.                       
67.                     // condition if we cant pour  
68.                     if (i == j || cond[i] == 0 || cond[j] == capacity[j]) {  
69.                         continue;  
70.                     }  
71.                       
72.                     // if we can pour from i to j  
73.                     int tmp[] = new int[4];  
74.                     for (int k = 0; k < 4; k++) {  
75.                         tmp[k] = cond[k];  
76.                     }  
77.                     if (cond[j] + cond[i] > capacity[j]) {  
78.                         tmp[j] = capacity[j];  
79.                         tmp[i] = cond[i] - (capacity[j] - cond[j]);  
80.                     } else {  
81.                         tmp[i] = 0;  
82.                         tmp[j] = tmp[j] + cond[i];  
83.                     }  
84.                       
85.                     // if this condition has not existed then put into the quene  
86.                     // otherwise ignore it  
87.                     if (!isExisted(tmp)) {  
88.                         existed(tmp);  
89.                         q.add(toNum(tmp));// set the next condition to the tail  
90.                         times.add(t + 1);  
91.                     }  
92.                 }  
93.             }  
94.         }  
95.     }  
96.   
97.     public static void main(String[] args) {  
98.         Scanner sc = new Scanner(new BufferedInputStream(System.in));  
99.         String tmp[] = sc.next().split(",");  
100.   
101.         int sum = 0;  
102.         for (int i = 0; i < startCond.length; i++) {  
103.             endCond[i] = Integer.valueOf(tmp[i]);  
104.             sum += endCond[i];  
105.         }  
106.         if (sum != 9) {  
107.             // impossible condition  
108.             System.out.println(-1);  
109.         } else {  
110.   
111.             // start condition of the bfs  
112.             q.add(toNum(startCond));  
113.             times.add(0);  
114.             existed(startCond);  
115.   
116.             // if we can found the end condition ,we will exit program in this function  
117.             bfs();  
118.         }  
119.         System.out.println(-1);// after check all condition we cant find endCondition  
120.     }  
121.   
122. }