Stacks of Flapjacks

Stacks of Flapjacks

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.

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.

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           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).

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.

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.

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

#include<cstdio>
#include<iostream>
#include<sstream>
#include<algorithm>
using namespace std;

const int maxn = 30 + 5;
int n, a[maxn];

void flip(int p)
{
  for(int i = 0; i < p-i; i++)
    swap(a[i], a[p-i]);
  printf("%d ", n-p);
}

int main()
{
  string s;
  while(getline(cin, s))
  {
    cout << s << "\n";
    stringstream ss(s);
    n = 0;
    while(ss >> a[n]) n++;
    cout<<n<<endl;
    for(int i = n-1; i > 0; i--)
	{
	    //找到当前最大值所在的位置;
      int p = max_element(a, a+i+1) - a;
      cout<<p<<endl;
        //如果最大值与它所在的位置相同,继续下一个;
      if(p == i) continue;
       //转换;将最大值放到第一个位置;
      if(p > 0) flip(p);
      flip(i);
    }
    printf("0\n");
  }
  return 0;
}

时间: 2024-10-15 01:03:37

Stacks of Flapjacks的相关文章

[2016-03-03][UVA][120][Stacks of Flapjacks]

[2016-03-03][UVA][120][Stacks of Flapjacks] UVA - 120 Stacks of Flapjacks Time Limit: 3000MS Memory Limit: Unknown 64bit IO Format: %lld & %llu Submit Status Description Background Stacks and Queues are often considered the bread and butter of data s

【思维】Stacks of Flapjacks

[UVa120] Stacks of Flapjacks 算法入门经典第8章8-1 (P236) 题目大意:有一个序列,可以翻转[1,k],构造一种方案使得序列升序排列. 试题分析:从插入排序即可找到思路.每次我们优先地将没有到自己位置上的.最大的数挪到自己的位置上. 为什么可以这样做呢?难道不会改变已经排好序的么. 不会,因为我们从大往小处理,翻转的是前面的一段,而排好序的是后面一段,因此肯定不会打乱后面的. 对于每一个数,设其下标为pos,已经排好序的有x个,那么我们先将pos其变为1,即翻

uva 120 stacks of flapjacks ——yhx

 Stacks of Flapjacks  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

UVA 120 Stacks of Flapjacks(翻煎饼,啦啦啦啦~)

Problem A : Stacks of Flapjacks 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

Stacks of Flapjacks UVA 120

说明:这道题初读有点绕....开始我以为只是将一个序列的最大值放到最右边,把最小值放到最左边...所以就怎么也通不过啦.后来终于理解题意了,其实就是要你排个序,从左到右为从大到小.但是改变序列顺序的规则有些特殊,即只能将从最左边开始到某一位置构成的连续子序列进行对称翻转.如有序列:  2,4,9,5,7,6.我选择的位置是5所在的位置,翻转后序列就变为5,9,4,2,7,6.然后用类似于冒泡排序的方法.通过最多两次翻转可以得到最大值,然后放到右边.不断重复上述操作,即可得到一个有序序列. 题目:

uva Stacks of Flapjacks

                                                 Stacks of Flapjacks  题目链接:Click Here~ 题目描写叙述:     给你n个数.要你得到的最后结果是从下到大排序.可是给出的序列不一定是有序你.要通过你的调整.问:要经过哪几个位置上的数的调整? 算法分析:     一開始,我的思路是直接模拟一边消除逆序数就能够了,由于我看数据非常小,仅仅有30.可是提交之后却TEL了. 后来上网查了一下.看到有一个人的思路还是非

UVa 120 Stacks of Flapjacks

题意:给一摞随意摞的煎饼,要按直径从上到下递增的顺序排列,求翻的顺序. 思路:贪心. 1,读取煎饼数据,新建一个数组,复制数据,排序,作为参考. 2,从最大直径(maxNum)的煎饼开始,看其是否在底层,是的话就寻找上一层最大的. 3,假如不在底层,看其在不在顶层,在顶层就把全部煎饼翻过来,使当前需要操作的最大的直径煎饼放在最下. 4,假如不在底层也不在顶层,就找到它,先翻到顶层,然后步骤同3. 直到maxNum代表数据为最小直径的煎饼. 代码: #include <iostream> #in

UVa120 - Stacks of Flapjacks (STL)

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. 栈和队列常常被

B - Stacks of Flapjacks UVA - 120

BackgroundStacks 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 proble