编程之美1.3 代码实现

// Test.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include<iostream>
#include<time.h>
#include<stdlib.h>
#include<assert.h>
#include<list>
#include<math.h>
#include<algorithm>
using namespace std;
time_t t1,t2;
void Tic()
{
t1=time(NULL);
// for(int i=0;i<INT_MAX;++i);
}
void Toc()
{
   t2=time(NULL);
   std::cout<<"time:"<<(t2-t1)/3600<<"时:"<<(t2-t1)%3600/60<<"分:"<<(t2-t1)%60<<"秒"<<std::endl;
}
class CPrefixSorting
{
private:
int *m_CakeArray;/*烙饼信息数组*/
int m_nCakeCnt;/*烙饼数目*/
int m_nMaxSwap;/*最多交换次数*/

int *m_SwapArray;/*交换结果数组*/
int *m_ReverseCakeArray;/*当前的烙饼信息数组*/
int *m_ReverseCakeArraySwap;/*当前的交换结果信息*/
int m_nSearch;/*当前搜索次数信息*/

std::list<int>lInt;/*对应一个排列，达到有序的最少交换次数*/
bool isJudge;
void IntToStr(int *pCakeArray,int n,int &result)
{

result=0;
         for(int i=0;i<n;++i)
result+=pCakeArray[i]*pow(10.0,i);
          
}

void Init(int *pCakeArray,int nCakeCnt)
{

assert(pCakeArray!=NULL&&nCakeCnt>0);
m_nCakeCnt=nCakeCnt;
m_CakeArray=new int[m_nCakeCnt];
m_ReverseCakeArray=new int[m_nCakeCnt];
assert(m_CakeArray!=NULL&&m_ReverseCakeArray!=NULL);
for(int i=0;i<nCakeCnt;++i)
{
m_CakeArray[i]=pCakeArray[i];
m_ReverseCakeArray[i]=m_CakeArray[i];
}

m_nMaxSwap=UpperBound(m_nCakeCnt);

m_SwapArray=new int[m_nMaxSwap+1];
assert(m_SwapArray!=NULL);
m_ReverseCakeArraySwap=new int[m_nMaxSwap+1];



}
int UpperBound(const int n)
{
   return 2*n;
}
int LowerBound(int*pCake,const int len)
{
int temp,count1=0;
for(int i=1;i<len;++i)
{
temp=pCake[i]-pCake[i-1];
if(::abs(temp)!=1)
{
count1+=1;;

}
}
   return count1;
}
void Search(int step)
{
int i,nEstimate;
nEstimate=LowerBound(m_ReverseCakeArray,m_nCakeCnt);
m_nSearch++;
if(step+nEstimate>m_nMaxSwap)
return;
if(IsSorted(m_ReverseCakeArray,m_nCakeCnt))
{
if(step<m_nMaxSwap)
{
m_nMaxSwap=step;
// std::cout<<"SwapNum:"<<step<<": ";
for(int i=0;i<m_nMaxSwap;++i)
{

m_SwapArray[i]=m_ReverseCakeArraySwap[i];
//std::cout<<m_SwapArray[i]<<"  ";
}
//std::cout<<std::endl;
}
return;
}
/*以下代码是判断是否已经出现过当前状态*/
if(isJudge)
{
int str;
IntToStr(m_ReverseCakeArray,m_nCakeCnt,str);
list<int>::iterator ite=find(lInt.begin(),lInt.end(),str);
if(ite==lInt.end())
lInt.push_back(str);
else
return;
}
for(int i=1;i<m_nCakeCnt;++i)
{
Reverse(0,i);
m_ReverseCakeArraySwap[step]=i;
Search(step+1);
Reverse(0,i);
}


}
bool IsSorted(int *pCakeArray,int nCakeCnt)
{
for(int i=1;i<nCakeCnt;++i)
if(pCakeArray[i-1]>pCakeArray[i])
return false;
return true;
}
void Reverse(int begin,int end)
{
       assert(end>begin);
   int i,j;
   for(i=begin,j=end;i<j;i++,j--)
   {
   std::swap(m_ReverseCakeArray[i],m_ReverseCakeArray[j]);
   }
}
public:
CPrefixSorting()
{
m_nCakeCnt=m_nMaxSwap=0;isJudge=false;//默认是不使用 是否出现过当前状态 来减少搜索次数
}
~CPrefixSorting()
{
if(m_CakeArray!=NULL)
delete []m_CakeArray;
if(m_SwapArray!=NULL)
delete []m_SwapArray;
if(m_ReverseCakeArray!=NULL)
delete []m_ReverseCakeArray;
if(m_ReverseCakeArraySwap!=NULL)
delete []m_ReverseCakeArraySwap;
}
void SetJudge(bool judge)
{
this->isJudge=judge;
lInt.clear();
}
void Run(int *pCakeArray,int nCakeCnt)
{
Init(pCakeArray,nCakeCnt);
m_nSearch=0;
Search(0);
}
void OutPut()
{
for(int i=0;i<m_nMaxSwap;++i)
std::cout<<m_SwapArray[i]<<" ";
std::cout<<std::endl;
std::cout<<"m_nSearch:"<<m_nSearch<<",m_nMaxSwap:"<<m_nMaxSwap<<std::endl;
}
};
void RunAlgorithm()
{

CPrefixSorting object;
//int a[10]={3,2,1,6,5,4,9,8,7,0};
//object.Run(a,10);
int a[3]={1,3,2};
Tic();
object.Run(a,3);
object.OutPut();
Toc();
    std:cout<<"增加剪支操作，判断是否使用过当前的搜索状态！"<<std::endl;
Tic();

object.SetJudge(true);
object.Run(a,3);
object.OutPut();
Toc();

}

int _tmain(int argc, _TCHAR* argv[])
{

    RunAlgorithm();
system("pause");
return 0;
}