迷宫问题的双向BFS

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define STARTVALUE 2012 
#define ENDVALUE 2013
#define QUEUESIZE (1024*1024)	//size of the queue for BFS
#define MAXVALUE (65535)

typedef enum{START=0,MIDDLE=1,END=2,UNREACHABLE=3}State;
typedef enum{ADD=0,MIN=1,MUL=2,DIV=3,DIV2=4,OTHER=5}Opera;
typedef struct Node{
	int value,path;
	Node * parent;
	Node * child[5];  //child[4] is for reverse search when operation is div.
	State state;
}*QuadTree;
QuadTree root,root_rev;
Node** ExistNode;
Node** ExistNode_rev;

Node * NewNode(int v, Node* n,int p, State s){
	Node *q = (Node *)malloc(sizeof(Node));
	q->value = v;
	q->parent = n;
	q->path = p;
	q->child[ADD] = q->child[MIN] = q->child[MUL] = q->child[DIV] = q->child[DIV2] = NULL;
	q->state = s;
	return q;
}

struct Queue{
	Node ** data;
	int size,header,tailer;
}NodeQueue, NodeQueue_rev;
void InitQueue(){
	NodeQueue.data = (Node**)malloc(QUEUESIZE*sizeof(Node *));
	NodeQueue_rev.data = (Node**)malloc(QUEUESIZE*sizeof(Node *));
	NodeQueue.size = NodeQueue_rev.size = QUEUESIZE;
	NodeQueue.header = NodeQueue.tailer = NodeQueue_rev.header = NodeQueue_rev.tailer = 0;
}
void EnQueue(Queue* nodequeue, Node * q){
	if((nodequeue->tailer+1)%nodequeue->size == nodequeue->header) {printf("Queue Overflow\n");return;}
	nodequeue->data[nodequeue->tailer] = q;
	nodequeue->tailer = (nodequeue->tailer+1)%nodequeue->size;
}
Node* DeQueue(Queue* nodequeue){
	if(nodequeue->header == nodequeue->tailer) return NULL;
	Node* temp = nodequeue->data[nodequeue->header];
	nodequeue->header = (nodequeue->header+1)%nodequeue->size;
	return temp;
}
void QueueClear(Queue* nodequeue){	//clear queue
	nodequeue->tailer = nodequeue->header;
}
Node* PopStack(Queue* nodequeue){	//queue also can be used as stack for outputing result
	if(nodequeue->header == nodequeue->tailer) return NULL;
	nodequeue->tailer = (nodequeue->tailer-1+nodequeue->size)%nodequeue->size;
	return nodequeue->data[nodequeue->tailer];
}

int add(int temp){return temp+7;}
int minus(int temp){return temp-5;}
int mul(int temp){return (temp<<1)+temp;}
int div(int temp){return temp>>1;}
int (*fun[5])(int) ={add,minus,mul,div,div};	//function pointer
int add_rev(int temp){return temp-7;}
int minus_rev(int temp){return temp+5;}
int mul_rev(int temp){return temp/3;}
int div_rev(int temp){return temp<<1;}
int div2_rev(int temp){return (temp<<1)+1;}			//
int (*fun_rev[5])(int) ={add_rev,minus_rev,mul_rev,div_rev,div2_rev};	//function pointer

//three-dimensional matrice: according to [State], [Path], [Next operation] return [Next State] 
State StateCompute[3][6][5]={
	{	{UNREACHABLE,UNREACHABLE,UNREACHABLE,MIDDLE,MIDDLE},
		{UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE},
		{UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE},
		{MIDDLE,UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE},
		{MIDDLE,UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE},
		{MIDDLE,UNREACHABLE,UNREACHABLE,MIDDLE,MIDDLE}
	},
	{	{UNREACHABLE,END,END,START,START},
		{START,UNREACHABLE,END,START,START},
		{START,END,UNREACHABLE,START,START},
		{START,END,END,UNREACHABLE,UNREACHABLE},
		{START,END,END,UNREACHABLE,UNREACHABLE},
		{UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE}
	},
	{	{UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE},
		{UNREACHABLE,UNREACHABLE,MIDDLE,UNREACHABLE,UNREACHABLE},
		{UNREACHABLE,MIDDLE,UNREACHABLE,UNREACHABLE,UNREACHABLE},
		{UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE},
		{UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE,UNREACHABLE},
		{UNREACHABLE,MIDDLE,MIDDLE,UNREACHABLE,UNREACHABLE}
	}
};
Node* IsExistRevTree(Node** existnode, Node* node);
void OutputResult(Node* meet){
	char opera[] = "+7-5*3/2/2";
	int i = 0;
	Node* end = meet;
	while(end->parent!=NULL){
		EnQueue(&NodeQueue,end);
		end = end->parent;
	}
	while((end=PopStack(&NodeQueue))!=NULL)
		printf("%d\t%d%c%c=%d\n",++i,end->parent->value,opera[2*end->path],opera[1+2*end->path],end->value);
	end = IsExistRevTree(ExistNode_rev,meet);
	while(end->parent!=NULL){
		printf("%d\t%d%c%c=%d\n",++i,end->value,opera[2*end->path],opera[1+2*end->path],end->parent->value);
		end = end->parent;
	}
}
void OutputResult_rev(Node* meet){
	char opera[] = "+7-5*3/2";
	int i = 0;
	Node* end = IsExistRevTree(ExistNode, meet);
	while(end->parent!=NULL){
		EnQueue(&NodeQueue,end);
		end = end->parent;
	}
	while((end=PopStack(&NodeQueue))!=NULL)
		printf("%d\t%d%c%c=%d\n",++i,end->parent->value,opera[2*end->path],opera[1+2*end->path],end->value);
	end = meet;
	while(end->parent!=NULL){
		printf("%d\t%d%c%c=%d\n",++i,end->value,opera[2*end->path],opera[1+2*end->path],end->parent->value);
		end = end->parent;
	}
}

void InitPruning(){		// allocate memory for storing existing node, using bitmap algorithm
	ExistNode = (Node**) malloc(3*4*MAXVALUE*sizeof(Node*));
	ExistNode_rev = (Node**) malloc(3*4*MAXVALUE*sizeof(Node*));
	memset(ExistNode,NULL,3*4*MAXVALUE*sizeof(Node*));
	memset(ExistNode_rev,NULL,3*4*MAXVALUE*sizeof(Node*));
}
bool Pruning(Node** existnode, Node* node){
	if(OTHER == node->path||(unsigned)node->value>MAXVALUE)	return true;
	if(existnode[node->state*4*MAXVALUE+(node->path==DIV2?DIV:node->path)*MAXVALUE+node->value]!=NULL)
		return false;
	existnode[node->state*4*MAXVALUE+(node->path==DIV2?DIV:node->path)*MAXVALUE+node->value] = node;
	return true;
}
Node* IsExistRevTree(Node** existnode, Node* node){
	if(OTHER == node->path||(unsigned)node->value>MAXVALUE)	return NULL;
	for(int i =0; i<4;i++){
		if(node->path==i||(node->path==DIV2&&i==DIV)) continue;
		if(existnode[node->state*4*MAXVALUE+i*MAXVALUE+node->value]!=NULL)
			return existnode[node->state*4*MAXVALUE+i*MAXVALUE+node->value];
	}
	return NULL;
}
void Expand(Node * node){
	for(int i = 0; i < 4; i++ ){
		if(UNREACHABLE ==StateCompute[node->state][node->path][i]) continue;
		node->child[i] = NewNode(fun[i](node->value),node,i,StateCompute[node->state][node->path][i]);
		if(Pruning(ExistNode,node->child[i])) EnQueue(&NodeQueue,node->child[i]);
		if(IsExistRevTree(ExistNode_rev,node->child[i])){
			QueueClear(&NodeQueue);
			QueueClear(&NodeQueue_rev);
			OutputResult(node->child[i]);
			break;
		}
	}
}
void Expand_rev(Node * node){
	for(int i = 0; i < 5; i++ ){
		if(UNREACHABLE ==StateCompute[node->state][node->path][i]||(MUL==i&&node->value%3!=0)||(DIV2==i&&node->value%2==1)) continue;
		node->child[i] = NewNode(fun_rev[i](node->value),node,i,StateCompute[node->state][node->path][i]);
		if(Pruning(ExistNode_rev,node->child[i])) EnQueue(&NodeQueue_rev,node->child[i]);
		if(IsExistRevTree(ExistNode,node->child[i])){
			QueueClear(&NodeQueue);
			QueueClear(&NodeQueue_rev);
			OutputResult_rev(node->child[i]);
			break;
		}
	}
}
int main(){
	Node * p = root = NewNode(STARTVALUE,NULL,OTHER,START);
	Node * q = root_rev = NewNode(ENDVALUE,NULL,OTHER,END);
	InitQueue();
	InitPruning();
	EnQueue(&NodeQueue_rev,q);
	EnQueue(&NodeQueue,p);
	while(true)
	{
		if((p=DeQueue(&NodeQueue))==NULL)break;
		Expand(p);
		if((q=DeQueue(&NodeQueue_rev))==NULL)break;
		Expand_rev(q);
	}
	printf("Completion!\n");
	return 0;
}