编程之美1.3-翻烙饼问题

问题：给定一组随机数字，使其从大到小排序。

要求：只能对数组做一种操作——翻转Arr[0]至Arr[n]，其中n为大于0小于ArrLength的整数

解题思路：搜索树算法、递归遍历+减枝

详解：

1.将该数组构建为一颗树，假设该数组为4,2,1,3：

2.目标为如何找到序列为1,2,3,4、深度最小的子节点。

代码：

#include "stdafx.h";
class CakeSort
{
private:
	int* m_CakeArray;		//初始烙饼数组
	int m_CakeCount;		//烙饼数量
	int m_MaxSwap;			//交换上界
	int m_SwapTimes;		//已交换的次数
	int* m_SwapArray;		//交换信息
	int* m_ReverseCake;		//执行交换后的烙饼数组
	int* m_SwapReverseCake;	//执行交换后的烙饼数组的交换信息
public:
	void Init(int* pCakeArray,int count);
	void Run(int* pCakeArray,int count);
	int UpperBound(int count);
	int LowerBound(int* pArray,int count);
	void Search(int step);
	bool IsSort(int* pArray,int count);
	void Reverse(int begin,int end);
};
void CakeSort::Init(int* pCakeArray,int count)
{
	m_CakeCount = count;
	m_CakeArray = new int[count];
	for(int i = 0 ; i < count ; i++)
		m_CakeArray[i] = pCakeArray[i];
	m_ReverseCake = new int[count];
	for(int i = 0 ; i < count ; i++)
		m_ReverseCake[i] = m_CakeArray[i];
	m_MaxSwap = UpperBound(count);
	m_SwapTimes = 0;
	m_SwapArray = new int[m_MaxSwap];
	m_SwapReverseCake = new int[m_MaxSwap];
}
int CakeSort::UpperBound(int count)
{
	return 2*(count - 1<span style="font-family: Arial, Helvetica, sans-serif;">);</span>
}
int CakeSort::LowerBound(int* pArray,int count)
{
	int ret = 0 ;
	int t;
	for(int i = 1 ; i < count ; i++)
	{
		t = pArray[i] - pArray[i-1];
		if((t != 1) && ( t!= -1))
			ret++;
	}
	return ret;
}
void CakeSort::Run(int* pArray,int count)
{
	Init(pArray,count);

	Search(0);

	for (int i = 0; i < m_MaxSwap; i++)  
		printf("%d\n", m_SwapArray[i]);  

	printf("Search Times : %d\n", m_SwapTimes);  
	printf("Total Swap times = %d\n", m_MaxSwap);  
}
void CakeSort::Reverse(int begin , int end)
{
	int i,j,temp;
	for(i = begin , j = end ; i < j ; i++ , j--)
	{
		temp = m_ReverseCake[i];
		m_ReverseCake[i] = m_ReverseCake[j];
		m_ReverseCake[j] = temp;
	}
}
bool CakeSort::IsSort(int* pArray,int count)
{
	for(int i = 1 ; i < count ; ++i)
	{
		if(pArray[i] < pArray[i-1])
			return false;
	}
	return true;
}
void CakeSort::Search(int step)
{
	m_SwapTimes++;
	int Est = LowerBound(m_ReverseCake,m_CakeCount);
	if(Est + step >= m_MaxSwap)
		return;
	if(IsSort(m_ReverseCake,m_CakeCount))
	{
		if(step <= m_MaxSwap)
		{
			m_MaxSwap = step;
			for(int i = 0 ; i < m_MaxSwap ; i ++)
			{
				m_SwapArray[i] = m_SwapReverseCake[i];
			}
		}
		return;
	}
	for(int i = 1 ; i < m_CakeCount ; i++)
	{
		Reverse(0,i);
		m_SwapReverseCake[step] = i;
		Search(step+1);
		Reverse(0,i);
	}
}
int main()
{
	int a[] = {3, 2, 1, 6, 5, 4, 9, 8, 7, 0};  
	CakeSort s;
	s.Run(a,10);
	return 0;  
}

PS:参考链接---http://blog.csdn.net/justpub/article/details/2301191