实现重写问题的AO*搜索

#include
#include
using namespace std;

struct NODE{
public:
	int q;                    //该结点耗散值，可被更新h（n）=nh（1）=0
	int value;                //该结点的值，或者称为序号
	void set（int k）{
		q=k;
		value=k;
		if （value==1） q=0;
	}
};

bool in（stack temp_stackNODE node）{           //查找一个结点类型的node是否在指定的堆栈里
	stack put_back;
	bool T=false;
	while（!temp_stack.empty（））{
		NODE temp=temp_stack.top（）;
		if （temp.value==node.value）{
			T=true;
			break;
		}
		temp_stack.pop（）;
		put_back.push（temp）;
	}
	while（!put_back.empty（））{
		NODE temp=put_back.top（）;
		put_back.pop（）;
		temp_stack.push（temp）;
	}
	return T;
}

NODE next（stack temp_stack）{                        //返回堆栈中第二个元素
	NODE null;
	null.set（1）;
	if（temp_stack.size（）==1） return null;
	NODE firstlast;
	first=temp_stack.top（）;
	temp_stack.pop（）;
	last=temp_stack.top（）;
	temp_stack.push（first）;
	return last;
}

int main（）{
	NODE node[7];
	stack solved;           //起始为空，存放已解决可解终结点
	stack expand;           //起始为空，存放已被扩展的结点
	stack s[7][2];          //为每种变化规则赋值一个堆栈保存
	for（int i=6;i>0;i--）{
		node[i].set（i）;
	}
	solved.push（node[1]）;                                 //node[1]作为终结点直接添加入已解结点堆栈中
	expand.push（node[6]）;                                 //node[6]作为已扩展点直接添加入已扩展结点堆栈中
	s[6][0].push（node[2]）; s[6][0].push（node[4]）;         //为每一种分解情况如6=4+2设置一个堆栈
	s[6][1].push（node[3]）; //s[6][1].push（node[3]）;
	s[4][0].push（node[1]）; s[4][0].push（node[3]）;
	s[4][1].push（node[2]）; //s[4][1].push（node[2]）;
	s[3][0].push（node[1]）; s[3][0].push（node[2]）;
	s[2][0].push（node[1]）; //s[2][0].push（node[1]）;

	int sub=6;                    //从6（根结点）开始
	bool T=false;
	while（1）{
		if （in（solvednode[6]））{                          //该问题已被解决，输出最终耗散值
			//succeed;
			cout<			//重写的新输出，很长，如下
			stack output;
			output.push（node[6]）;
			while（!output.empty（））{
				NODE temp=output.top（）;
				output.pop（）;
				if （temp.value!=1）{
					cout<					int k=0;
					sub=temp.value;