在一些面试算法或智力题中，时不时会遇到容器倒水的问题，例如，有三个容器，分别是10升，7升，4升，7升和4升的容器装满了水，10升容器是空的，如果将容器a中的水倒入容器b时，必须使得a中的水全部倒完，或者b被倒满，问有没有一种倒水序列，使得7升容器或4升容器中只有2升的水。
这个问题怎么会跟图论的深度优先搜索联系起来呢。如果我们把三个容器的水量和容量状态当作一个点，例如初始时刻[10(empty:10, water:0), 7(empty:0, water:7), 4(empty:0, water: 4)] 对应一个点A，进行一次倒水操作，例如将7升容器的水倒入10升容器中后，容器容量状态为［10(empty:3, water:7), 7(empty:7, water:0), 4(empty:0, water:4)] 则对应一个点B，这两个点之间就有一条有向边 A->B. 因此该问题的处理方法就是查找从初始点A开始，进行深度优先搜索，看是否有一条路径，使得从点A, 可达到点C，点C代表中7升容器或4升容器装有两升的水。
在DSF遍历中，需要处理一个问题，那就是遍历中访问一个已经被访问的节点，即遇到环或回路的时候，要停止继续搜索。对应于该问题，也存在对应的回路情形，例如将7升的水倒入10升的容器，接着又将10升容器中的水倒回7升容器，这就形成一个回路，如果程序中不处理这种情况，那就回出现死循环。
接下来我们看看代码设计，首先用一个类来表示容器：
public class Container {
public int water;
public int empty;
public Container() {
water = 0;
empty = 0;
}
public Container(Container otherContainer) {
water = otherContainer.water;
empty = otherContainer.empty;
}
@Override
public boolean equals(Object otherContainer) {
if (this.water == ((Container)otherContainer).water && this.empty == ((Container)otherContainer).empty) {
return true;
}
return false;
}
}public class Vertice {
private Container[] containers = new Container[3];
public Vertice(Container[] containers) {
for (int i = 0; i < 3; i++) {
this.containers[i] = new Container(containers[i]);
}
}
@Override
public boolean equals(Object obj ) {
if (!(obj instanceof Vertice)) {
return false;
}
Vertice otherContainers = (Vertice)obj;
if (containers.length != otherContainers.getContainers().length) {
return false;
}
else {
for (int i = 0; i < containers.length; i++) {
if (!containers[i].equals(otherContainers.getContainers()[i])) {
return false;
}
}
}
return true;
}
public Container[] getContainers() {
return containers;
}
}接下来，我们再看看程序的逻辑代码：所以的主逻辑代码都通过类 DSFPollWater 来实现，先给出代码，然后我再逐步分析：
<pre name="code" class="java">import java.util.Stack;
public class DSFPollWater {
private Container[] containers = new Container[3];
private Stack<Vertice> containerStack = new Stack<Vertice>();
private boolean stackPrinted = false;
public DSFPollWater() {
initContainers();
}
private void initContainers() {
for (int i = 0; i < 3; i++) {
containers[i] = new Container();
}
containers[0].empty = 10;
containers[0].water = 0;
containers[1].empty = 0;
containers[1].water = 7;
containers[2].empty = 0;
containers[2].water = 4;
}
public void dsfPollingWater() {
if (containerStateExisted()) {
return;
}
for (int i = 0; i < containers.length; i++) {
for (int j = 0; j < containers.length; j++) {
if (j != i) {
saveContainerState();
boolean bPollResult = pollWater(containers[i], containers[j]);
if (isSuccessed() && stackPrinted == false) {
System.out.println("--ok--");
printStack();
return;
}
if (bPollResult) {
dsfPollingWater();
}
restoreContainerState();
}
}
}
}
private void printStack() {
for (int i = 0; i < containerStack.size(); i++) {
Vertice consArr = containerStack.get(i);
Container[] cons = consArr.getContainers();
System.out.print("(");
for (int j = 0; j < cons.length; j++) {
System.out.print(cons[j].empty + cons[j].water + "[empty:" + cons[j].empty + ", water:" + cons[j].water + "]" );
if (j < cons.length - 1) {
System.out.print(",");
}
}
System.out.print(")");
if (i < containerStack.size() - 1) {
System.out.print("->");
}
System.out.print("\n");
}
stackPrinted = true;
}
private void saveContainerState() {
Container[] backupContainers = new Container[]{containers[0], containers[1], containers[2]};
Vertice containerArr = new Vertice(backupContainers);
containerStack.push(containerArr);
}
private void restoreContainerState() {
if (containerStack.empty() == false) {
containers = containerStack.pop().getContainers();
}
}
public boolean isSuccessed() {
for (int i = 1; i < containers.length; i++) {
if (containers[i].water == 2) {<p class="p1"> saveContainerState();</p> return true;
}
}
return false;
}
private boolean pollWater(Container from, Container to) {
if (to.empty == 0) {
return false;
}
int volumn = from.water >= to.empty ? to.empty : from.water;
from.water -= volumn;
from.empty += volumn;
to.water += volumn;
to.empty -= volumn;
return true;
}
private boolean containerStateExisted() {
Vertice containerArr = new Vertice(containers);
if (containerStack.contains(containerArr)) {
return true;
}
return false;
}
public static void main(String[] args) {
DSFPollWater dsfPollWater = new DSFPollWater();
dsfPollWater.dsfPollingWater();
}
}
首先，通过initContainers 来初始化三个容器的状态， dsfPollingWater 是进行深度优先便利的主函数，在函数开始，调用containerStateExisted 来判断当前容器状态是否已经存在，也相当于遍历时是否遇到了已经遍历过的点，举个例子， 初始状态是：[10(empty:10, water:0), 7(empty:0, water:7), 4(empty:0, water: 4)]，接下来，将7升容器中的水全部倒入10升容器，那么状态转换为［10(empty:3, water:7), 7(empty:7, water:0), 4(empty:0, water:4)]，如果接下来做的是将10升容器中的水倒入7升容器，那么初始状态又出现了，这就意味着我们进入了环回路，如果不处理这种情况的话，程序会陷入死循环，containerStateExisted 函数就是用于判断这种情况，如果出现回路，递归要立马返回，以便开始新的搜索。接下来的两个for 循环是为了模拟容器倒水情形，三个容器，倒入的方法有：容器1倒入容器2，容器1倒入容器3，容器2 倒入容器1.....,总共有9种倒法，两个for循环就是执行这9种倒水情形。
进入循环，先执行saveContainerState(), 由于执行倒水动作后，容器的存水状况会发生改变，因此在执行倒水前，会先将容器的当前状态保存起来，对应于图论，当我们进行深度优先遍历时，如果遇到了环路，或者当前路径已经遍历结束，就必须要从当前节点返回其父节点，saveContainerState() 把当前的容器状态存入栈中，以便恢复后进行新的遍历。
接下来，我们将容器i 中的水倒入容器j中(通过调用pollWater，然后判断一下，倒完水后，是否达到成功状态(isSuccessed)，如果某个容器中含有2升水，那么堆栈中就保留了倒水过程中的一系列的容器状态，通过printStack 把它们打印出来就可以得知倒水过程。pollWater 如果返回true, 表明从容器i倒水到容器j 是成功的, 如果容器i中没有水，那么倒水就不会成功，pollWater 就会返回false, 如果倒水成功，我们递归调用dsfPollingWater 进行下一轮的倒水尝试，其也对应于深度优先搜索。
containerStateExisted 用于判断当前容器的状态是否已经存在过，如果存在，表明搜索进入了环路，必须返回，不然就是死循环，由于所有遍历过的容器状态都保存在堆栈中，因此只要判断堆栈中有没有于当前状态相同的节点就可以了。
运行上面的程序，可以获得以下结果：
--ok--
(10[empty:10, water:0],7[empty:0, water:7],4[empty:0, water:4])->
(10[empty:3, water:7],7[empty:7, water:0],4[empty:0, water:4])->
(10[empty:0, water:10],7[empty:7, water:0],4[empty:3, water:1])->
(10[empty:7, water:3],7[empty:0, water:7],4[empty:3, water:1])->
(10[empty:7, water:3],7[empty:3, water:4],4[empty:0, water:4])->
(10[empty:3, water:7],7[empty:3, water:4],4[empty:4, water:0])->
(10[empty:6, water:4],7[empty:0, water:7],4[empty:4, water:0])->
(10[empty:0, water:10],7[empty:6, water:1],4[empty:4, water:0])->
(10[empty:4, water:6],7[empty:6, water:1],4[empty:0, water:4])->
(10[empty:4, water:6],7[empty:2, water:5],4[empty:4, water:0])->
(10[empty:8, water:2],7[empty:2, water:5],4[empty:0, water:4])->
(10[empty:8, water:2],7[empty:0, water:7],4[empty:2, water:2])
也就是说，通过上面所标示的十二次倒水操作，我们可以从给定的初始状态实现,达到7升或4升容器装有2升水的结果，从程序运行结果看，4升容器中装有2升水。
3463
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
