編程之美學習筆記--一摞烙餅的排序

問題：假設有n塊大小不一的烙餅，翻烙餅時只能從最上面的烙餅開始，一次抓住最上面的幾塊餅，把它們上下顛倒個兒，那麼最少要翻多少次，才能夠達到最後的大小有序？

思路

先上一張圖，可以很好的說明思路：

假設有四張無序的餅，那麼問題就變成了找到使層數最小的結點。書中給出的思路是：
將烙餅從第二張開始一個一個的嘗試去翻，採用深度優先搜索的策略。在搜索開始之前，先找到了一種完成任務的方式，最少需要2*（n_cake-1）步。這就是一個搜索的上界，如果搜索步驟超過了這個上界，則這一枝可以拋棄不用搜索了，如果搜索到了一種翻轉方式，則將這種翻轉方式的翻轉次數更新爲新的搜索上界值，以減小搜索範圍；同時給出了計算搜索下界的計算方式：當前狀態翻轉到有序狀態的步驟數目下界：若當前狀態中，還有m對烙餅沒有相鄰，而每次翻轉最多隻能使得一個烙餅與大小跟它相鄰的烙餅拍到一起，故至少還要m次才能排好，如果當前搜索步數加上這個下界的值超過了搜索上界值，則在該枝的搜索就不必進行了。
搜索時，循環進行每一個子樹的搜索，循環中使用遞歸方式搜索；程序如下：

#include <stdio.h>
#include <stdlib.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; //執行交換後的烙餅數組的交換信息
    int* m_SortArray;        //排序完成的烙餅數組結果

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);
    ~CakeSort(void);
};
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];
    m_SortArray=new int [m_CakeCount];
}
int CakeSort::UpperBound(int count)
{
    return 2*(count - 1);
}

//當前狀態翻轉到有序狀態的步驟數目下界：若當前狀態中，還有m對烙餅沒有相鄰，而每次翻轉最多隻能
//使得一個烙餅與大小跟它相鄰的烙餅拍到一起，故至少還要m次才能排好
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);

    //打印最優排序方式
    printf("最優翻轉方式：\n");
    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);  

    //打印排序結果
    for (int i=0;i<m_CakeCount;i++)
    {
        printf("cake:%d\n",m_SortArray[i]);
    }


}
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];
                printf("%d\n",m_SwapArray[i]);
            }
            //打印該翻轉方式下的排序結果
            for (int i=0;i<m_CakeCount;i++)
            {
                //想要保存正確的翻轉結果，需要另建數組保存，不然m_ReverseCake還會在其他函數中修改，最後m_ReverseCake中不會保留正確的翻轉結果
                m_SortArray[i]=m_ReverseCake[i];
                printf("cake:%d\n",m_ReverseCake[i]);
            }

        }
        return;
    }
    //沒有排列好的情況
    for(int i = 1 ; i < m_CakeCount ; i++)
    {
        Reverse(0,i);
        //記錄本次操作的下標
        m_SwapReverseCake[step] = i;
        Search(step+1);
        //若第step+1步的翻轉失敗，回覆到第step步的翻轉結果
        Reverse(0,i);
    }
}
int main()
{
    int a[] = {3, 2, 1, 6, 5, 4, 9, 8, 7, 0};  
    CakeSort s;
    s.Run(a,10);
    system("pause");
    return 0;  
}

CakeSort::~CakeSort(void)
{
    if(m_CakeArray!=NULL)delete []m_CakeArray;
    if(m_SwapReverseCake!=NULL)delete []m_SwapReverseCake;
    if(m_SwapArray!=NULL)delete []m_SwapArray;
    if(m_ReverseCake!=NULL)delete []m_ReverseCake;
    if(m_SortArray!=NULL)delete []m_SortArray;
}

從上述程序的輸出結果中可以看出，其實程序還是搜索了很多不必要的路徑，如剛剛將頭兩張烙餅翻轉，下一步馬上又把頭兩張餅翻轉過來，顯然是重複了，就沒有再向下搜索的必要了，因此可以繼續優化，進一步減小搜索範圍
這裏我們採用的想法是：上一步翻轉過的前i張餅，在下一次迭代時，直接跳過翻轉前i張餅的情況（因爲這樣又會恢復到上一步的狀態），因此我們將:Search遞歸函數修改爲：

void CakeSort::Search(int step,int flapIndex)
{
    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];
                printf("%d\n",m_SwapArray[i]);
            }
            //打印該翻轉方式下的排序結果
            for (int i=0;i<m_CakeCount;i++)
            {
                //想要保存正確的翻轉結果，需要另建數組保存，不然m_ReverseCake還會在其他函數中修改，最後m_ReverseCake中不會保留正確的翻轉結果
                m_SortArray[i]=m_ReverseCake[i];
                printf("cake:%d\n",m_ReverseCake[i]);
            }

        }
        return;
    }
    //沒有排列好的情況
    for(int i = 1 ; i < m_CakeCount ; i++)
    {
        if(flapIndex==i)continue;
        Reverse(0,i);
        //記錄本次操作的下標
        m_SwapReverseCake[step] = i;
        Search(step+1,i);
        //若第step+1步的翻轉失敗，回覆到第step步的翻轉結果
        Reverse(0,i);
    }
}

相應的，run函數修改爲：

void CakeSort::Run(int* pArray,int count)
{
    Init(pArray,count);

    Search(0,0);

    //打印最優排序方式
    printf("最優翻轉方式：\n");
    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);  

    //打印排序結果
    for (int i=0;i<m_CakeCount;i++)
    {
        printf("cake:%d\n",m_SortArray[i]);
    }


}

雖然可以避免一部分無用搜索，但是還是會存在無用的搜索。