目錄

今天先來個好玩點的，呃，確切說是好吃的點的問題。哈哈，就是如標題表明的烙餅排序。程式猿果然思維跟普通人就不一樣，連吃個餅都想的這麼多。問題描述是這樣的：把一摞餅按照大小次序擺好，要求是小的在上面，大的在下面，只能通過翻轉一摞餅進行排序，就像用鏟子插入某個位置，把這個位置之上的所有餅進行翻轉。那假設有N塊大小不一的烙餅，最少要翻轉幾次才能達到最終有序排列呢？

翻轉演示圖

與傳統排序不同的是，不能一張張抽出來，然後插入進去；也不能任意交換兩塊餅。說明基本的排序演算法都不太好用。是不是有點意思呢？想當年比爾·蓋茨也研究過這個問題~

目前這個問題的答案只有一個範圍，沒有確切的值，完成排序需要的最少次數在(15/14)N與(18/11)N之間。2011年的時候這個問題被定義為NP-Hard。什麼是NP-Hard？NP（Non-Deterministic）官方定義是非確定性多項式。而非確定性是指，可用一定數量的運算去解決多項式時間內可解決的問題。例如，著名的推銷員旅行問題（Travel Saleman Problem or TSP）：假設一個推銷員需要從香港出發，經過廣州，北京，上海，…，等 n 個城市，最後返回香港。任意兩個城市之間都有飛機直達，但票價不等。假設公司只給報銷C元錢，問是否存在一個行程安排，使得他能遍歷所有城市，而且總的路費小於C？推銷員旅行問題顯然是NP的。因為如果你任意給出一個行程安排，可以很容易算出旅行總開銷。但是，要想知道一條總路費小於C的行程是否存在，在最壞情況下，必須檢查所有可能的旅行安排！這將是個天文數字。

好了介紹性的東西說的差不多了，下面主要講一下怎麼個排法~

由於每次操作都是針對最上面的餅，如果最底層的餅已經排好序，然後就只需要處理上面的N-1個餅了。

翻轉圖

首先，經過兩次翻轉，最大的餅已經在最下面了。接著次大的餅也需要兩次翻轉，最後剩兩張餅的時候只需要1次就可以，所以總的至少翻轉次數為2（n-1）-1即2n-3。

當然這是這個問題解的一種上限，非最優。

那麼下限呢？這裡也只說一種簡單的優化，非最佳。每一次翻轉最多使得一個烙餅與大小跟它相鄰的烙餅排到一起。如果當前狀態N個烙餅中，有M對相鄰的烙餅它們不相鄰，那麼至少需要M次才能排好。

下面稍微介紹下優化方法及演算法的實現。

假如這堆烙餅中有好幾個不同的部分相對有序，就可以先把小一些的烙餅翻轉使其有序。這樣就會減少翻轉次數。可以考慮每次翻轉的時候，把兩個本來應該相鄰的烙餅儘可能換到一起。這樣，當所有的烙餅都換到一起之後。實際上就完成了排序。這樣的話就會想到使用動態規劃或者遞迴的方法來實現。可以從不同的翻轉策略開始，遞迴所有可能性。這樣，肯定能找到最優解。

程式碼如下：

#include <stdio.h>
/************************************************************************/
/* 烙餅排序實現——By Sin_Geek 2014.04.12                               */
/************************************************************************/
class CPancakeSorting
{
public:
	CPancakeSorting()
	{
		m_nCakeCnt = 0;
		m_nMaxSwap = 0;
	}
	
	//計算烙餅翻轉資訊,pCakeArray 儲存烙餅索引陣列，nCakeCnt烙餅個數
	void Run(int* pCakeArray, int nCakeCnt)
	{
		Init(pCakeArray, nCakeCnt);
		m_nSearch = 0;
		Search(0);
	}

	//輸出烙餅具體翻轉的次數
	void Output()
	{
		for (int i = 0; i < m_nMaxSwap; i++)
		{
			printf("%d", m_arrSwap[i]);
		}

		printf("\nSearch Times : %d\n", m_nSearch);
		printf("Total Swap times = %d\n", m_nMaxSwap);
	}

private:
	//初始化陣列資訊，pCakeArray 儲存烙餅索引陣列，nCakeCnt烙餅個數
	void Init(int* pCakeArray, int nCakeCnt)
	{
		m_nCakeCnt = nCakeCnt;

        //初始化
		m_CakeArray = new int[m_nCakeCnt];

		for (int i = 0; i < m_nCakeCnt; i++)
		{
			m_CakeArray[i] = pCakeArray[i];
		}

		//設定最多交換次數資訊
		m_nMaxSwap = UpBound(m_nCakeCnt);

		//初始化交換結果陣列
		m_SwapArray = new int[m_nMaxSwap];

		//初始化中間交換結果資訊
		m_ReverseCakeArray = new int[m_nCakeCnt];
		for (i = 0; i < m_nCakeCnt; i++)
		{
			m_ReverseCakeArray[i] = m_CakeArray[i];
		}
		m_ReverseCakeArraySwap = new int[m_nMaxSwap];
	}

	//尋找當前翻轉的上界
	int UpBound(int nCakeCnt)
	{
		return nCakeCnt*2 - 3;
	}

	//尋找當前翻轉的下界
	int LowerBound(int* pCakeArray, int nCakeCnt)
	{
		int t,ret = 0;

		//根據當前陣列的排序資訊情況判斷最少需要交換多少次
		for (int i = 1; i < nCakeCnt; i++)
		{
			//判斷位置相鄰的兩個烙餅是否為尺寸排序上相鄰的
			t =  pCakeArray[i] - pCakeArray[i-1];
			if ((t == 1) || (t == -1))
			{
			}
			else
			{
				ret++;
			}
		}
		return ret;
	}

	//排序的主函式
	void Search(int step)
	{
		int i,nEstimate;
		m_nSearch++;

		//估算這次搜素所需的最小交換次數
		nEstimate = LowerBound(m_ReverseCakeArray, m_nCakeCnt);
		if (step + nEstimate > m_nMaxSwap) 
		return;

		//如果已經排好序，輸出結果
		if (IsSorted(m_ReverseCakeArray, m_nCakeCnt)) 
		{
			if (step < m_nMaxSwap) 
			{
				m_nMaxSwap = step;
				for (i = 0; i < m_nMaxSwap; i++)
					m_arrSwap[i] = m_ReverseCakeArraySwap[i];
			}
			return;
		}

		//遞迴翻轉
		for (i = 1; i < m_nCakeCnt; i++)
		{
			Revert(0,i);
			m_ReverseCakeArraySwap[step] = i;
			Search(step + 1);
			Revert(0,i);
		}

	}


	bool IsSorted(int* pCakeArray, int nCakeCnt)
	{
		for (int i = 1; i < m_nCakeCnt; i++)
		{
			if(pCakeArray[i-1] > pCakeArray[i])
				return false;
		}
		return true;
	}

	//翻轉烙餅
	void Revert(int nBegin, int nEnd)
	{
		//ASSERT(nEnd > nBegin);
		int i,j,t;

		for (i = nBegin, j = nEnd; i < j; i++,j--)
		{
			t = m_ReverseCakeArray[i];
			m_ReverseCakeArray[i] = m_ReverseCakeArray[j];
			m_ReverseCakeArray[j] = t;
		}
	}

private:
	int m_nCakeCnt;       //烙餅個數
	int m_nMaxSwap;       //最多交換次數
	int m_nSearch;        //當前搜尋次數
	int* m_CakeArray;     //烙餅資訊陣列
	int* m_SwapArray;     //交換結果陣列
	int* m_ReverseCakeArray;//當前翻轉烙餅資訊陣列
	int* m_ReverseCakeArraySwap;//當前翻轉烙餅交換結果陣列
	int m_arrSwap[10];

};
void main()
{
	int nCakeCnt = 10;
	int arrSwap[10] = {3,2,1,6,5,4,9,8,7,0} ;
	CPancakeSorting pan;
	pan.Run(arrSwap, nCakeCnt);
	pan.Output();
}
 

當然還可以把這個問題更復雜化一點，假定每個烙餅都有一面是烤過的，在原來排序的結果上附加一個條件，就是讓所有烤過的那一面都朝下~有興趣的可以思考一下哦~~