编程之美—烙饼排序问题（JAVA）

一、问题描述

　　星期五的晚上，一帮同事在希格玛大厦附近的“硬盘酒吧”多喝了几杯。程序员多喝了几杯之后谈什么呢？自然是算法问题。有个同事说：“我以前在餐      馆打工，顾客经常点非常多的烙饼。店里的饼大小不一，我习惯在到达顾客饭桌前，把一摞饼按照大小次序摆好——小的在上面，大的在下面。由于我      一只手托着盘子，只好用另一只手，一次抓最上面的几块饼，把它们上下颠倒个个儿，反复几次之后，这摞烙饼就排好序了。我后来想，这实际上是个     有趣的排序问题：假设有n块大小不一的饼，那最少要翻几次，才能达到最后大小有序的结果呢？你能否写出一个程序，对于n块大小不一的烙饼，输出     最优化的翻饼过程呢？

二、问题分析

　　首先看到这个问题 ，你第一感觉肯定是：噢，这是一个排序问题。但是这个问题不同于一般的排序，从问题描述中可以看出，每次操作都只能选从第       一个到第n个烙饼，然后整体倒置（如图1）。问题来了，选择从第一个到底n个烙饼，进行倒置（1~n个饼并没有排好序），如何在每一次或者几次         倒置中可以使得烙饼的局部排好序呢？然后经过一系列倒置，然后使整体排好序。描述到这里，你是不是已经想到了一种解法呢？

三、解法一：首先把最上面的烙饼和最大的烙饼之间的烙饼翻转，于是，最大的烙饼就在最上面了，再进行一次翻转，把最大的烙饼放在最底

           部，最大的烙饼就在自己的正确位置上了。即通过两次翻转，把最大的烙饼放在最低部了。然后选择从最上面的饼和次大的烙饼

　　　　，重复上面的步骤。每两次翻转，把不再正确位置上的最大饼放在合适的位置上。

                 

那么，我们一共需要多少次翻转才能把这些烙饼给翻转过来呢？

             首先，经过两次翻转可以把最大的烙饼翻转到最下面。因此，最多需要把上面的n-1个烙饼依次翻转两次。那么，排到剩下第一个和第二个时，         我们需要2（n-2)次翻转。最后，第一个和第二个最多需要一次翻转（可能一次都不需要，已经排好序了）。

四、我们已经求出了一个解法，但是会不会有更好的方法通过更少的翻转达到相同的目的呢？

考虑一种情况，比如上面的图1，序号1、2、3的最上面三个烙饼其实是三个相邻顺序已经排好的烙饼。考虑每次翻转时都让把两个本来应该相邻在烙饼尽可能地换到一起。这样，当所有的烙饼都换到一起之后，实际上就是完成排序了。（从这个意义上来说，每次翻最大烙饼的方案实质上就是每次把最大的和次大的交换到一起，但是通过了两次翻转，不是每一次都尽可能的把两个本来应该相邻在烙饼尽可能地换到一起）

      那什么的情况下可以通过最少的翻转排好序呢？这里是不是可以选择一种穷举的方法，穷举所有的的每次翻转的情况，展开来看就是一棵树，每个结点都有九个子节点（有九中翻转情况），如果翻转达到2n-3还未排好序则截断这一分支。可以根据当前的翻转次数加上估计还需要的最小翻转次数（下界值，下限值可以这样确定：从最后一个位置开始，往前找到第一个与最终结果位置不同的烙饼编号（也就是说排除最后几个已经就位的烙饼），从该位置到第一个位置，计算相邻的烙饼的编号不连续的次数，再加上1。）来判断是否截断这一分支。我们可以选择递归的方法深度遍历这颗树，得到最小的排好序的那些步骤。

五、代码

public class CFlapjackSorting {
    private int m_nCake;    //烙饼的个数
    private int[] m_CakeArray;  //烙饼的信息数组，也就是初始数组的输入数
    private int m_nMaxSwap;     //最大的交换次数
    private int[] m_SwapArray;  //存储交换位置信息的数组
    private int[] m_ReverseCakeArray;   //当时翻转烙饼信息数组
    private int[] m_ReverseCakeArraySwap;  //当时存储交换位置信息的数组
    private int m_nSearch;      //搜索次数

    public CFlapjackSorting() {
        m_nCake = 0;
        m_nMaxSwap = 0;
    }

    /**
     *
     * @param pCakeArray  输入的烙饼信息
     * @param nCake       数组的长度
     */
    public void init(int[] pCakeArray, int nCake) {
        assert (pCakeArray != null);
        m_nCake = nCake;
        m_CakeArray = new int[m_nCake];
        assert (m_CakeArray != null);
        //初始化烙饼数组
        for (int i = 0; i < m_nCake; i++) {
            m_CakeArray[i] = pCakeArray[i];
        }

        m_nMaxSwap = upBound(m_nCake);
        m_SwapArray = new int[m_nMaxSwap + 1];
        assert (m_SwapArray != null);
        m_ReverseCakeArray = new int[m_nCake];
        for (int i = 0; i < m_nCake; i++) {
            m_ReverseCakeArray[i] = m_CakeArray[i];
        }

        m_ReverseCakeArraySwap = new int[m_nMaxSwap+1];
    }

    /**
     * 最大上界：可以翻转的最大次数
     * @param nCake 烙饼的个数
     * @return
     */
    public int upBound(int nCake) {
        return 2 * nCake;
    }

    /**
     * 最小下界
     * @param pCakeArray
     * @param nCake
     * @return
     */
    int LowerBound(int[] pCakeArray, int nCake) {
        int t, lower = 0;
        for (int i = 1; i < nCake; i++) {
            t = pCakeArray[i] - pCakeArray[i - 1];
            if ((t == 1) || (t == -1)) {

            } else {
                lower++;
            }
        }
        return lower;
    }

    /**
     * 搜索函数
     * @param step  第几步
     */
    public void search(int step) {
        int minEstimate; //最小交换次数估计
        m_nSearch++;
        minEstimate = LowerBound(m_ReverseCakeArray, m_nCake);
        if (step + minEstimate > m_nMaxSwap)
            return;
        //判读是否排好序
        if (isSorted(m_ReverseCakeArray, m_nCake)) {
            //如果排好序了，而且翻转次数小于最大翻转次数。否则终止搜索
            if (step < m_nMaxSwap) {
                m_nMaxSwap = step;
                for (int i = 0; i < m_nMaxSwap; i++) {
                    m_SwapArray[i] = m_ReverseCakeArraySwap[i];
                }
            }
            return;
        }
        //进行翻转
        for (int i = 1; i < m_nCake; i++) {
            revert(0, i);
            m_ReverseCakeArraySwap[step] = i;  //记录每次翻转时翻转的位置信息
            search(step + 1);
            revert(0, i);
        }
    }

    /**
     * 判断是否排好序
     * @param pCakeArray
     * @param nCake
     * @return
     */
    public boolean isSorted(int[] pCakeArray, int nCake) {
        for (int i = 1; i < nCake; i++) {
            if (pCakeArray[i] < pCakeArray[i - 1]) {
                return false;
            }
        }
        return true;
    }

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

    /**
     * 输出翻转的位置信息
     * 搜索的次数
     * 翻转的次数
     * 翻转的每一步翻转情况
     */
    public void output() {
        for (int i = 0; i < m_nMaxSwap; i++) {
            System.out.printf("%d", m_SwapArray[i]);
        }

        System.out.printf("\n|Search Times|:%d\n", m_nSearch);
        System.out.printf("Total swap times = %d\n", m_nMaxSwap);

        perReverseArrayOutput(m_CakeArray,m_SwapArray,m_nCake,m_nMaxSwap);
    }
    /**
     * 通过记录每次翻转位置的数组，输入每次翻转的数组
     * 显示每一步的翻转结果
     * @param cakeArray  最初要排序的数组
     * @param swapArray  记录每次翻转时翻转的位置
     *@param nCake  数组的数量
     * @param maxSwap 翻转的次数
     */
    public static void perReverseArrayOutput(int[] cakeArray,int[] swapArray,int nCake,int maxSwap){
        System.out.printf("%d\n", maxSwap);
        int t;
        for(int i=0;i<maxSwap;i++) {
            System.out.printf("%d ",swapArray[maxSwap]);
            for (int x = 0,y = swapArray[i]; x < y; x++, y--) {

                t = cakeArray[x];
                cakeArray[x] = cakeArray[y];
                cakeArray[y] = t;
            }

            for(int k=0;k<nCake;k++){
                System.out.printf("%d ",cakeArray[k]);
            }
            System.out.print("\n");
        }

    }

    public void run(int[] pCakeArray,int nCake){
        init(pCakeArray,nCake);
        m_nSearch=0;
        search(0);
    }

}

六、参考博客

jinLei_zhao的博客（一摞烙饼的排序）

Huaerge的博客（一摞烙饼的排序）