狼羊过河问题
package guohe;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
/**
* 狼羊过河问题
* @author tiger
* @date 2011年1月27日。
*
* 这里是用面向对象的编程方式，有定义了狼和羊两个类。
* 但其实程序里并没有用到它们的行为，该问题只是关心它们的数目而已！
* 所以其实可以直接就定义四个变量来存储两岸的狼数和羊数，然后在遍历
* 递归的同时增减这四个数字即可。
*
*/
public class Guohe {
//左岸的狼数和羊数
private List<Actor> leftLangs = new LinkedList<Actor>();
private List<Actor> leftYangs = new LinkedList<Actor>();
//右岸的狼数和羊数
private List<Actor> rightLangs = new LinkedList<Actor>();
private List<Actor> rightYangs = new LinkedList<Actor>();
//存储所有成功过河的方案
private List winSteps = new ArrayList();
public Guohe() {
init();
}
/**
* 刷新重置盘面为初始情况
*/
private void init() {
leftLangs.clear();
leftYangs.clear();
rightLangs.clear();
rightYangs.clear();
for (int i = 0; i < 3; i++) {
leftLangs.add(new Lang());
leftYangs.add(new Yang());
}
//这两个状态需要初始放进去。
states.add("3,3,0,0,1");
states.add("3,3,0,0,2");
//方向设为初始向对岸的方向
fangxiang = TYPE_FANGXIANG_GO;
}
//到对岸：go , 回来：come
private static int TYPE_FANGXIANG_GO = 1;
private static int TYPE_FANGXIANG_COME = 2;
//船行方向
private int fangxiang = TYPE_FANGXIANG_GO;
/**
* 保存盘面的状态
*
* 保存的是有5个数字的字符串，这5个数字代表的意义依次是：
* 左岸狼数、左岸羊数、右岸狼数、右岸羊数、当前船行方向。
*
* 状态的保存非常重要，把所有递归遍历遇到的状态都保存在这里，
* 当后面的某次遍历所遇到的盘面已经有在states里存在的话，说明该
* 盘面已经被处理过，则可以直接跳过。
*
* 保存下已经处理过的盘面，这样的设计可以防止出现死循环导致内存泄露。
*/
private List states = new ArrayList();
/**
* 针对当前船行方向，根据当前盘面情况，即两岸的狼数和羊数
* 得到可以上船的狼数和羊数。 该方法中会把盘面状态保存入states.
* @param fangxiang
* @return
*/
private List<int[]> getChuanMember(int fangxiang)
{
List<int[]> rtnlist = new LinkedList<int[]>();
String key = "";
List alangs, ayangs, blangs, byangs;
if(fangxiang == TYPE_FANGXIANG_GO)
{
alangs = leftLangs;
ayangs = leftYangs;
blangs = rightLangs;
byangs = rightYangs;
}else{
alangs = rightLangs;
ayangs = rightYangs;
blangs = leftLangs;
byangs = leftYangs;
}
//判断 1,0 .(1狼0羊)
if(alangs.size() >= 1)
{
if((alangs.size() - 1 <= ayangs.size() || ayangs.size() == 0) && (blangs.size() + 1 <= byangs.size() || byangs.size() == 0))
{
if(fangxiang == TYPE_FANGXIANG_GO)
{
key = (alangs.size() - 1) + "," + ayangs.size() + "," + (blangs.size() + 1) + "," + byangs.size() + "," + TYPE_FANGXIANG_GO;
}else{
key = (blangs.size() + 1) + "," + byangs.size() + "," + (alangs.size() - 1) + "," + ayangs.size() + "," + TYPE_FANGXIANG_COME;
}
if(!states.contains(key))
{
rtnlist.add(new int[]{1, 0});
states.add(key);
}
}
}
//判断 2,0 .(2狼0羊)
if(alangs.size() >= 2)
{
if((alangs.size() - 2 <= ayangs.size() || ayangs.size() == 0) && (blangs.size() + 2 <= byangs.size() || byangs.size() == 0))
{
if(fangxiang == TYPE_FANGXIANG_GO)
{
key = (alangs.size() - 2) + "," + ayangs.size() + "," + (blangs.size() + 2) + "," + byangs.size() + "," + TYPE_FANGXIANG_GO;
}else{
key = (blangs.size() + 2) + "," + byangs.size() + "," + (alangs.size() - 2) + "," + ayangs.size() + "," + TYPE_FANGXIANG_COME;
}
if(!states.contains(key))
{
rtnlist.add(new int[]{2, 0});
states.add(key);
}
}
}
//判断0,1 .(0狼1羊)
if(ayangs.size() >= 1)
{
if((alangs.size() <= ayangs.size() - 1 || ayangs.size() - 1 == 0) && (blangs.size() <= byangs.size() + 1 || byangs.size() + 1 == 0))
{
if(fangxiang == TYPE_FANGXIANG_GO)
{
key = alangs.size() + "," + (ayangs.size() - 1) + "," + blangs.size() + "," + (byangs.size() + 1) + "," + TYPE_FANGXIANG_GO;
}else{
key = blangs.size() + "," + (byangs.size() + 1) + "," + alangs.size() + "," + (ayangs.size() - 1) + "," + TYPE_FANGXIANG_COME;
}
if(!states.contains(key))
{
rtnlist.add(new int[]{0, 1});
states.add(key);
}
}
}
//判断0,2 .(0狼2羊)
if(ayangs.size() >= 2)
{
if((alangs.size() <= ayangs.size() - 2 || ayangs.size() - 2 == 0) && (blangs.size() <= byangs.size() + 2 || byangs.size() + 2 == 0))
{
if(fangxiang == TYPE_FANGXIANG_GO)
{
key = alangs.size() + "," + (ayangs.size() - 2) + "," + blangs.size() + "," + (byangs.size() + 2) + "," + TYPE_FANGXIANG_GO;
}else{
key = blangs.size() + "," + (byangs.size() + 2) + "," + alangs.size() + "," + (ayangs.size() - 2) + "," + TYPE_FANGXIANG_COME;
}
if(!states.contains(key))
{
rtnlist.add(new int[]{0, 2});
states.add(key);
}
}
}
//判断1,1 .(1狼1羊)
if(alangs.size() >= 1 && ayangs.size() >= 1)
{
if((alangs.size() - 1 <= ayangs.size() - 1 || ayangs.size() - 1 == 0) && (blangs.size() + 1 <= byangs.size() + 1 || byangs.size() + 1 == 0))
{
if(fangxiang == TYPE_FANGXIANG_GO)
{
key = (alangs.size() - 1) + "," + (ayangs.size() - 1) + "," + (blangs.size() + 1) + "," + (byangs.size() + 1) + "," + TYPE_FANGXIANG_GO;
}else{
key = (blangs.size() + 1) + "," + (byangs.size() + 1) + "," + (alangs.size() - 1) + "," + (ayangs.size() - 1) + "," + TYPE_FANGXIANG_COME;
}
if(!states.contains(key))
{
rtnlist.add(new int[]{1, 1});
states.add(key);
}
}
}
return rtnlist;
}
/**
* 用来存储当前遍历的方案步骤
*
* 存储的是大小为3的数字数组。各元素的意义依次是：
* 船行方向、船上狼数、船上羊数
*
*/
private List<int[]> temp = new ArrayList<int[]>();
/**
* 递归方法，不断深度遍历
*/
private void digui()
{
//得到当前盘面下，可以上船的狼数和羊数
List list = this.getChuanMember(fangxiang);
//如果找不到可乘船的狼羊，则说明当前的盘面无法走向成功，则退出。
if(list.isEmpty())
{
//重置为初始盘面情况
init();
//清空之前的步骤存储
temp.clear();
return;
}
for (int i = 0; i < list.size(); i++) {
int[] element = (int[]) list.get(i);
if(fangxiang == TYPE_FANGXIANG_GO)
{
//修改两岸的狼数
if(element[0] == 1)
{
Actor a = this.leftLangs.remove(0);
this.rightLangs.add(a);
}
else if(element[0] == 2)
{
Actor a = this.leftLangs.remove(0);
this.rightLangs.add(a);
a = this.leftLangs.remove(0);
this.rightLangs.add(a);
}
//修改两岸的羊数
if(element[1] == 1)
{
Actor a = this.leftYangs.remove(0);
this.rightYangs.add(a);
}
else if(element[1] == 2)
{
Actor a = this.leftYangs.remove(0);
this.rightYangs.add(a);
a = this.leftYangs.remove(0);
this.rightYangs.add(a);
}
//存储步骤
temp.add(new int[]{fangxiang, element[0], element[1]});
//判断是否完成，如果完成，将完成步骤加入完成方案的列表里
if(this.success())
{
//打印成功方案
System.out.println("方案：(共" + temp.size() + "步)");
for (int j = 0; j < temp.size(); j++) {
int[] a = (int[]) temp.get(j);
System.out.println("第" + (j + 1) + "步, " + (a[0] == 1 ? "前进" : "后退") + "---> 狼" + a[1] + ",羊" + a[2]);
}
winSteps.add(temp);
//重置盘面为初始情况
init();
//清空之前的步骤存储
temp.clear();
return; //这里是return而非continue，是因为既然已经成功了,而当前是最后一步，那么后面的循环必然不能成功。--->不大肯定。
}
fangxiang = TYPE_FANGXIANG_COME;
digui();
}
else if(fangxiang == TYPE_FANGXIANG_COME)
{
//修改两岸的狼数
if(element[0] == 1)
{
Actor a = this.rightLangs.remove(0);
this.leftLangs.add(a);
}
else if(element[0] == 2)
{
Actor a = this.rightLangs.remove(0);
this.leftLangs.add(a);
a = this.rightLangs.remove(0);
this.leftLangs.add(a);
}
//修改两岸的羊数
if(element[1] == 1)
{
Actor a = this.rightYangs.remove(0);
this.leftYangs.add(a);
}
else if(element[1] == 2){
Actor a = this.rightYangs.remove(0);
this.leftYangs.add(a);
a = this.rightYangs.remove(0);
this.leftYangs.add(a);
}
//存储步骤
temp.add(new int[]{fangxiang, element[0], element[1]});
//调换方向
fangxiang = TYPE_FANGXIANG_GO;
//递归处理现在的盘面
digui();
}
}
}
private boolean success()
{
return this.leftLangs.isEmpty() && this.leftYangs.isEmpty() && this.rightLangs.size() == 3 && this.rightYangs.size() == 3;
}
public static final int TYPE_LANG = 1;
public static final int TYPE_YANG = 2;
class Actor {
public int type = 0;
public boolean isLang()
{
return type == TYPE_LANG;
}
public boolean isYang()
{
return type == TYPE_YANG;
}
}
//狼
class Lang extends Actor{
public Lang() {
type = TYPE_LANG;
}
}
//羊
class Yang extends Actor{
public Yang() {
type = TYPE_YANG;
}
}
public static void main(String[] args) {
new Guohe().digui();
}
}
打印结果如下：
方案：(共11步)
第1步, 前进---> 狼2,羊0
第2步, 后退---> 狼1,羊0
第3步, 前进---> 狼2,羊0
第4步, 后退---> 狼1,羊0
第5步, 前进---> 狼0,羊2
第6步, 后退---> 狼1,羊1
第7步, 前进---> 狼0,羊2
第8步, 后退---> 狼1,羊0
第9步, 前进---> 狼2,羊0
第10步, 后退---> 狼1,羊0
第11步, 前进---> 狼2,羊0
