int
BreadthFirstSearch(List<NodeType> &startstatelist,
BinaryTree_AVL<DataType> &startlist,
BinaryTree_AVL<DataType> &otherlist)
{
int status;
// track all states created
BinaryTree_AVL<String> allstates;
// create open priority queue
List<Proxy<NodeType> > openpq;
// copy list of start states
int nodedepth = 1;
ListIterator<NodeType> startstateIter(startstatelist);
for ( ; !startstateIter.done(); startstateIter++)
{
// copy start state
Proxy<NodeType> pstart(startstateIter());
// set start node depth
pstart->setDepth(nodedepth);
// insert start state into open queue
if ((status = openpq.insertAtEnd(pstart)) != OK)
{
ERRORD("insertAtFront() failed.", status, errno);
return(status);
}
}
// start search loop
for (Proxy<NodeType> pnode; ! openpq.isEmpty(); )
{
// remove next node from priority open queue
if ((status = openpq.removeAtFront(pnode)) != OK)
{
ERRORD("removeAtFront() failed.", status, errno);
return(status);
}
// set current node depth
nodedepth = pnode->getDepth();
// check if we have a goal node or not
status = pnode->isGoal(startlist, otherlist);
switch (status)
{
case OK:
break;
case NOMATCH:
case MAXDEPTHEXCEEDED:
// no clauses were generated. skip further
// processing of this node.
continue;
case VALID:
// goal node, print solution
PrintSolution(pnode);
PrintRenameVariables(pnode);
// check if more than one solutions is required
solutionsfound += 1;
statistics[SolutionsFound] += 1;
totalstatistics[TotalSolutionsFound] += 1;
if (solutionsfound >= solutionsrequired)
return(VALID);
continue;
case MAXCLAUSEEXCEEDED:
// check if any solutions were found
if (solutionsfound > 0)
return(VALID);
else
return(NOTPROVEN);
default:
// some type of error
ERRORD("isGoal() failed.", status, errno);
return(status);
}
// generate the children of the current node
if ((status = pnode->expand(startlist, otherlist)) != OK)
{
ERRORD("expand() failed.", status, errno);
return(status);
}
// set up links to parent and calculate the heuristic value
ListIterator<Proxy<NodeType> >
childrenIter(*pnode->getChildren());
for ( ; !childrenIter.done(); childrenIter++)
{
// pointer to child
Proxy<NodeType> pchild(childrenIter());
// set up link to parent
if (reporttype == ReportParent ||
reporttype == ReportBoth)
pchild->setParent(pnode);
// insert into queue
if (!bfswithchecks)
{
pchild->setDepth(nodedepth+1);
if ((status = openpq.insertAtEnd(
pchild)) != OK)
{
ERRORD("insertAtEnd() failed.",
status, errno);
return(status);
}
}
else
{
statistics[RedundantClauseTestsAttempted] += 1;
totalstatistics[TotalRedundantClauseTestsAttempted] += 1;
String newnode(pchild->getNormalizedClauses());
if (allstates.retrieve(newnode) == NOMATCH)
{
pchild->setDepth(nodedepth+1);
if ((status = openpq.insertAtEnd(
pchild)) != OK)
{
ERRORD("insertAtEnd() failed.",
status, errno);
return(status);
}
}
else
{
statistics[RedundantClausesRejected] += 1;
totalstatistics[TotalRedundantClausesRejected] += 1;
}
}
}
if (bfswithchecks)
{
if (allstates.insert(pnode->getNormalizedClauses()) != OK)
{
ERRORD("insert() failed.", status, errno);
return(status);
}
}
}
// check if any solutions were found
if (solutionsfound > 0)
return(VALID);
else
return(NOTPROVEN);
}
int
dfs(Proxy<NodeType> &pnode, int &threshold, int &next_threshold,
BinaryTree_AVL<DataType> &startlist,
BinaryTree_AVL<DataType> &otherlist)
{
int status;
// expand the current node's children
if ((status = pnode->expand(startlist, otherlist)) != OK)
{
// some type of error
ERRORD("expand() failed.", status, errno);
return(status);
}
// scan children for goal nodes
ListIterator<Proxy<NodeType> > childrenIter(*pnode->getChildren());
for ( ; !childrenIter.done(); childrenIter++)
{
// get pointer to child
Proxy<NodeType> pchild(childrenIter());
// set up link to parent
if (reporttype == ReportParent ||
reporttype == ReportBoth)
pchild->setParent(pnode);
// calculate the heuristic value
if ((status = pchild->heuristic(startlist, otherlist)) != OK)
{
ERRORD("heuristic() failed.", status, errno);
return(status);
}
// check if we have a goal node
status = pchild->isGoal(startlist, otherlist);
switch (status)
{
case OK:
break;
case NOMATCH:
case MAXDEPTHEXCEEDED:
continue;
case MAXCLAUSEEXCEEDED:
return(status);
case VALID:
// goal node, print solution
PrintSolution(pnode);
PrintRenameVariables(pnode);
return(VALID);
default:
// some type of error
ERRORD("isGoal() failed.", status, errno);
return(status);
}
// check if we continue, is threshold exceeded?
int childcost = pchild->getFvalue();
if (childcost <= threshold)
{
// continue depth-first search
status = dfs(pchild, threshold, next_threshold,
startlist, otherlist);
switch (status)
{
case OK:
case NOMATCH:
case MAXDEPTHEXCEEDED:
case NOTPROVEN:
break;
case MAXCLAUSEEXCEEDED:
return(MAXCLAUSEEXCEEDED);
case VALID:
// goal node, print solution
return(VALID);
default:
// some type of error
ERRORD("dfs() failed.", status, errno);
return(status);
}
}
else if (childcost < next_threshold)
{
next_threshold = childcost;
}
}
// goal was not not proven
return(NOTPROVEN);
}
int
DepthFirstHillClimbSearch(List<NodeType> &startstatelist,
BinaryTree_AVL<DataType> &startlist,
BinaryTree_AVL<DataType> &otherlist)
{
int status;
// track all states created
BinaryTree_AVL<String> allstates;
// create open stack for traversal
List<Proxy<NodeType> > openstack;
// keep track of current path here instead of
// using parent pointers. parent pointers cause
// cycles and reference-counted pointers cannot
// deal with cyclic data structures. they cause
// major memory leaks.
//
int nodedepth = 1;
List<Proxy<NodeType> > currentpath;
// copy list of start states
ListIterator<NodeType> startstateIter(startstatelist);
for ( ; !startstateIter.done(); startstateIter++)
{
// copy start state
Proxy<NodeType> pstart(startstateIter());
// calculate the heuristic value for this node
if ((status = pstart->heuristic(startlist, otherlist)) != OK)
{
ERRORD("heuristic() failed.", status, errno);
return(status);
}
// set start node depth
pstart->setDepth(nodedepth);
// insert start state into open queue
if ((status = openstack.insertOrdered(pstart)) != OK)
{
ERRORD("insertOrdered() failed.", status, errno);
return(status);
}
}
// children priority queue
List<Proxy<NodeType> > childpq;
// start search loop
int olddepth = nodedepth;
Proxy<NodeType> pchild;
for (Proxy<NodeType> pnode; ! openstack.isEmpty(); )
{
// remove next node from priority open queue
if ((status = openstack.removeAtFront(pnode)) != OK)
{
ERRORD("removeAtFront() failed.", status, errno);
return(status);
}
// check if we have a goal node or not
status = pnode->isGoal(startlist, otherlist);
switch (status)
{
case OK:
// update current path
if ((status = updatepath(nodedepth,
olddepth, pnode, currentpath)) != OK)
return(status);
break;
case NOMATCH:
case MAXDEPTHEXCEEDED:
// no clauses were generated. skip further
// processing of this node.
continue;
case VALID:
// update current path
if ((status = updatepath(nodedepth,
olddepth, pnode, currentpath)) != OK)
return(status);
// goal node, print solution
PrintSolution(pnode);
PrintSolution(currentpath);
PrintRenameVariables(pnode);
// check if more than one solutions is required
solutionsfound += 1;
statistics[SolutionsFound] += 1;
totalstatistics[TotalSolutionsFound] += 1;
if (solutionsfound >= solutionsrequired)
return(VALID);
continue;
case MAXCLAUSEEXCEEDED:
// check if any solutions were found
if (solutionsfound > 0)
return(VALID);
else
return(NOTPROVEN);
default:
// some type of error
ERRORD("isGoal() failed.", status, errno);
return(status);
}
// generate the children of the current node
if ((status = pnode->expand(startlist, otherlist)) != OK)
{
ERRORD("expand() failed.", status, errno);
return(status);
}
// clear children priority queue
childpq.clear();
// set up links to parent and calculate the heuristic value
ListIterator<Proxy<NodeType> >
childrenIter(*pnode->getChildren());
for ( ; !childrenIter.done(); childrenIter++)
{
// pointer to child
pchild = childrenIter();
// set up link to parent
if (reporttype == ReportParent ||
reporttype == ReportBoth)
pchild->setParent(pnode);
// calculate the heuristic value
if ((status = pchild->heuristic(
startlist, otherlist)) != OK)
{
ERRORD("heuristic() failed.", status, errno);
return(status);
}
// insert child into a priority queue to order
pchild->setDepth(nodedepth+1);
if ((status = childpq.insertOrdered(pchild)) != OK)
{
ERRORD("insertOrdered() failed.",
status, errno);
return(status);
}
}
// insert nodes into stack ordered by heuristic value
while (!childpq.isEmpty())
{
// remove next node from priority open queue
if ((status = childpq.removeAtEnd(pchild)) != OK)
{
ERRORD("removeAtEnd() failed.",
status, errno);
return(status);
}
// insert node into a stack
if (!bfswithchecks)
{
if ((status = openstack.insertAtFront(
pchild)) != OK)
{
ERRORD("insertAtFront() failed.",
status, errno);
return(status);
}
}
else
{
statistics[RedundantClauseTestsAttempted] += 1;
totalstatistics[TotalRedundantClauseTestsAttempted] += 1;
String newnode(pchild->getNormalizedClauses());
if (allstates.retrieve(newnode) == NOMATCH)
{
if ((status = openstack.insertAtFront(
pchild)) != OK)
{
ERRORD("insertAtFront() failed.",
status, errno);
return(status);
}
}
else
{
statistics[RedundantClausesRejected] += 1;
totalstatistics[TotalRedundantClausesRejected] += 1;
}
}
}
// children are now in the queue. release pointers to
// children stored in node.
//
pnode->getChildren()->clear();
if (bfswithchecks)
{
if (allstates.insert(pnode->getNormalizedClauses()) != OK)
{
ERRORD("insert() failed.", status, errno);
return(status);
}
}
}
// check if any solutions were found
if (solutionsfound > 0)
return(VALID);
else
return(NOTPROVEN);
}