Missionaries and Cannibals problem breadth first search implementation

Problem description:

Three missionaries and cannibals want to cross the river using a boat which can carry at most two people, under the constraint that, for both banks, if there are missionries present on the bank, they can't be outnumbered by
cannibals (if they were, the cannibals would eat the missionaries.) The boat cannot cross the river by itself with no people on board.

Problem solution:

This kinds of problem has many solutions. All the solustion are all about state space search. For this problem the state represent is very important. The problem's state can be represented as three element tuple (M, C, B).

–M: number of missionaries on left bank
–C: number of cannibals on left bank
–B: number of boat on left bank

The state can be a six element tuple the left bank state and right bank state, because we can deduce the right bank state by left bank state, so the three left bank element tupe is enough. The start state is (3, 3, 1) which
mean all the missionaries, cannibals and boat on the left side bank. The end state is (0, 0, 0) which means all the missionaries, cannibals and boat on the right bank. To find a path from the state space tree, we should skip or prune some invalid branches
or nodes.

When generate the successive states, some states are not allowed except the below operation to get successive states.

1.Move one cannibal across the river.
2.Move two cannibals across the river.
3.Move one missionary across the river.
4.Move two missionaries across the river.
5.Move one missionary and one cannibal.

Below is an implementation with breadth first search. Some other methods I will study later.

package hello.test;

import java.util.LinkedList;
import java.util.Queue;

public class MCB3 {
// the state queue used for search
private Queue<State> q = new LinkedList<State>();

// State class
private class State {
private int missionary;  // the number of  missionaries between 0 and 3
private int cannibals;	// the number of cannibals between 0 and 3
private int boat;	// the number of boat between 0 and 1
private State previous;	// the previous state used to record the state transfer path
private int stateLevel;	// state level used to record the height of the tree

// constructor
public State(int missionary, int cannibals, int boat, int stateLevel) {
this(missionary, cannibals, boat, null, stateLevel);
}

// constructor
public State(int missionary, int cannibals, int boat, State preState, int stateLevel) {
this.missionary = missionary;
this.cannibals = cannibals;
this.boat = boat;
this.previous = preState;
this.stateLevel = stateLevel;
}

// get the state level
public int getStateLevel() {
return this.stateLevel;
}

// is the state a valid state
public boolean isValid() {
if (missionary < 0 || missionary > 3 || cannibals < 0 || cannibals > 3) return false;
if(3 - missionary < 0 || 3 - missionary > 3 || 3 - cannibals < 0 || 3 - cannibals > 3) return false;
if(missionary > 0 && cannibals > missionary) return false;
if(3 - missionary > 0 && 3 - cannibals > 3 - missionary) return false;
return true;
}

// is two states equal to each other
public boolean isEqual(State s) {
return (s.missionary == this.missionary &&
s.cannibals == this.cannibals &&
s.boat == this.boat);
}

// is the state is the goal state
public boolean isGoal() {
State goal = new State(0, 0, 0, 99999);
return isEqual(goal);
}

// print the path
public void print() {
if(this.previous != null) {
this.previous.print();
}

String side = this.boat == 1 ? " Boat Right -> " : " <- Boat Left ";
System.out.println(this.missionary + "M/" + this.cannibals + "C " + side + "" +
(3 - this.missionary) + "M/" + (3 - this.cannibals) + "C");
}
}

// expand the successors from the current state and enqueue these successor states
private void successors(State currentState) {
for(int i = 0; i <= 2; i++) {
for(int j = 0; j <= 2; j++) {
if(i == 0 && j == 0) continue;
if(i + j > 2) break;
addStatetoQueue(currentState, i, j);
}
}
}

// generate a new state and enqueue the state
private void addStatetoQueue(State preState, int missionary, int cannibal) {
// TODO Auto-generated method stub
int side = preState.boat == 1 ? -1 : 1;
State state = new State(preState.missionary + side * missionary,
preState.cannibals + side * cannibal, 1 - preState.boat, preState,
preState.getStateLevel() + 1);
if(state.isValid())
q.add(state);
}

// solve the mcb problem with bfs
public void solve() {
//ArrayList<State> solutions = new ArrayList<State>();
boolean isFirstFound = false;	// is the state first time found
boolean isallFound = false;	// is all the states found
int optimalLevel = 0;	// the state level
int count = 0;	// solution count

State start = new State(3, 3, 1, 1);	// start state
q.add(start);

while(!q.isEmpty() && !isallFound) {
State current = q.remove();

if(current.isGoal()) {
if(isFirstFound) {
if(current.getStateLevel() <= optimalLevel) {
count++;
System.out.println("The "+ count + "th solution ===");
current.print();
System.out.println();
} else {
isallFound = true;
}
} else {
isFirstFound = true;
optimalLevel = current.getStateLevel();
count++;
System.out.println("The "+ count + "th solution, the level is " + optimalLevel + " ======" );
current.print();
System.out.println();
}

} else {
successors(current);
}
}
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MCB3 mcb = new MCB3();
mcb.solve();
}

}