Problem p02289 (C++) — buggy submission, verdict: Time Limit Exceeded

#include <iostream>

using namespace std;

struct Heap {
  int *H;
  int size;
  Heap() {
    this->H = new int[2000000];
    this->size = 0;
  }
  int siz() { return this->size; }
  void swap(int a, int b) {
    int aux = this->H[b];
    this->H[b] = this->H[a];
    this->H[a] = aux;
  }
  void Iheapify(int i) {
    int f;
    if (i > 0) {
      f = i / 2;
      if (i % 2 == 0 && f > 0) {
        f -= 1;
      }
      if (this->H[i] > this->H[f]) {
        swap(i, f);
        Iheapify(f);
      }
    }
  }

  void Rheapify(int i) {
    int l, r, m;
    m = i;
    l = (2 * i) + 1;
    r = (2 * i) + 2;
    if (l < this->size && this->H[l] >= this->H[m]) {
      m = l;
    }
    if (r < this->size && this->H[r] >= this->H[m]) {
      m = r;
    }
    if (m != i) {
      swap(i, m);
      Rheapify(m);
    }
  }
  void insert(int k) {
    this->H[size] = k;
    Iheapify(size);
    this->size++;
  }
  int extract() {
    int temp = this->H[0];
    swap(0, size - 1);
    this->size--;
    Rheapify(0);
    return temp;
  }

  void print() {
    for (int i = 1; i <= size; i++) {
      cout << H[i] << endl;
    }
  }
};

int main() {
  string s = "";
  int k;
  bool b = true;
  Heap *heap = new Heap();
  while (b) {
    cin >> s;
    if (s == "end") {
      break;
    }
    if (s[0] == 'i') {
      cin >> k;
      heap->insert(k);
    } else {
      if (heap->siz() > 0) {
        k = heap->extract();
        cout << k << endl;
      }
    }
  }
  return 0;
}


Error: TLE

Fixed submission:


#include <iostream>
#include <iterator>
#include <math.h>
#include <sstream>
#include <string>
#include <vector>

using namespace std;

struct node {
  int key;
  int altura;
  int tamanho;
  node *direita;
  node *esquerda;
};

void swap(int *a, int *b) {
  int t = *a;
  *a = *b;
  *b = t;
}

int max(int a, int b) { return (a > b) ? a : b; }

node *criarNode(int val) {

  node *temp = new node();
  temp->key = val;
  temp->tamanho = 1;
  temp->altura = 0;
  temp->esquerda = NULL;
  temp->direita = NULL;

  return temp;
}

int Tamanho(node *n) {

  if (n == NULL) {
    return 0;
  } else {
    return n->tamanho;
  }
}

int Altura(node *t) {

  if (t == NULL) {
    return -1;
  } else {
    return t->altura;
  }
}

void updateAltura(node *t) {

  t->altura = max(Altura(t->esquerda), Altura(t->direita)) + 1;
  t->tamanho = Tamanho(t->esquerda) + Tamanho(t->direita) + 1;
}

node *inserir(node *n, int key) {
  if (n == NULL) {
    n = criarNode(key);
    return n;
  }
  if (n->esquerda == NULL ||
      Tamanho(n->esquerda) < int(pow(2, Altura(n->esquerda) + 1)) - 1 ||
      Tamanho(n->direita) == Tamanho(n->esquerda)) {
    n->esquerda = inserir(n->esquerda, key);
  } else {
    n->direita = inserir(n->direita, key);
  }

  if ((n->esquerda != NULL && n->esquerda->key > n->key) ||
      (n->direita != NULL && n->direita->key > n->key)) {
    if (n->esquerda == NULL) {
      swap(n->key, n->direita->key);
    } else if (n->direita == NULL) {
      swap(n->key, n->esquerda->key);
    } else {
      if (n->esquerda->key > n->direita->key) {
        swap(n->key, n->esquerda->key);
      } else {
        swap(n->key, n->direita->key);
      }
    }
  }

  updateAltura(n);
  return n;
}

void heapify(node *n) {

  if (!n) {
    return;
  }

  while ((n->esquerda != NULL && n->esquerda->key > n->key) ||
         (n->direita != NULL && n->direita->key > n->key)) {
    if (n->esquerda == NULL) {
      swap(n->key, n->direita->key);
      n = n->direita;
    } else if (n->direita == NULL) {
      swap(n->key, n->esquerda->key);
      n = n->esquerda;
    } else {
      if (n->esquerda->key > n->direita->key) {
        swap(n->key, n->esquerda->key);
        n = n->esquerda;
      } else {
        swap(n->key, n->direita->key);
        n = n->direita;
      }
    }
  }
}

int counter = 0;

node *remover(node *n, node *root) {

  if (n == NULL) {
    return NULL;
  }

  if (n->esquerda == NULL && n->direita == NULL) {
    swap(root->key, n->key);
    delete n;
    return NULL;
  } else if (Altura(n->esquerda) > Altura(n->direita)) {
    counter++;
    n->esquerda = remover(n->esquerda, root);
    if (counter != 0) {
      counter--;
      updateAltura(n);
      return n;
    }

  } else {
    counter++;
    n->direita = remover(n->direita, root);
    if (counter != 0) {
      counter--;
      updateAltura(n);
      return n;
    }
  }

  updateAltura(n);

  return root;
}

int top(node *root) {
  heapify(root);
  if (root == NULL) {
    return 0;
  } else {
    return root->key;
  }
}

void extractMax(node **heap) {
  *heap = remover(*heap, *heap);
  heapify(*heap);
}

int main() {
  std::ios_base::sync_with_stdio(false);
  cin.tie(nullptr);

  node *heap = NULL;
  std::string x;

  while (std::cin) {
    getline(cin, x);
    if (x[0] == 'i') {

      std::istringstream buf(x);
      std::istream_iterator<std::string> beg(buf), end;
      std::vector<std::string> tokens(beg, end);
      int value = atoi(tokens[1].c_str());

      heap = inserir(heap, value);
    } else if (x[0] == 'e' && x[1] == 'x') {
      std::cout << top(heap) << std::endl;
      extractMax(&heap);
    } else {
      break;
    }
  }
  return 0;
}