Sicily 7974. Integer Lists 解题报告

题目：

Constraints

Time Limit: 1 secs, Memory Limit: 256 MB

Description

The programming language Better And Portable Code (BAPC) is a language for working with lists of integers. The language has two built-in functions: ‘R’ (reverse) and ‘D’ (drop).
The function ‘R’ reverses its input list, and ’D’ drops the first element of its input and returns the rest, or gives an error in case its input is an empty list. To get more advanced behavior, functions can be composed: “AB” is the function that first applies ‘A’ to its input and then ‘B’ to the resulting list. For example, “RDD” is a function that reverses a list and then drops the first two elements.
Unfortunately, our BAPC interpreter has bit rotted, so we ask you to write a new one. Given a BAPC program and its input, return its output or “error” in case ‘D’ is applied to an empty list. Lists are represented as the character ‘[’ followed by a comma-separated list of integers followed by the character ‘]’. Notice that the input and output lists can be quite long.

Input

On the first line one positive number: the number of test cases, at most 100. After that per test case:

• one line with a string p (1 <= length(p) <= 100 000): a BAPC program, consisting of the characters ‘R’ and ‘D’.
• one line with an integer n (0 <= n <= 100 000): the number of elements in the input.
• one line with a list of n integers in the form [x1, ..., xn] (1 <= xi <= 100): the input list.

Output

Per test case:

• one line with the resulting integer list or “error” in case of an error.

Sample Input

4
RDD
4
[1,2,3,4]
DD
1
[42]
RRD
6
[1,1,2,3,5,8]
D
0
[]

Sample Output

[2,1]
error
[1,2,3,5,8]
error

思路：

题目只有R和D两种操作，即删除掉第一个元素和将数组反序。一开始想要用容器模拟删除和反序两种操作，

但是发现如果进行多次反序肯定会消耗大量的时间，因为反序的时候要对几乎所有的元素进行移动。

为了快速的将数组反序，可以考虑用双端的链表来作为数据结构，然后每次只需要交换头尾指针即可。

这里用了一个bool类型的reverse来记录数组是否是反序状态，每次反序只需reverse=!reverse即可，同时用

head，rear两个下边记录当前数组的首位下标，对元素的删除转化为下标的移动。一开始没有注意每一位数的范围

是1到100，全部都当做1位数处理结果WA，重新审题后加入函数get_an_integer（int index,int count）来读取输入中的

每个整数。

最后输出时判断数组是否是反序状态再进行相应输出。

#include<iostream>
using namespace std;

const int Max_length=100000;


string RD,input;
int intergers[Max_length];

void get_an_interger(int &index,int &count);

int main(){
    int testcases;
    cin>>testcases;
    while(testcases--){
        int num_of_data;
        cin>>RD>>num_of_data>>input;
        int head=0,rear=num_of_data-1;
        int len_of_RD=RD.length(),len_of_input=input.length();
        bool reverse=false,error_exist=false;
        int count=0;
        for(int i=0;i<len_of_input;i++){
            //scan the input to refine the integers and store them in array
            if(input[i]>='1'&&input[i]<='9')
                get_an_interger(i,count);
        }
        if(count!=num_of_data)
            cout<<"Wrong in get data"<<endl;
        for(int i=0;i<len_of_RD;i++){
            if(RD[i]=='R'){
                reverse=!reverse;
            }else{
                if(num_of_data==0){
                    cout<<"error"<<endl;
                    error_exist=true;
                    break;
                }else{
                    if(reverse)
                        rear--;
                    else
                        head++;
                    num_of_data--;
                }
            }
        }
        if(!error_exist){
            cout<<'[';
            if(num_of_data==0)
                cout<<']'<<endl;
            if(reverse){
                for(int i=0;i<num_of_data;i++){
                    if(i==num_of_data-1)
                        cout<<intergers[rear-i]<<']'<<endl;
                    else
                        cout<<intergers[rear-i]<<',';
                }
            }else{
                for(int i=0;i<num_of_data;i++){
                    if(i==num_of_data-1)
                        cout<<intergers[head+i]<<']'<<endl;
                    else
                        cout<<intergers[head+i]<<',';
                }
            }
        }
    }
    return 0;
}
void get_an_interger(int &index,int &count){
    int interger=input[index]-'0';
    index++;
    while(input[index]>='0'&&input[index]<='9'){
        interger=interger*10+input[index]-'0';
        index++;
    }
    intergers[count]=interger;
    count++;
}