Class HPancakeSortNode

java.lang.Object

SearchNode

HSearchNode

HPancakeSortNode

All Implemented Interfaces:

java.lang.Cloneable

public class HPancakeSortNode
extends HSearchNode

Field Summary

Fields

Modifier and Type	Field and Description
int	cost The cumulative cost of reaching this node given the sequence of previous flips, i.e.
int	lastFlip Last number of flipped pancakes (2 through length), or 0 for the root search node.
int[]	pancake Current pancake sequence consisting of a permutation of integers from 0 through length - 1.

Fields inherited from class SearchNode

depth, parent

Constructor Summary

Constructors

Constructor and Description
HPancakeSortNode(int[] pancake) Create an HPancakeSortNode that is constructed with the given pancake permutation of pancake sizes numbered {0-(length-1)}, setting the initial cost to 0.
HPancakeSortNode(int size, int numShuffleFlips) Create an HPancakeSortNode that is constructed by creating a sorted sequence of pancake sizes numbered 0 through (length-1) and then performing random reversals of pancakes ranging from 2 to length and initializing this generated root by setting lastFlipped and cost to 0.

Method Summary

Modifier and Type	Method and Description
HPancakeSortNode	clone() Return the result of a deep clone of HPancakeSortNode that has a unique pancake array copy for each cloned node.
java.util.ArrayList<SearchNode>	expand() Return a list of HPancakeSortNode children that result from a flip of 2 through (length) flips.
void	flip(int n) Flip (that is, reverse the order of) the first n pancakes, increase the node cost by n, and set lastFlip to n.
double	getG() Return the total number of pancakes flipped to reach this node from the root node.
static HPancakeSortNode	getGoalNode(int[] pancake) Given a pancake index permutation of values from 0 through the array length - 1, return an optimal goal node resulting from A* search with an admissible heuristic that is not h(n) = 0.
double	getH() Return an admissible heuristic estimate of the cost to a goal node that does not overestimate, nor is the trivial h(n) = 0 heuristic.
int	getLastFlip() Return the size of the most recently flipped stack of pancakes, or 0 in the case of the root node.
boolean	isGoal() Return whether or not the pancake values are sorted in ascending order.
static void	main(java.lang.String[] args) This method will be ignored in JUnit testing, but can serve as a place for your test code.
java.lang.String	toString() Return a single line String representation of the current node including node cost (g(n)), the last flip made, and the current pancake sequence.

Methods inherited from class HSearchNode

getF

Methods inherited from class SearchNode

childClone

Methods inherited from class java.lang.Object

equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

pancake

public int[] pancake

Current pancake sequence consisting of a permutation of integers from 0 through length - 1.

lastFlip

public int lastFlip

Last number of flipped pancakes (2 through length), or 0 for the root search node.

cost

public int cost

The cumulative cost of reaching this node given the sequence of previous flips, i.e. the total number of pancakes flipped to reach this node.

Constructor Detail

HPancakeSortNode

public HPancakeSortNode(int size,
                        int numShuffleFlips)

Create an HPancakeSortNode that is constructed by creating a sorted sequence of pancake sizes numbered 0 through (length-1) and then performing random reversals of pancakes ranging from 2 to length and initializing this generated root by setting lastFlipped and cost to 0.

Parameters:

size - number of pancakes

numShuffleFlips - number of random flips used to shuffle

HPancakeSortNode

public HPancakeSortNode(int[] pancake)

Create an HPancakeSortNode that is constructed with the given pancake permutation of pancake sizes numbered {0-(length-1)}, setting the initial cost to 0.

Parameters:

pancake - given permutation of pancake sizes numbered 0 through (length-1)

Method Detail

flip

public void flip(int n)

Flip (that is, reverse the order of) the first n pancakes, increase the node cost by n, and set lastFlip to n. This method is useful for both shuffling an initial state, and for making modifications to cloned children of nodes.

Parameters:

n - number of leading pancakes to be reversed in order

isGoal

public boolean isGoal()

Return whether or not the pancake values are sorted in ascending order.

Specified by:

isGoal in class SearchNode

Returns:

whether or not the pancake values are sorted in ascending order

expand

public java.util.ArrayList<SearchNode> expand()

Return a list of HPancakeSortNode children that result from a flip of 2 through (length) flips.

Specified by:

expand in class SearchNode

Returns:

a list of HPancakeSortNode children that result from a flip of 2 through (length) flips.

toString

public java.lang.String toString()

Return a single line String representation of the current node including node cost (g(n)), the last flip made, and the current pancake sequence.

Overrides:

toString in class java.lang.Object

Returns:

a single line String representation of the current node including node cost (g(n)), the last flip made, and the current pancake sequence

clone

public HPancakeSortNode clone()

Return the result of a deep clone of HPancakeSortNode that has a unique pancake array copy for each cloned node.

Overrides:

clone in class SearchNode

Returns:

the result of a deep clone of HPancakeSortNode that has a unique pancake array copy for each cloned node

getLastFlip

public int getLastFlip()

Return the size of the most recently flipped stack of pancakes, or 0 in the case of the root node. This number should be 0 for the root, but in the range 2 through the number of pancakes for any child.

Returns:

the size of the most recently flipped stack of pancakes, or 0 in the case of the root node

getG

public double getG()

Return the total number of pancakes flipped to reach this node from the root node.

Specified by:

getG in class HSearchNode

Returns:

the total number of pancakes flipped to reach this node from the root node

getH

public double getH()

Return an admissible heuristic estimate of the cost to a goal node that does not overestimate, nor is the trivial h(n) = 0 heuristic. Hint: Consider how one can not overestimate the number of remaining flips, and consider the minimum flip cost.

Specified by:

getH in class HSearchNode

Returns:

an admissible heuristic estimate of the cost to a goal node that does not overestimate, nor is the trivial h(n) = 0 heuristic.

getGoalNode

public static HPancakeSortNode getGoalNode(int[] pancake)

Given a pancake index permutation of values from 0 through the array length - 1, return an optimal goal node resulting from A* search with an admissible heuristic that is not h(n) = 0.

Parameters:

pancake - a pancake index permutation of values from 0 through the array length - 1

Returns:

an optimal goal node resulting from A* search with an admissible heuristic that is not h(n) = 0

main

public static void main(java.lang.String[] args)

This method will be ignored in JUnit testing, but can serve as a place for your test code.

Parameters:

args - (unused parameter)