編程之美1.3 一摞烙餅的排序

問題描述：

這是前綴翻轉排序問題，書上的內容這里不詳述，給個電子版下載地址

本文源碼編譯環境：codeblock with gcc

書上給的源碼有點小錯誤，編譯通不過，這里是修改過后的原始代碼：

/****************************************************************/
//
// 烙餅排序實現
//
/****************************************************************/
#include <cstdio>
#include<cassert>
class CPrefixSorting
{
public:

    CPrefixSorting()    
    {
        m_nCakeCnt = 0;
        m_nMaxSwap = 0;
        m_CakeArray = NULL;
        m_SwapArray = NULL;
        m_ReverseCakeArray = NULL;
        m_ReverseCakeArraySwap = NULL;
    }

    ~CPrefixSorting()
    {printf("1");
        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;  
        }
        printf("2");
    }

    //
    // 計算烙餅翻轉信息
    // @param
    // 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_SwapArray[i]);
        }

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

private:

    //
    // 初始化數組信息
    // @param
    // pCakeArray    存儲烙餅索引數組
    // nCakeCnt    烙餅個數
    //
    void Init(int* pCakeArray, int nCakeCnt)
    {
        assert(pCakeArray != NULL);
        assert(nCakeCnt > 0);

        m_nCakeCnt = nCakeCnt;

        // 初始化烙餅數組
        m_CakeArray = new int[m_nCakeCnt]; 
        assert(m_CakeArray != NULL);
        for(int i = 0; i < m_nCakeCnt; i++)
        {
            m_CakeArray[i] = pCakeArray[i];
        }

        // 設置最多交換次數信息
        m_nMaxSwap = UpBound(m_nCakeCnt);

        // 初始化交換結果數組 
        m_SwapArray = new int[m_nMaxSwap + 1];
        assert(m_SwapArray != NULL);

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


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

    //
    // 尋找當前翻轉的下界
    //
    //
    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_SwapArray[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);
        }
    }
    //
    // true : 已經排好序
    // false : 未排序
    //
    bool IsSorted(int* pCakeArray, int nCakeCnt)
    {
        for(int i = 1; i < 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_CakeArray;    // 烙餅信息數組
    int m_nCakeCnt;    // 烙餅個數
    int m_nMaxSwap;    // 最多交換次數。根據前面的推斷，這里最多為
    // m_nCakeCnt * 2 
    int* m_SwapArray;    // 交換結果數組

    int* m_ReverseCakeArray;    // 當前翻轉烙餅信息數組
    int* m_ReverseCakeArraySwap;    // 當前翻轉烙餅交換結果數組
    int m_nSearch;    // 當前搜索次數信息
};


int main()
{
    CPrefixSorting a;
    int cakeArry[] = {3,2,1,6,5,4,9,8,7,0};
    a.Run(cakeArry, sizeof(cakeArry) / sizeof(int));
    a.Output();
    printf("\n");
    CPrefixSorting b;
    int cakeArry1[] = {12,3,2,1,11,6,5,10,4,9,8,7,0};
    b.Run(cakeArry1, sizeof(cakeArry1) / sizeof(int));
    b.Output();
    printf("\n");
    CPrefixSorting c;
    int cakeArry2[] = {2,0,1};
    c.Run(cakeArry2, sizeof(cakeArry2) / sizeof(int));
    c.Output();
    return 0;
}

三個測試樣例運行結果：

下面的討論主要是針對書上搜索算法的改進，並且在原始代碼的基礎上進行修改。下面是對原始程序的幾點說明：

1、要盡快找到最小翻轉次數，就要減少搜索過程中（深搜）搜索子樹的數目，即剪枝。原文中是通過分析某個序列，使該序列有序的最小翻轉次數和最大翻轉次數來剪枝的。關於翻轉次數的上界和下界，原文中也提到了分別是 (5n+5)/3向上取整 和 15n/14向上取整，需要注意的是這里的上界和下界是指：任意給定一個序列，最大翻轉次數是(5n+5)/3向上取整 ，最小翻轉次數是15n/14向上取整；而程序中的上界和下界分別是針對某個序列而言，比如對於序列5 4 3 2 1，按照公式下界是5*15/14 = 6，但其實只要翻轉1次。

2、原始程序中使用2n作為上界，其實按照每次把最大的燒餅翻轉的最底下的算法，上界應該為2（n-1），具體書上已經有說明（當然一開始我們也可以選擇(5n+5)/3向上取整作為上界）。然后在搜索的過程中每找到一個比當前上界更好的方案，就更新上界。

3、對於下界書上做法是：因為每一次翻轉最多只能使一個烙餅與大小和它相鄰的烙餅排到一起，所以如果當前n個烙餅中，有m對相鄰的烙餅大小不相鄰，那么我們至少需要m次翻轉才能排好序。

---

下面是改進的幾個地方，改進后的代碼以及改進結果見本文末尾：

1、翻轉上界的改進：其實我們可以通過選擇某個方案對原始序列進行翻轉使之有序，計算翻轉次數，那么這個翻轉次數可以作為上界，因為最優的方案肯定不會比當前的方案差。改進的代碼里選擇書上講的翻轉方案：把最大的未就位的烙餅翻轉到它對應的位置，具體見函數UpBound_case

2、翻轉下屆的改進：不僅要像書上那樣考慮相鄰位置烙餅大小是否相鄰，還要考慮最大燒餅是否就位，若序列中最大燒餅不在最后的位置必然要反轉一次使其就位，而這次是最大燒餅就位的翻轉不改變序列的相鄰燒餅的連續性，具體見LowerBound函數。

3、search中是否超過上屆的條件判斷：具體說明見search函數的注釋（下面代碼224行 和 240行）

4、在搜索的過程中，對於某個序列，原始程序是每個位置都翻轉一次，改進后，對於序列后面已經排好序的位置就不進行翻轉，因為對排好序的位置翻轉必然不會減少翻轉次數，程序中通過search函數第二個參數實現。

5、在對序列翻轉再搜索時，源程序是從第一個位置依次到最后一個位置翻轉再搜索，改進后，我們對翻轉每個位置翻轉后的序列進行一個評估，評估它離有序序列的距離，然后優先搜索距離小的序列。評估函數其實就是LowerBound函數

6、對序列翻轉再搜索時，若某個翻轉剛好使序列有序，那么其他翻轉方案肯定會導致無序，因此可以放棄搜索，代碼通過search的返回值實現，具體見下面代碼292行

改進代碼和結果如下：

#include<cstdio>
#include<cassert>
#include<vector>
#include<algorithm>
struct node
{
    int index;
    int score;
};

bool comp(struct node a, struct node b)
{
    return a.score < b.score;
}

class CPrefixSorting
{
public:

    CPrefixSorting()
    {
        m_nCakeCnt = 0;
        m_nMaxSwap = 0;
        m_CakeArray = NULL;
        m_SwapArray = NULL;
        m_ReverseCakeArray = NULL;
        m_ReverseCakeArraySwap = NULL;
        flag1 = false;
    }

    ~CPrefixSorting()
    {
        releaseAll();
    }

    void releaseAll()
    {
        if( m_CakeArray != NULL )
        {
            delete []m_CakeArray;
            m_CakeArray = NULL;
        }
        if( m_SwapArray != NULL )
        {
            delete []m_SwapArray;
            m_SwapArray = NULL;
        }
        if( m_ReverseCakeArray != NULL )
        {
            delete []m_ReverseCakeArray;
            m_ReverseCakeArray = NULL;
        }
        if( m_ReverseCakeArraySwap != NULL )
        {
            delete []m_ReverseCakeArraySwap;
            m_ReverseCakeArraySwap = NULL;
        }
    }

    //
    // 計算烙餅翻轉信息
    // @param
    // pCakeArray    存儲烙餅索引數組
    // nCakeCnt    烙餅個數
    //
    void Run(int* pCakeArray, int nCakeCnt)
    {

        releaseAll();
        Init(pCakeArray, nCakeCnt);

        m_nSearch = 0;
        Search(0, nCakeCnt - 1);
    }

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

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

private:

    //
    // 初始化數組信息
    // @param
    // pCakeArray    存儲烙餅索引數組
    // nCakeCnt    烙餅個數
    //
    void Init(int* pCakeArray, int nCakeCnt)
    {
        assert(pCakeArray != NULL);
        assert(nCakeCnt > 0);

        flag1 = false;

        m_nCakeCnt = nCakeCnt;

        // 初始化烙餅數組
        m_CakeArray = new int[m_nCakeCnt];
        assert(m_CakeArray != NULL);
        for(int i = 0; i < m_nCakeCnt; i++)
        {
            m_CakeArray[i] = pCakeArray[i];
        }

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

        // 設置最多交換次數信息
        //m_nMaxSwap = UpBound(m_nCakeCnt);
        m_nMaxSwap = UpBound_case(m_ReverseCakeArray, m_nCakeCnt);
        //UpBound_case中m_ReverseCakeArray改變了
        //m_ReverseCakeArray復原
        for(int i = 0; i < m_nCakeCnt; i++)
        {
            m_ReverseCakeArray[i] = m_CakeArray[i];
        }

        // 初始化交換結果數組
        m_SwapArray = new int[m_nMaxSwap + 1];
        assert(m_SwapArray != NULL);

        m_ReverseCakeArraySwap = new int[m_nMaxSwap];
        assert(m_ReverseCakeArraySwap != NULL);
    }


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

    //--每次把最大的翻轉到最下面，計算這種方法所需要的次數
    //--計算過程中保存翻轉結果，因為這種方法可能就是最小翻轉次數的方法
    //--這個次數可以作為翻轉次數的上界
    int UpBound_case(int* pCakeArray, int nCakeCnt)
    {
        int re = 0;
        for (int j = nCakeCnt - 1 ; ;)
        {
            while(j > 0 && j == pCakeArray[j])
                --j;
            if (j <= 0)
                break;
            int i = j;
            while (i >= 0 && pCakeArray[i] != j)
                --i;
            if (i != 0)
            {
                Revert(pCakeArray, 0, i);
                re++;
            }
            Revert(pCakeArray, 0, j);
            re++;
            --j;
        }
        return re;
    }

    //
    // 尋找當前翻轉的下界
    //
    //
    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++;
            }
        }
        //--如果最大的烙餅不在最后一個位置，則要多翻轉一次
        if (pCakeArray[nCakeCnt-1] != nCakeCnt-1) ret++;
        return ret;
    }

    //--序列評估函數，對一個序列，若到達有序狀態所需的翻轉次數越少，得分越少
    //--若到達有序狀態所需的翻轉次數越多，得分越多
    //--搜索時可以優先搜索得分少的序列，這樣能盡快達到最優解
    int Evaluate(int* pCakeArray, int nCakeCnt)
    {
        return LowerBound(pCakeArray, nCakeCnt);
    }

    // 排序的主函數
    //--第endBound+1 個燒餅后均以排好序，沒有必要對排好序的進行交換
    //--因為交換已經排好序的燒餅只能使交換次數增大
    //--如果當前搜索的序列排好序則返回true，否則返回false
    bool Search(int step, int endBound)
    {
        int i, nEstimate;

        m_nSearch++;

        // 估算這次搜索所需要的最小交換次數
        nEstimate = LowerBound(m_ReverseCakeArray, m_nCakeCnt);

        //--遇到相等情形，若對於翻轉次數為m_nMaxSwap的結果已經保存，流程繼續。
        //--后面再遇到就可以跳過了，因為針對該翻轉次數的結果已經保存，
        //無需再計算
        if(step + nEstimate == m_nMaxSwap && flag1 == false);
        else if(step + nEstimate >= m_nMaxSwap)
            return false;

        //重新計算排好序的位置
        int k = endBound;
        while(k > 0 && k == m_ReverseCakeArray[k])
            --k;

        // 如果k=0,說明已經排好序，即翻轉完成，輸出結果
        //if(IsSorted(m_ReverseCakeArray, m_nCakeCnt))
        if(k == 0)
        {
            if(step < m_nMaxSwap)
            {
                //--當前找到的一個解
                m_nMaxSwap = step;
                for(i = 0; i < m_nMaxSwap; i++)
                    m_SwapArray[i] = m_ReverseCakeArraySwap[i];
            }
            else if(step == m_nMaxSwap && flag1 == false)
            {
                //--只有第一次碰到step == m_nMaxSwap時才做如下操作
                //--因為m_nMaxSwap可能是最小翻轉次數，因此要記錄此次結果
                //--后面再碰到相等時，可以忽略，因為不用重復保存結果
                for(i = 0; i < m_nMaxSwap; i++)
                    m_SwapArray[i] = m_ReverseCakeArraySwap[i];
                flag1 = true;
            }
            return true;
        }

        // 遞歸進行翻轉,k之后已經排好序的位置就不用翻轉了
        std::vector<node> swapIndexScore;
        //對翻轉后的序列進行評估，評估它到排序好的序列之間的距離，優先搜索距離小的序列
        for(i = 1; i <=k; i++)
        {
            struct node tnode;
            tnode.index = i;
            tnode.score = nEstimate;//原始序列的分數
            //求翻轉后的分數，翻轉后只有翻轉位置影響分數的大小
            if(i != m_nCakeCnt - 1)
            {
                if(abs(m_ReverseCakeArray[i] - m_ReverseCakeArray[i+1]) == 1)
                    tnode.score++;
                if(abs(m_ReverseCakeArray[0] - m_ReverseCakeArray[i+1]) == 1)
                    tnode.score--;
            }
            else
            {
                if(m_ReverseCakeArray[i] == i)tnode.score++;
                if(m_ReverseCakeArray[0] == i)tnode.score--;
            }
            swapIndexScore.push_back(tnode);
        }
        //按照得分小到大排序，得分小的優先搜索
        sort(swapIndexScore.begin(), swapIndexScore.end(),comp);

        for(i = 0; i < swapIndexScore.size() ; i++)
        {
            Revert(m_ReverseCakeArray, 0, swapIndexScore[i].index);
            m_ReverseCakeArraySwap[step] = swapIndexScore[i].index;
            bool isDone = Search(step + 1, k);
            Revert(m_ReverseCakeArray, 0, swapIndexScore[i].index);
            //如果該搜索序列有序，那么其他翻轉方案肯定會導致無序，因此不需要搜索
            if(isDone == true)break;
        }

//        for(i = 1; i <=k ; i++)
//        {
//            Revert(m_ReverseCakeArray, 0, i);
//            m_ReverseCakeArraySwap[step] = i;
//            Search(step + 1, k);
//            Revert(m_ReverseCakeArray, 0, i);
//        }
        return false;
    }
    //
    // true : 已經排好序
    // false : 未排序
    //
    bool IsSorted(int* pCakeArray, int nCakeCnt)
    {
        for(int i = 1; i < nCakeCnt; i++)
        {
            if(pCakeArray[i-1] > pCakeArray[i])
            {
                return false;
            }
        }
        return true;
    }

    //
    // 翻轉數組
    //
    void Revert(int arry[], int nBegin, int nEnd)
    {
        assert(nEnd > nBegin);
        int i, j, t;

        // 翻轉數組
        for(i = nBegin, j = nEnd; i < j; i++, j--)
        {
            t = arry[i];
            arry[i] = arry[j];
            arry[j] = t;
        }
    }

private:

    int* m_CakeArray;    // 烙餅信息數組
    int m_nCakeCnt;    // 烙餅個數
    int m_nMaxSwap;    // 最多交換次數。根據前面的推斷，這里最多為
    // m_nCakeCnt * 2
    int* m_SwapArray;    // 交換結果數組

    int* m_ReverseCakeArray;    // 當前翻轉烙餅信息數組
    int* m_ReverseCakeArraySwap;    // 當前翻轉烙餅交換結果數組
    int m_nSearch;    // 當前搜索次數信息
    bool flag1;//--當最開始計算的m_nMaxSwap是最小翻轉次數時，若記錄了這個翻轉的
               //結果,flag1 = ture，否則為false，詳見search函數
};

int main()
{
    CPrefixSorting a;
    int cakeArry[] = {3,2,1,6,5,4,9,8,7,0};
    int cakeArry1[] = {12,3,2,1,11,6,5,10,4,9,8,7,0};
    int cakeArry2[] = {2,0,1};
    a.Run(cakeArry, sizeof(cakeArry) / sizeof(int));
    a.Output();
    a.Run(cakeArry1, sizeof(cakeArry1) / sizeof(int));
    a.Output();
    a.Run(cakeArry2, sizeof(cakeArry2) / sizeof(int));
    a.Output();
    return 0;
}

 

【版權聲明】轉載請注明出處 http://www.cnblogs.com/TenosDoIt/p/3250742.html