ninegongdlg.cpp

本人这学期写八数码作业

	"Arial"));                 // lpszFacename
	
	RECT rc;
	GetClientRect(&rc);//得到客户区大小
	up.x =rc.left+3;
	up.y =rc.top+3;
	down.x=rc.right-100;
	down.y=rc.bottom;
	xWidth=(down.x -up.x)/3;
	yHeight=(down.y-up.y)/3;
	for(int i=0;i<9;++i)
	{
		rect[i].top=up.y+i/3*yHeight;
		rect[i].left=up.x+i%3*xWidth;
		rect[i].right=rect[i].left+xWidth;
		rect[i].bottom=rect[i].top+yHeight;
	}
	return 0;
}
void CninegongDlg::DrawBackGround(CDC* dc,RECT rt,bool isHiscroll)
{
	int width,height;
	RECT rc;
	width=xWidth;
	height=yHeight;
	if(isHiscroll)
		width=2*xWidth;
	else
		height=2*yHeight;

	CDC hdcCompatible;
	hdcCompatible.CreateCompatibleDC(NULL);

	CBitmap hbmScreen;
	hbmScreen.CreateCompatibleBitmap(dc,width,height);
	
	if(!hdcCompatible.SelectObject(&hbmScreen))
	{	MessageBox("fff");return ;	}
	rc.left=1;	rc.top=1;
	rc.right=width;	rc.bottom=height;
	CBrush br;	br.CreateSolidBrush(RGB(0,0,0));
	CBrush *oldBrush=hdcCompatible.SelectObject(&br);
	CPen pen;	pen.CreatePen(PS_SOLID,2,RGB(230,0,0));
	CPen *oldPen=hdcCompatible.SelectObject(&pen);
	hdcCompatible.Rectangle(1,1,width,height);
	hdcCompatible.FillRect(&rc,&br);

	if(isHiscroll)
	{	hdcCompatible.MoveTo(width/2+1,1);hdcCompatible.LineTo(width/2+1,height);}
	else 
	{	hdcCompatible.MoveTo(1,height/2+1);hdcCompatible.LineTo(width,height/2+1);}

	dc->BitBlt(rt.left,rt.top,width,height,&hdcCompatible,width,height, SRCCOPY);
	
	dc->StretchBlt(rt.left,rt.top,width,height,&hdcCompatible,1,1,width,height, SRCCOPY);

    hdcCompatible.SelectObject(oldBrush);//还原画刷
	hdcCompatible.SelectObject(oldPen);
    br.DeleteObject();
	pen.DeleteObject();
	hdcCompatible.DeleteDC();
	hbmScreen.DeleteObject();
}
void CninegongDlg::Draw(int left,int right,bool isLeft,bool isHiscroll)
{
	CDC *dc=GetDC();
	dc->SetBkMode(TRANSPARENT);
	CFont *oldFont=dc->SelectObject(&font);
	CString str;

	std::swap(number[left],number[right]);
	
	if(isLeft)
		DrawBackGround(dc,rect[left],isHiscroll);
	else
		DrawBackGround(dc,rect[right],isHiscroll);
	dc->SetTextColor(RGB(192,192,192));

	str.Format("%d",number[left]);
	dc->DrawText(str,1,&rect[left],DT_CENTER);
	dc->SetTextColor(RGB(0,250,120));

	RECT rt;//绘画阴影字体
	rt.left=rect[left].left+1;
	rt.top=rect[left].top+1;
	rt.right=rect[left].right+1;
	rt.bottom=rect[left].bottom+1;
	str.Format("%d",number[left]);
	dc->DrawText(str,1,&rt,DT_CENTER);
	dc->SelectObject(oldFont);
	ReleaseDC(dc);
}
void CninegongDlg::Random()
{
    for (int i = 0 ; i < 9 ; i++)
        number[i] =i;
      for (int i = 1; i < 100 ; i++)
	  {	
		  

		  std::swap(number[rand()%9],number[rand()%9]);
		  srand( (unsigned)time( NULL ) );
	  }
	  int j=0;
	  for(int i=8;i>=0;--i)
		  orient[i]=j++;
	  for (int i = 0 ; i < 100; i++)
	  {	
		  
			j=rand()%9;
			srand( (unsigned)time( NULL ) );
		  std::swap(orient[rand()%9],orient[j]);
		  
	  }
      
}
bool CninegongDlg::SearchNode(const Node&  orient)
{
	closeTable.empty();
	bool expand=false;
	bool succ=false;
	int count=0;
	Node n1(number);

	std::deque<Node> dequeOpen;
	std::deque<Node>::iterator list_it;

	dequeOpen.push_back(n1);

	std::vector<Node>tempVect;
	tempVect.resize(4);
	while(count<500)
	{
		expand=false;
		if(list_it==dequeOpen.end()){ std::cerr<<" first error";break;;}
		list_it=dequeOpen.begin();
		closeTable.push_back(*list_it);

		if(*list_it==orient){ succ=true;std::cout<<"succ";std::cout<<*list_it;break;}
		NodeFactory factory(*list_it);
		while(factory.hasNext())
		{
			expand=true;
			tempVect.push_back(factory.getNextNode());
		}
		if(!expand){ std::cerr<<" result error";return 0;}
		dequeOpen.pop_front();
		for(int i=0;i<(int)tempVect.size();++i)
			dequeOpen.push_front(tempVect[i]);
		sortDeque(dequeOpen,orient);
		
		tempVect.empty();
		++count;
	}
	closeTable.pop_front();
	return succ;
}
void CninegongDlg::sortDeque(std::deque<Node> &deque,const Node& cmp)
{
	int sortElem=(int)deque.size();
	if(sortElem>0)
	{
		int min=0;
		for(int j=min+1;j<sortElem;++j)
		if(deque[min].diffence(cmp)>deque[j].diffence(cmp))min=j;

		std::swap(deque[min],deque[0]);
	}
}

HBRUSH CninegongDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
{
	HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
	if(nCtlColor==CTLCOLOR_STATIC)
	{
		pDC->SetBkMode(TRANSPARENT);
		pDC->SetTextColor(RGB(0,20,250));
	}
	return hbr;
}
void CninegongDlg::UpdateStatus()
{
	++count;
	CString str2;
	str2.Format("%d",count);
	GetDlgItem(IDC_STATIC4)->SetWindowText(str2);
}
void CninegongDlg::Start()
{
	CString str,str2;
	str.Format("%3d%3d%3d\n%3d%3d%3d\n%3d%3d%3d\n",number[0],number[1],number[2],number[3],number[4],
		number[5],number[6],number[7],number[8]);

	GetDlgItem(IDC_STATIC2)->SetWindowText(str);

	str2.Format("%3d%3d%3d\n%3d%3d%3d\n%3d%3d%3d\n",orient[0],orient[1],orient[2],orient[3],orient[4],
		orient[5],orient[6],orient[7],orient[8]);

	GetDlgItem(IDC_STATIC3)->SetWindowText(str2);
}
bool CninegongDlg::SearchOpen(const Node& orient)
{
	bool result=false;
	int count=0;
	Node n1(number);

	Node *N;
	std::vector<Node> vectOpen;
	std::vector<Node> vectClose;
	vectOpen.push_back(n1);
	bool succ=false;
	while(count<10000)
	{
		if(count==vectOpen.size()){ std::cout<<" first error";break;;}
		N=&vectOpen[count];
		vectClose.push_back(*N);
		if(*N==orient){ succ=true; break;}
		NodeFactory factory(*N);
		while(factory.hasNext())
		{
			result=true;
			vectOpen.push_back(factory.getNextNode());
		}
		if(!result){ std::cout<<" result error";break;}
		++count;
		
	}
	std::vector<Node>::iterator itor=vectClose.begin();

	int i=(int)vectClose.size()-1;
	N=&vectClose[i];	closeTable.push_front(vectClose[N->getSelf()]);
	while(N->getSelf()!=0)
	{
		closeTable.push_front(vectClose[N->getParent()]);
		N=&vectClose[N->getParent()];
	}
	closeTable.pop_front();
	return succ;
}
void sortVect(std::vector<Node> &vect,const Node& cmp)
{
	int sortElem=(int)vect.size();
		for(int i=0;i<sortElem-1;++i)
		{
			int min=i;
			for(int j=i;j<sortElem;++j)
			if(vect[min].diffence(cmp)>vect[j].diffence(cmp))min=j;

			std::swap(vect[min],vect[i]);
		}
}
void parseNode(std::deque<Node>&deque,std::vector<Node>& vect,const Node& cmp)
{
	sortVect(vect,cmp);
	int sortElem=(int)vect.size();
	if(sortElem>=2)
	{
		if(vect[0].diffence(cmp)==vect[1].diffence(cmp))
		{
			std::vector<Node>sortArray1;
			sortArray1.resize(4);
			std::vector<Node>sortArray2;
			sortArray2.resize(4);
			NodeFactory factory(vect[0]);
			
			while(factory.hasNext())
				sortArray1.push_back(factory.getNextNode());

			NodeFactory factory1(vect[1]);
			while(factory1.hasNext())
				sortArray2.push_back(factory1.getNextNode());
			
			sortVect(sortArray1,cmp);
			sortVect(sortArray2,cmp);
			if(sortArray1[0].diffence(cmp)>sortArray2[0].diffence(cmp))
				deque.push_front(vect[1]);
			else
				deque.push_front(vect[0]);
		}
		else deque.push_front(vect[0]);
	}
	else deque.push_front(vect[0]);
}
bool CninegongDlg::SearchPri(const Node& orient)
{
	closeTable.empty();
	bool result=false;
	int count=0;
	Node n1(number);

	int sortElem;
	std::deque<Node> dequeOpen;
	
	std::deque<Node>::iterator list_it;
	dequeOpen.push_back(n1);
	std::vector<Node>sortArray;
	sortArray.resize(4);
	bool succ=false;
	while(count<3000)
	{
		result=false;
		sortElem=0;
		if(list_it==dequeOpen.end()){ break;;}
		list_it=dequeOpen.begin();
		closeTable.push_back(*list_it);

		if(*list_it==orient){ succ=true;break;}
		NodeFactory factory(*list_it);
		while(factory.hasNext())
		{
			result=true;
			sortArray[sortElem++]=factory.getNextNode();
		}
		if(!result)break;
		dequeOpen.pop_front();
		parseNode(dequeOpen,sortArray,orient);
		
		sortArray.empty();
		++count;
	}
	closeTable.pop_front();
	return succ;
}

void CninegongDlg::OnStart()
{
	Random();
	Start();
	InvalidateRect(NULL,TRUE);
	count=0;
}

void CninegongDlg::OnSpead()
{
	choice=0;
	CMenu *menu=GetMenu();
	menu->CheckMenuRadioItem(ID_SPEAD,ID_CHANGE,ID_SPEAD,MF_BYCOMMAND);
	
}

void CninegongDlg::OnPriorty()
{
	choice=1;CMenu *menu=GetMenu();
	menu->CheckMenuRadioItem(ID_SPEAD,ID_CHANGE,ID_PRIORTY,MF_BYCOMMAND);
}

void CninegongDlg::OnChange()
{
	choice=2;CMenu *menu=GetMenu();
	menu->CheckMenuRadioItem(ID_SPEAD,ID_CHANGE,ID_CHANGE,MF_BYCOMMAND);
}