UVa120 - Stacks of Flapjacks

Time limit: 3.000 seconds
限时：3.000秒

Background
背景

Stacks and Queues are often considered the bread and butter of data
structures and find use in architecture, parsing, operating systems, and
discrete event simulation. Stacks are also important in the theory of
formal languages.
栈和队列常常被视为数据结构中的面包和黄油，广泛应用在体系结构、分析、操作系统和离散事件等领域。栈同时也在形式语言理论中发挥着重要的作用。

This problem involves both butter and sustenance in the form of
pancakes rather than bread in addition to a finicky server who flips
pancakes according to a unique, but complete set of rules.
这个问题是让一个挑剔的厨师按照独特而完备的一组规则翻动煎饼，以保持煎饼（而不是面包）中的黄油和营养素不被烧坏。（这句话实在不知道怎么翻译才好，还望各位老师指正！Ps. 这道题翻译的难度要比解题大多了！！）

The Problem
问题

Given a stack of pancakes, you are to write a program that indicates
how the stack can be sorted so that the largest pancake is on the bottom
and the smallest pancake is on the top. The size of a pancake is given
by the pancake's diameter. All pancakes in a stack have different
diameters.
给定一叠煎饼，你要写一个程序计算出如何才能使这叠煎饼自底向上由大至小的排列。给定煎饼的半径作为其尺寸，一叠煎饼的大小各不相同。

Sorting a stack is done by a sequence of pancake "flips". A flip
consists of inserting a spatula between two pancakes in a stack and
flipping (reversing) the pancakes on the spatula (reversing the
sub-stack). A flip is specified by giving the position of the pancake on
the bottom of the sub-stack to be flipped (relative to the whole
stack). The pancake on the bottom of the whole stack has position 1 and
the pancake on the top of a stack of n pancakes has position n.
为煎饼叠排序是通过一些列的“翻转”动作来完成的。一个翻转动作就是将一个小铲插到煎饼叠中的某两个煎饼之间，然后将小铲上面的所有煎饼翻转（倒转小铲上面的子栈）。每个翻转动作由其开始的位置给出，即小铲上面子栈中最底下一个煎饼的编号。整叠煎饼中最下面一个的位置为1，n个煎饼的叠中最上面一个的位置为n。

A stack is specified by giving the diameter of each pancake in the stack in the order in which the pancakes appear.
一个煎饼叠由一组表示其中各煎饼直径的数构成，它们排列的顺序就是给出的这些数的顺序。

For example, consider the three stacks of pancakes below (in which pancake 8 is the top-most pancake of the left stack):
比如下面三个煎饼叠（煎饼8是左边一叠的最上面的一个）

8           7           2
         4           6           5
         6           4           8
         7           8           4
         5           5           6
         2           2           7

The stack on the left can be transformed to the stack in the middle
via flip(3). The middle stack can be transformed into the right stack
via the command flip(1).
左边一叠可以通过翻转第3个煎饼变成中间一叠的顺序。中间一叠可以通过翻转第1个煎饼变成右边一叠的顺序。

The Input
输入

The input consists of a sequence of stacks of pancakes. Each stack
will consist of between 1 and 30 pancakes and each pancake will have an
integer diameter between 1 and 100. The input is terminated by
end-of-file. Each stack is given as a single line of input with the top
pancake on a stack appearing first on a line, the bottom pancake
appearing last, and all pancakes separated by a space.
输入包括一系列煎饼叠。每叠都由1到30个煎饼组成，并且每个煎饼的直径都在 1到100之间。输入由EOF结束。每叠煎饼独占一行，最上面的在行首，最下面的在行尾，各煎饼中间由空格隔开。

The Output
输出

For each stack of pancakes, the output should echo the original stack
on one line, followed by some sequence of flips that results in the
stack of pancakes being sorted so that the largest diameter pancake is
on the bottom and the smallest on top. For each stack the sequence of
flips should be terminated by a 0 (indicating no more flips necessary).
Once a stack is sorted, no more flips should be made.
对应于每叠煎饼数据，必须在第一行输出原叠的内容，接下来输出一组翻转动作的序列，使得这一叠煎饼自底向上由大至小的排列。输出的每一组翻转动作序列都要由0来结束（表示不再进行翻转）。一旦一叠煎饼已经排好序，就不能再进行任何翻转。

Sample Input
输入示例

1 2 3 4 5
5 4 3 2 1
5 1 2 3 4

Sample Output
输出示例

1 2 3 4 5
0
5 4 3 2 1
1 0
5 1 2 3 4
1 2 0

Analysis
分析

算法很简单，给你一组煎饼，用笔在纸上一画就知道该怎么办了。还是动态规划的思想，从底至上，保持已经遍例过的煎饼都是最大且有序的。比如输入的数据为：

2 4 1 3 5

按题目要求，4在顶5在底。5已经是最大的了，则移动到上一个煎饼3。3之上（含）最大的是4，先将4翻转到最顶，形成：

4 2 1 3 5

然后将4到3的子叠翻转，形成：

3 1 2 4 5

移动到上一个煎饼2，2之上（含）最大的是3，而3就在顶部，因此直接将2到3翻转，形成：

2 1 3 4 5

最后将2和1翻转，就完成了。注意：一定不要忘了在输入的一行数据下再将原数据复制输出一行，漏掉必然WA。按照上面的算法来做就不会出现多余的翻转操作，因此不用担心。

//解题思路：找到还没排好序的煎饼其中最大的一个，判断其是否在
//顶部，如果不在，则从该位置翻转，再从底部还未排序到的地方
//翻转；否则直接翻转。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define inf 0x3f3f3f3f
const int maxn = ;
int A[maxn], B[maxn];
int n, t, cnt, d, max1;
char ch;

void Change()    //实现翻转操作
{
    for(int i = , j = d; i < j; i++, j-- )
    {
        int temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }
    return ;
}

int main()
{
    while(scanf("%d", &A[]) != EOF)    //这一步不可忽视，刚开始这里直接用的是while(1)，而且没有跳出，
                                        //交了好多发，各种WA，非常迷茫。后来灵感一来，你懂的。
    {
        cnt = ;
        while() //不要小看了这里面的输入操作，其实很巧妙。
        {
            //if(getchar() != ' ') break;    也可以注释掉下面一行，用这一行。
            if(getchar() == '\n') break;
            scanf("%d", &A[++cnt]);
        }
        int flag = ;
        for(int i = ; i < cnt; i++) printf("%d ", A[i]);
        printf("%d\n", A[cnt]);
        A[] = ;    //这一行可以不要，因为默认数组中的元素A[0] = 0, 但是自己要知道。
        for(int i = ; i <= cnt; i++)
        {
            if(A[i] > A[i-]) continue; // 判断是否已经排好序。
            flag = ;
        }
        if(!flag)
        {
            printf("0\n"); //如果已经排好序，则直接返回0
            continue;
        }
        t = ;
        for(int i = ; i <= cnt; i++) //i为底部还没排序的位置。
        {
            max1 = -inf;
            for(int j = cnt-i+; j >= ; j--)
            {
                if(A[j] > max1)
                {
                    max1 = A[j];    //找出还未排好序的元素中最大值
                    d = j;            //记录最大元素的下标。
                }
            }
            if(d != cnt-i+)    //如果最大元素不在它本该在的位置，才进行操作。
            {
                if(d != )    //若果最大元素不在顶部。
                {
                    B[t++] = cnt +  - d; //记录对应翻转的位置。
                    Change();    //把最大元素翻转到顶部
                }
                d = cnt - i + ;    //对应开始翻转的位置。
                Change();    //将顶部元素翻转到对应的底部的相关位置。
                B[t++] = i;
            }
        }
        for(int i = ; i < t; i++) printf("%d ", B[i]);
        printf("0\n");
    }
    return ;
}