《编程之美》之一摞烙饼的排序

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

class CPrefixSorting
{
public:
	int * m_SwapArray;
	int * m_SwapTempArray;
	int * m_PieTempArray;
	int m_nPieCount;
	int * m_PieArray;
	int m_nMaxSwapCount;

public:
	CPrefixSorting()
	{
	}

	virtual ~CPrefixSorting()
	{
	}

public:
	void OutPut()
	{
		for (int i = 0; i < m_nMaxSwapCount; i++)
		{
			printf("%d\n", m_SwapArray[i]);
		}
	}

	/*遍历搜寻所有解法*/
	bool Search(int nStep)
	{
		/*剪枝:如果比最普通的解法还要差劲，干脆舍弃*/  
		int nMinTimes = LowerBound(m_PieTempArray, m_nPieCount);
		if (nStep + nMinTimes > m_nMaxSwapCount)
		{
			return false;
		}

		if (IsSorted())
		{
			/*如果找到一个更优解法，则保存这个更优的解法*/
			if (nStep < m_nMaxSwapCount)
			{
				m_nMaxSwapCount = nStep;
				for (int i = 0; i < m_nMaxSwapCount; i++)
				{
					m_SwapArray[i] = m_SwapTempArray[i];
				}
			}
			return true;
		}

		/*颠倒此次烙饼后，遍历接下来全部可能的颠倒情况*/
		for (int i = 1; i < m_nPieCount; i++)
		{
			Reverse(0, i);
			m_SwapTempArray[nStep] = i;
			Search(nStep + 1);
			Reverse(0, i);
		}
	}

	bool IsSorted()
	{
		for (int i = 0; i < m_nPieCount - 1; i++)
		{
			if (m_PieTempArray[i] > m_PieTempArray[i + 1])
			{
				return false;
			}
		}
		return true;
	}

	void Init(int* pPieArray, int nPieCount)
	{
		assert(NULL != pPieArray);
		assert(0 < nPieCount);

		m_PieArray = new int[nPieCount];
		assert(NULL != m_PieArray);
		m_PieTempArray = new int[nPieCount];
		assert(NULL != m_PieTempArray);
		m_nPieCount = nPieCount;

		for (int i = 0; i < nPieCount; i++)
		{
			m_PieArray[i] = pPieArray[i];
			m_PieTempArray[i] = pPieArray[i];
		}

		m_nMaxSwapCount = UpperBound(nPieCount);
		m_SwapArray = new int[m_nMaxSwapCount];
		assert(NULL != m_SwapArray);
		m_SwapTempArray = new int[m_nMaxSwapCount];
		assert(NULL != m_SwapTempArray);
	}

	void Reverse(int nBegin, int nEnd)
	{
		assert(nBegin < nEnd);
		int i, j, t;
		for (i = nBegin, j = nEnd; i < j; i++, j--)
		{
			t = m_PieTempArray[i];
			m_PieTempArray[i] = m_PieTempArray[j];
			m_PieTempArray[j] = t;
		}
	}

	void Run(int* pPieArray, int nPieCount)
	{
		Init(pPieArray, nPieCount);
		Search(0);
		OutPut();
	}

	int UpperBound(int nPieCount)
	{
		return (nPieCount - 1) * 2;
	}

	int LowerBound(int* pPieArray, int nPieCount)
	{
		int ret = 0, t;
		for (int i = 0; i < m_nPieCount - 1; i++)
		{
			t = pPieArray[i] - pPieArray[i+1];
			if (t == 1 || t == -1)
			{
				continue;
			}
			ret++;
		}
		return ret;
	}
};

int main()
{
	CPrefixSorting stSort;
	int pPieArray[10] = {3,4,0,1,2,6,5,8,7,9};
	stSort.Run(pPieArray, 10);
	system("pause");
	return 0;
}