三個水杯

描述

給出三個水杯，大小不一，並且只有最大的水杯的水是裝滿的，其餘兩個為空杯子。三個水杯之間相互倒水，並且水杯沒有標識，只能根據給出的水杯體積來計算。現在要求你寫出一個程式，使其輸出使初始狀態到達目標狀態的最少次數。

輸入

第一行一個整數N(0<N<50)表示N組測試資料
接下來每組測試資料有兩行，第一行給出三個整數V1 V2 V3 (V1>V2>V3 V1<100 V3>0)表示三個水杯的體積。
第二行給出三個整數E1 E2 E3 （體積小於等於相應水杯體積）表示我們需要的最終狀態

輸出

每行輸出相應測試資料最少的倒水次數。如果達不到目標狀態輸出-1

樣例輸入

2
6 3 1
4 1 1
9 3 2
7 1 1

樣例輸出

3
-1

I.分析廣度優先搜尋

 

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
/**
 * 三個水杯
時間限制：1000 ms  |  記憶體限制：65535 KB
難度：4
描述
給出三個水杯，大小不一，並且只有最大的水杯的水是裝滿的，其餘兩個為空杯子。三個水杯之間相互倒水，並且水杯沒有標識，只能根據給出的水杯體積來計算。現在要求你寫出一個程式，使其輸出使初始狀態到達目標狀態的最少次數。
輸入
第一行一個整數N(0<N<50)表示N組測試資料
接下來每組測試資料有兩行，第一行給出三個整數V1 V2 V3 (V1>V2>V3 V1<100 V3>0)表示三個水杯的體積。
第二行給出三個整數E1 E2 E3 （體積小於等於相應水杯體積）表示我們需要的最終狀態
輸出
每行輸出相應測試資料最少的倒水次數。如果達不到目標狀態輸出-1
樣例輸入
2
6 3 1
4 1 1
9 3 2
7 1 1
樣例輸出
3
-1
 * @author daniel
 * @email 
 
[email protected]
 * @time 2016-5-17 上午10:20:59
 */
public class Main {
	public static int[] oldState = new int[3];
	public static int[] targetState = new int[3];
	//50*2
	public static boolean[][][] visited = new boolean[100][100][100];
	//stack棧
	public static Queue<CupNode> nodeQueue;


	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int testnum = input.nextInt();
		for (int i = 0; i < testnum; i++) {
			for (int j = 0; j < 3; j++) {
				oldState[j] = input.nextInt();
			}
			for (int j = 0; j < 3; j++) {
				targetState[j] = input.nextInt();
			}
			//全部填充false
			 
<span style="white-space:pre">	</span>/*<span style="white-space:pre">		</span>for (int j = 0; j < 100; j++)
<span style="white-space:pre">				</span>for (int k = 0; k < 100; k++)
<span style="white-space:pre">					</span>for (int l = 0; l < 100; l++)
<span style="white-space:pre">						</span>visited[j][k][l] = false;
<span style="white-space:pre">			</span>*/
<span style="white-space:pre">			</span>/**/ 
<span style="white-space:pre">			</span>for (int j = 0; j < 100; j++)
<span style="white-space:pre">				</span>for (int k = 0; k < 100; k++)
<span style="white-space:pre">	</span>                Arrays.fill(visited[j][k], false);
			 
			System.out.println(BFS());
		}
	 
	}

	public static class CupNode {
		int[] state = new int[3];
		int stepNum;
	}

	public static boolean isAchieveTarget(CupNode currentNode) {
		for (int i = 0; i < 3; i++) {
			if (currentNode.state[i] != targetState[i]) {
				return false;
			}
		}
		return true;
	}

	public static void pourWater(int destination, int source, CupNode newNode) {
		int leftWaterFiled = oldState[destination] - newNode.state[destination];
		if (newNode.state[source] >= leftWaterFiled) {
			newNode.state[destination] += leftWaterFiled;
			newNode.state[source] -= leftWaterFiled;
		} else {
			newNode.state[destination] += newNode.state[source];
			newNode.state[source] = 0;
		}
	}
/**
 * BFS
 * @author daniel
 * @time 2016-5-17 上午11:57:44
 * @return
 */
	public static int BFS() {
		nodeQueue = new LinkedList<CupNode>();
		CupNode currentNode = new CupNode();
		currentNode.state[0] = oldState[0];
		currentNode.state[1] = currentNode.state[2] = 0;
		nodeQueue.add(currentNode);
		visited[currentNode.state[0]][currentNode.state[1]][currentNode.state[2]] = true;
		while (!nodeQueue.isEmpty()) {
			currentNode = nodeQueue.poll();
			if (isAchieveTarget(currentNode)) {
				return currentNode.stepNum;
			}
			for (int i = 0; i < 3; i++) {
				for (int j = 1; j < 3; j++) {
					int k = (i + j) % 3;
					if (currentNode.state[i] != 0 && oldState[k] > currentNode.state[k]) {
						CupNode newNode = new CupNode();
						for (int l = 0; l < 3; l++) {
							newNode.state[l] = currentNode.state[l];
						}
						newNode.stepNum = currentNode.stepNum;
						pourWater(k, i, newNode);
						newNode.stepNum = currentNode.stepNum + 1;
						if (!visited[newNode.state[0]][newNode.state[1]][newNode.state[2]]) {
							nodeQueue.add(newNode);
							visited[newNode.state[0]][newNode.state[1]][newNode.state[2]] = true;
						}
					}
				}
			}
		}
		return -1;
	}
}