Problem:
Doubly Linked List

Your task is to implement a double linked list.

Write a program which performs the following operations:

insert x: insert an element with key x into the front of the list.

delete x: delete the first element which has the key of x from the list. If there is not such element, you need not do anything.

deleteFirst: delete the first element from the list.

deleteLast: delete the last element from the list.

Input

The input is given in the following format:

n

command1

command2

...

commandn

In the first line, the number of operations n is given. In the following n lines, the above mentioned operations are given in the following format:

insert x

delete x

deleteFirst

deleteLast

Output

Print all the element (key) in the list after the given operations. Two consequtive keys should be separated by a single space.

Constraints

The number of operations ≤ 2,000,000

The number of delete operations ≤ 20

0 ≤ value of a key ≤ 109

The number of elements in the list does not exceed 106

For a delete, deleteFirst or deleteLast operation, there is at least one element in the list.

Sample Input 1

7
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5

Sample Output 1

6 1 2

Sample Input 2

9
insert 5
insert 2
insert 3
insert 1
delete 3
insert 6
delete 5
deleteFirst
deleteLast

Sample Output 2

1

Solution in JAVA (judge verdict: Memory Limit Exceeded)

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        Main main = new Main();
        main.solv();
    }
    
    private void solv() {
        Scanner input = new Scanner(System.in, System.getProperty("file.encoding"));
        int n = input.nextInt();
        DoublyLinkedList<Long> list = new DoublyLinkedList<Long>();
        while (n-- > 0) {
            String s = input.next();
            if ("insert".equals(s)) {
                long x = input.nextLong();
                list.insert(x);
            } else if ("delete".equals(s)) {
                long x = input.nextLong();
                list.delete(x);
            } else if ("deleteFirst".equals(s)) {
                list.deleteFirst();
            } else if ("deleteLast".equals(s)) {
                list.deleteLast();
            }
        }
        print(list.toArray());
    }
    
    private void print(Object[] xs) {
        StringBuilder sb = new StringBuilder();
        for (Object x : xs) sb.append(x.toString()).append(' ');
        System.out.println(sb.toString().trim());
    }
    
    private static class DoublyLinkedList<T> {
        Object[] list = new Object[0];
        int size = 0;
        
        public void insert(T x) {
            size += 1;
            Object[] newList;
            if (list.length < size) {
                newList = new Object[size*2];
            } else {
                newList = list;
            }
            for (int i = size - 1; 0 < i; i--) {
                newList[i] = list[i-1];
            }
            newList[0] = x;
            list = newList;
        }
        public void delete(T x) {
            if (size <= 0) return;
            int index;
            for (index = 0; index < size; index++) {
                if (list[index].equals(x)) {
                    break;
                }
            }
            if (index >= size) return;
            for (int i = index; i < size - 1; i++) {
                list[i] = list[i+1];
            }
            size -= 1;
        }
        public void deleteFirst() {
            if (size <= 0) return;
            for (int i = 0; i < size - 1; i++) {
                list[i] = list[i+1];
            }
            size -= 1;
        }
        public void deleteLast() {
            if (size <= 0) return;
            size -= 1;
        }
        public Object[] toArray() {
            return Arrays.copyOf(list, size);
        }
    }
}