编程之美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("
 |Search Times| : %d
", m_nSearch);
        printf("Total Swap times = %d
", 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("
");
    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("
");
    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("
 |Search Times| : %d
", m_nSearch);
        printf("Total Swap times = %d

", 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