C++ NodePtr::expand方法代码示例

int
BestFirst_Astar_Check(const NodeType &start, 
	int &uniquenodes, int &expandednodes)
{
	uniquenodes = expandednodes = 0;

	// copy start state
	NodePtr<NodeType> pstart(start);

	// calculate the heuristic value for this node
	pstart->heuristic(*pstart);

	// create open priority queue
	List<NodePtr<NodeType> > openpq;
	openpq.insertByValue(pstart);
	uniquenodes++;

	// create closed set
	List<NodePtr<NodeType> > closedset;

	// start search loop
	for (NodePtr<NodeType> pnode; ! openpq.isEmpty(); )
	{
		// remove next node from priority open queue
		openpq.removeAtFront(pnode);

		// check if we have a goal node or not
		if (pnode->isGoal())
		{
			// goal node, print solution
			PrintSolution((NodeType *)pnode);
			return(OK);
		}

		// generate the children of the current node
		if (pnode->expand() != OK)
		{
			// unable to expand current node
			return(NOTOK);
		}
		if (((++expandednodes%1000) == 0) && (expandednodes > 0))
		{
			cout << expandednodes << " nodes expanded." << endl;
			cout << "current node is ... " << *pnode << endl;
		}

		// the following two lists are REQUIRED since the
		// list iterator used below does NOT allow nodes
		// to be deleted or inserted into the list while
		// the iterator is traversing the list. the solution
		// is to save the nodes that must be deleted and
		// inserted in two separate lists, and after the
		// iterator is done, then remove and add nodes to
		// pnodes children list.
		//
		// list of nodes to delete from pnode children
		List<NodePtr<NodeType> > nodesToRemove;
		nodesToRemove.clear();

		// list of nodes to add to pnode children
		List<NodePtr<NodeType> > nodesToInsert;
		nodesToInsert.clear();

		// scan children and determine if they already exist.
		ListIterator<NodePtr<NodeType> > 
			childrenIter(*pnode->getChildren());
		for ( ; !childrenIter.done(); childrenIter++)
		{
			// set up link to parent
			childrenIter()->setParent((NodeType *)pnode);

			// calculate the heuristic value
			childrenIter()->heuristic(*pstart);

			// check if node already exists
			NodePtr<NodeType> pchild(childrenIter());
			NodePtr<NodeType> popen(childrenIter());
			NodePtr<NodeType> pclosed(childrenIter());

			// check if node was already generated
			int inopen = NOMATCH;
			int inclosed = NOMATCH;
			if (( ! openpq.isEmpty()) && 
			    (inopen = openpq.retrieveByValue(popen)) == OK)
			{
				// check which path is better, the new
				// path thru pnode, or the old one
				// thru popen.
				//
				int childGvalue = pchild->getGvalue();
				int oldGvalue = popen->getGvalue();
				if (childGvalue < oldGvalue)
				{
					// reset old node parent pointer
					popen->setParent(pchild->getParent());
					popen->heuristic(*pstart);
				}

				// delete copy of node, and insert
				// old node, popen, into children
//.........这里部分代码省略.........

int
BestFirst_Astar_WOCheck(const NodeType &start, const List<NodeType> &goals, 
	int &uniquenodes, int &expandednodes)
{
	uniquenodes = expandednodes = 0;

	// copy start state
	NodePtr<NodeType> pstart(start);

	// calculate the heuristic value for this node
	pstart->heuristic(*pstart, goals);

	// create open priority queue
	List<NodePtr<NodeType> > openpq;
	openpq.insertByValue(pstart);
	uniquenodes++;

	// create closed set
	List<NodePtr<NodeType> > closedset;

	// start search loop
	for (NodePtr<NodeType> pnode; ! openpq.isEmpty(); )
	{
		// remove next node from priority open queue
		openpq.removeAtFront(pnode);

		// check if we have a goal node or not
		if (goals.isInList(*pnode))
		{
			// goal node, print solution
			PrintSolution((NodeType *)pnode);
			return(OK);
		}

		// generate the children of the current node
		if (pnode->expand() != OK)
		{
			// unable to expand current node
			return(NOTOK);
		}
		if (((++expandednodes%1000) == 0) && (expandednodes > 0))
		{
			cout << expandednodes << " nodes expanded." << endl;
			cout << "current node is ... " << *pnode << endl;
		}

		// set up links to parent and calculate the heuristic value
		ListIterator<NodePtr<NodeType> > 
			childrenIter(*pnode->getChildren());
		for ( ; !childrenIter.done(); childrenIter++)
		{
			// set up link to parent
			childrenIter()->setParent((NodeType *)pnode);

			// calculate the heuristic value
			childrenIter()->heuristic(*pstart, goals);

			// insert into open queue
			openpq.insertByValue(childrenIter());
			if (((++uniquenodes%1000) == 0) && (uniquenodes > 0))
			{
				cout << uniquenodes << " unique nodes." << endl;
			}
		}

		// store node in closed set
		closedset.insertAtFront(pnode);
	}

	// finished with error
	return(NOTOK);
}