Gym 101246F list and iterator

F. Elevator

time limit per test

1 second

memory limit per test

256 megabytes

input

input.txt

output

output.txt

The Berland State Building is the highest building in the capital of Berland. Curious Polikarp was studying the principle of operation of an elevator in the Berland State Building for a quite a while. Recently he has finally understood the algorithm behind its operation, in case a person enters the elevator on the floor f and presses the floor buttons e1, e2, ..., en one by one. The buttons are pressed sequentially but very quickly while the elevator is still located on the floor f. All the pressed buttons are distinct and differ from the floor f. No other button pressings are considered in this problem.

After the buttons e1, e2, ..., en have been pressed, all of them become highlighted and the elevator starts moving according the following rules:

• The elevator starts moving towards the floor, the button of which is highlighted and pressed first among all highlighted buttons. Say, it's floor/button a.
• If on its way to a the elevator passes the floor b, the button of which is highlighted, it stops there, the light goes out for the button bunhighlighting it, and the floor b is considered visited. Then the elevator continues moving towards the floor a. It is possible that there will be more than one floor such as b on the way to floor a — all these floors will be passed one by one according to the described algorithm.
• Having reached the floor a, the elevator stops there, the light goes out for the button a unhighlighting it, and the floor a is considered visited. Then the elevator starts to move towards the floor, the button of which has been pressed the earliest among the currently highlighted buttons. That floor becomes a new value of a. The elevator continues moving according to the rules described in the previous paragraph. If it's impossible to find a new value for a because there are no highlighted floor buttons, it means that all floors have been visited and the elevator stops.

Now, when the principle of the elevator's operation is clear, Polikarp wants to experiment with the elevator's movements without the elevator itself. He wants to write a program that simulates elevator's operation. Unfortunately, he didn't attend any programming lessons and it's a challenge for him. Can you please help Polikarp and write a program which will simulate movements of the elevator?

Input

The first line of input contains a pair of integers n, f (1 ≤ n, f ≤ 100), where n — amount of pressings made, f — index of the current floor where all these pressings were made. The second line contains distinct integers e1, e2, ..., en (1 ≤ ei ≤ 100, ei ≠ f) — buttons indices in the order they were pressed.

Output

Output all the floors where the elevator stops, in a chronological order of the stops.

Examples

input

4 5
10 9 2 1

output

9 10 2 1 

input

4 3
2 4 1 5

output

2 4 1 5 

http://codeforces.com/gym/101246/problem/F

题目大意是说，一部电梯，多个按钮 ，i按钮即前往i层。初始电梯在第f层，多个按钮a 1 ，a 2 ,……a n 同时按下，n个按钮全部变成高亮。电梯运行规则如下：

1.电梯直接前往第一个被按下的a按钮方向。

2. 电梯在前往a层的途中遇到了b层，并且代表b层的按钮处于高亮状态，那么在b层停顿。b按钮高亮消失， 电梯继续前往a楼层。之后遇到的其他处于高亮的楼层按钮同样如此。

3.电梯到达a层，a按钮高亮消失，电梯选择剩下的高亮的按钮中最靠前的按钮为下一个a，并且前往a楼层。重复第二三个规则。直到没有高亮的按钮。

解题思路：题目不难，只是一个模拟题。储存的数据结构我想到的是用长度可变，可任意删增的list，搭配iterator遍历。开两个list，a，b，第一个存储所有的高亮按钮。第二个存储在前往a层途中要停靠的楼层。并且排序，如果电梯下降，那就降序排序；如果电梯上升，就升序排序。并且按序输出，再清空list。重复取a按钮，直到list a 为空就结束。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <list>
using namespace std;

bool fun( int x ,int y,int z)
{
    int t;
    if(x>y)
    {
        t=y;
        y=x;
        x=t;
    }
    if(z>x&&z<y)
        return true;
    return false;
}
bool compare1(int a,int b)
{
  return a<b; //升序排列
}
bool compare2(int a,int b)
{
  return a>b; //降序排列
}

int main()
{
    freopen("input.txt","r",stdin);
    freopen("output.txt","w",stdout);
    int n,f,r;
    list<int > s;
    list<int>  sonstr;
    list<int>::iterator it;
    while(cin>>n>>f)
    {
        bool kaiguan =true;
        for(int i=0;i<n;i++){
            cin>>r;
            s.push_back(r);
        }
        while(!s.empty()){
            it = s.begin();
            sonstr.push_back(*it);
            for( list<int>::iterator i = s.begin() ; i!= s.end() ;)
            {
                if( fun( *it, f , *i ))
                {
                    sonstr.push_back( *i);
                    i=s.erase(i);
                }else
                    i++;
            }

            if(*it > f)
                sonstr.sort(compare1);
            else
                sonstr.sort(compare2);

            for( list<int>::iterator i = sonstr.begin() ; i!= sonstr.end() ; i++ )
            {
                if(kaiguan){
                    cout<<*i;
                    kaiguan=false;
                }
                else
                    cout<<" "<<*i;
            }
            f=*it;
            sonstr.clear();
            s.erase(it);
        }
        cout<<endl;
    }
    return 0;
}