ShellSort

The Problem

King Yertle wishes to rearrange his turtle throne to place his highest-ranking nobles and closest advisors nearer to the top. A single operation is available to change the order of the turtles in the stack: a turtle can crawl out of its position in the stack and climb up over the other turtles to sit on the top.

Given an original ordering of a turtle stack and a required ordering for the same turtle stack, your job is to determine a minimal sequence of operations that rearranges the original stack into the required stack.

The first line of the input consists of a single integer K giving the number of test cases. Each test case consist on an integer n giving the number of turtles in the stack. The next n lines specify the original ordering of the turtle stack. Each of the lines contains the name of a turtle, starting with the turtle on the top of the stack and working down to the turtle at the bottom of the stack. Turtles have unique names, each of which is a string of no more than eighty characters drawn from a character set consisting of the alphanumeric characters, the space character and the period (`.‘). The next n lines in the input gives the desired ordering of the stack, once again by naming turtles from top to bottom. Each test case consists of exactly 2n+1 lines in total. The number of turtles (n) will be less than or equal to two hundred.

For each test case, the output consists of a sequence of turtle names, one per line, indicating the order in which turtles are to leave their positions in the stack and crawl to the top. This sequence of operations should transform the original stack into the required stack and should be as short as possible. If more than one solution of shortest length is possible, any of the solutions may be reported. Print a blank line after each test case.

Sample Input

2
3
Yertle
Duke of Earl
Sir Lancelot
Duke of Earl
Yertle
Sir Lancelot
9
Yertle
Duke of Earl
Sir Lancelot
Elizabeth Windsor
Michael Eisner
Richard M. Nixon
Mr. Rogers
Ford Perfect
Mack
Yertle
Richard M. Nixon
Sir Lancelot
Duke of Earl
Elizabeth Windsor
Michael Eisner
Mr. Rogers
Ford Perfect
Mack

Sample Output

Duke of Earl

Sir Lancelot
Richard M. Nixon
Yertle

解决方式：通过观察，可把这些名字按目标位置标上序号。从上到下一次1......n，依照整理之前的顺序。把这些标号从后写入list容器，然后从头到尾遍历每一个位置。当这个元素比前面的最大值要小时，这个元素必须移动。但未必是操作最少。所以。当遍历完整个序列。选必须移动的元素之中的最大值移到开头。然后反复之前的动作，直到没有要移动的为止。用list模拟，用了2.9多秒，差点tle。不知还有没有更快的。

代码：

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

list<int> L;//创建一个list容器
string name[220];
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        map<string ,int >num;
        map<int,string> str;
        int n;
        scanf("%d",&n);
        getchar();
        char Name[100];
        for(int i=0;i<n;i++)
            {
              gets(Name);
              name[i]=(string)Name;
            }
        for(int i=0;i<n;i++)
        {
            gets(Name);
            num[(string)Name]=i+1;
            str[i+1]=(string)Name;

        }
        L.clear();
        for(int i=0;i<n;i++)
        {
            L.push_back(num[name[i]]);//从后把元素增加

        }
        list<int>::iterator j;
        list<int>::iterator del;
        list<int>::iterator te;//定义迭代器
        int Max;
        while(1){
                bool flag=false;
                Max=0;
        for(j=L.begin();j!=L.end();j++)
          {
              te=max_element(L.begin(),j);//返回L.begin(),到j之间的最大值
              if((*j)<(*te))
              {
                  if(int(*j)>Max){
                    del=j;Max=int(*j);
                  }
                 flag=true;
              }
          }
          if(!flag) break;
          L.push_front(int(*del));//从前面增加
          cout<<str[*del]<<endl;
          L.erase(del);//删除del位置的元素

        }
        cout<<endl;

    }
    return 0;
}