示例#1
0
文件: search.cpp 项目: ombt/ombt
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);
}
示例#2
0
文件: search.cpp 项目: ombt/ombt
int
updatepath(int &nodedepth, int &olddepth, Proxy<NodeType> &pnode,
		List<Proxy<NodeType> > &currentpath)
{
	int status;

	// get new node depth
	nodedepth = pnode->getDepth();

	// update path if reporting is on
	if (reporttype != ReportStack && reporttype != ReportBoth)
		return(OK);

	// update path in stack
	if (currentpath.isEmpty())
	{
		if ((status = currentpath.insertAtFront(pnode)) != OK)
		{
			ERRORD("insertAtFront() failed.", 
				status, errno);
			return(status);
		}
		olddepth = nodedepth;
	}
	else if (nodedepth <= olddepth)
	{
		int nodestopop = olddepth - nodedepth + 1;
		for (int inode = 1; inode <= nodestopop; inode++)
		{
			Proxy<NodeType> ppathnode;
			if ((status = currentpath.removeAtFront(
				ppathnode)) != OK)
			{
				ERRORD("removeAtFront() failed.", 
					status, errno);
				return(status);
			}
		}
		if ((status = currentpath.insertAtFront(pnode)) != OK)
		{
			ERRORD("insertAtFront() failed.", 
				status, errno);
			return(status);
		}
		olddepth = nodedepth;
	}
	else if (nodedepth > olddepth)
	{
		if ((status = currentpath.insertAtFront(pnode)) != OK)
		{
			ERRORD("insertAtFront() failed.", 
				status, errno);
			return(status);
		}
		olddepth = nodedepth;
	}
	else
	{
		MustBeTrue(0);
	}

	// all done
	return(OK);
}