SHARE
TWEET

Untitled

a guest Apr 24th, 2019 60 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <bits/stdc++.h>
  2. using namespace std;
  3.  
  4. struct Node {
  5.     string name;
  6.     Node *nextPtr, *prevPtr;
  7.     Node(string name) {
  8.         this->name = name;
  9.         nextPtr = nullptr;
  10.         prevPtr = nullptr;
  11.     }
  12. };
  13.  
  14. int main() {
  15.     Node *root = new Node("NTHU");
  16.     Node *node = new Node("TSMC");
  17.     root->nextPtr = root->prevPtr = node;
  18.     node->nextPtr = node->prevPtr = root;
  19.  
  20.     int test;
  21.     cin >> test;
  22.     bool reverse_tag = false;
  23.     while (test--) {
  24.         string op;
  25.         cin >> op;
  26.         if (op == "INSERT") {
  27.             string src, dst, name;
  28.             int k;
  29.             cin >> src >> dst >> name >> k;
  30.             Node *cur = root;
  31.             bool ok = true, success = false;
  32.             while (ok || cur != root) {
  33.                 ok = false;
  34.                 if (!reverse_tag) {
  35.                     if (cur->name == src && cur->nextPtr->name == dst) {
  36.                         Node *nxt = cur->nextPtr;
  37.                         Node *newNode = new Node(name);
  38.                         cur->nextPtr = newNode;
  39.                         newNode->nextPtr = nxt;
  40.                         nxt->prevPtr = newNode;
  41.                         newNode->prevPtr = cur;
  42.                         success = true;
  43.                     }
  44.                     cur = cur->nextPtr;
  45.                 } else {
  46.                     if (cur->name == src && cur->prevPtr->name == dst) {
  47.                         Node *pre = cur->prevPtr;
  48.                         Node *newNode = new Node(name);
  49.                         cur->prevPtr = newNode;
  50.                         newNode->prevPtr = pre;
  51.                         pre->nextPtr = newNode;
  52.                         newNode->nextPtr = cur;
  53.                         success = true;
  54.                     }
  55.                     cur = cur->prevPtr;
  56.                 }
  57.             }
  58.             if (success && k == 2) {
  59.                 cur = root;
  60.                 ok = true;
  61.                 while (ok || cur != root) {
  62.                     ok = false;
  63.                     if (!reverse_tag) {
  64.                         if (cur->name == dst && cur->nextPtr->name == src) {
  65.                             Node *nxt = cur->nextPtr;
  66.                             Node *newNode = new Node(name);
  67.                             cur->nextPtr = newNode;
  68.                             newNode->nextPtr = nxt;
  69.                             nxt->prevPtr = newNode;
  70.                             newNode->prevPtr = cur;
  71.                         }
  72.                         cur = cur->nextPtr;
  73.                     } else {
  74.                         if (cur->name == dst && cur->prevPtr->name == src) {
  75.                             Node *pre = cur->prevPtr;
  76.                             Node *newNode = new Node(name);
  77.                             cur->prevPtr = newNode;
  78.                             newNode->prevPtr = pre;
  79.                             pre->nextPtr = newNode;
  80.                             newNode->nextPtr = cur;
  81.                         }
  82.                         cur = cur->prevPtr;
  83.                     }
  84.                 }
  85.             }
  86.         } else if (op == "DELETE") {
  87.             string name;
  88.             cin >> name;
  89.             Node *cur = root;
  90.             bool ok = true;
  91.             while (ok || cur != root) {
  92.                 ok = false;
  93.                 if (!reverse_tag) {
  94.                     if (cur->nextPtr->name == name) {
  95.                         Node *to = cur->nextPtr->nextPtr;
  96.                         if (cur->name == to->name)
  97.                             to = to->nextPtr;
  98.                         cur->nextPtr = to;
  99.                         to->prevPtr = cur;
  100.                     }
  101.                     cur = cur->nextPtr;
  102.                 } else {
  103.                     if (cur->prevPtr->name == name) {
  104.                         Node *to = cur->prevPtr->prevPtr;
  105.                         if (cur->name == to->name)
  106.                             to = to->prevPtr;
  107.                         cur->prevPtr = to;
  108.                         to->nextPtr = cur;
  109.                     }
  110.                     cur = cur->prevPtr;
  111.                 }
  112.             }
  113.         } else if (op == "REVERSE") {
  114.             reverse_tag ^= 1;
  115.         }
  116.     }
  117.     bool ok = true;
  118.     Node *cur = root;
  119.     while (ok || cur != root) {
  120.         ok = false;
  121.         cout << cur->name << "->";
  122.         if (!reverse_tag)
  123.             cur = cur->nextPtr;
  124.         else
  125.             cur = cur->prevPtr;
  126.     }
  127.     cout << cur->name << endl;
  128.     return 0;
  129. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top