struct Node {
    string val;
    Node* prev;
    Node* next;
};

class BrowserHistory {
    Node * List, *Current;
public:
    BrowserHistory(string homepage) {
        List = new Node();
        List->prev = List->next = nullptr;
        List->val = homepage;

        Current = List;
    }
    
    void visit(string url) {
        Node *Next = Current->next;
        if(Next == nullptr) {
            Current->next = new Node();
            Current->next->next = nullptr;
            Current->next->prev = Current;
        }else {
            Node *tmp = Next->next;
            Next->next = nullptr;
            // free
            while(tmp) {
                Node *node = tmp->next;
                delete tmp;
                tmp = node;
            }
        }
        Current->next->val = url;
        Current = Current->next;
    }
    
    string back(int steps) {
        string str = Current->val;
        Node *pre;
        while(steps-- && Current) {
            pre = Current;
            Current = Current->prev;
            if(Current) str = Current->val;
        }
        if(nullptr == Current) Current = pre;
        return str;

    }
    
    string forward(int steps) {
        string str = Current->val;
        Node *pre;
        while(steps-- && Current) {
            pre = Current;
            Current = Current->next;
            if(Current) str = Current->val;
        }
        if(nullptr == Current) Current = pre;
        return str;
    }
};

 now <---> now->child    ...    clast <---> next

class Solution {
    Node* dfs(Node* head) {
        Node *now = head;
        Node *last = nullptr;

        while(now) {
            Node *cLast;
            if(now->child) {
                cLast = dfs(now->child);
                Node *next = now->next;

                // now <--> cFirst   ... cLast <---> next;
                now->next = now->child;
                now->child = nullptr;
                now->next->prev = now;

                if(next) {
                    next->prev = cLast; 
                }
                cLast->next = next;
            }
            if(now->next == nullptr) {
                if(now->child) {
                    last = cLast;
                }else {
                    last = now;
                }
            }
            now = now->next;
        }
        return last;
    }
public:
    Node* flatten(Node* head) {
        if(head == nullptr) {
            return nullptr;
        }
        Node *last = dfs(head);
        last->next = nullptr;
        return head;
    }
};

class Solution {
    void dfs(Node *root, Node **minNode, Node **maxNode) {
        if(root == nullptr) {
            *minNode = nullptr;
            *maxNode = nullptr;
            return ;
        }
        Node *lminNode, *lmaxNode, *rminNode, *rmaxNode;
        if(root->left) {
            dfs(root->left, &lminNode, &lmaxNode);
            lmaxNode->right = root;
            root->left = lmaxNode;
            *minNode = lminNode;
        }else {
            *minNode = root;
        }

        if(root->right) {
            dfs(root->right, &rminNode, &rmaxNode);
            rminNode->left = root;
            root->right = rminNode;
            *maxNode = rmaxNode;
        }else {
            *maxNode = root;
        }
    }
public:
    Node* treeToDoublyList(Node* root) {
        if(root == nullptr) {
            return nullptr;
        }
        Node *minNode, *maxNode;
        dfs(root, &minNode, &maxNode);
        maxNode->right = minNode;
        minNode->left = maxNode;
        return minNode;
    }
};