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

#include <algorithm>
#include <iostream>
using namespace std;

int main() {
  int n, k;
  long long int dis[100][100];
  int s, a, b;
  long long int c;

  while (1) {
    cin >> n >> k;
    if (!n && !k)
      break;

    for (int i = 0; i < n; i++) {
      for (int j = 0; j < n; j++) {
        if (i == j)
          dis[i][j] = 0;
        else
          dis[i][j] = -1;
      }
    }

    for (int i = 0; i < k; i++) {
      cin >> s;
      if (s) {
        cin >> a >> b >> c;
        a--;
        b--;
        for (int j = 0; j < n; j++) {
          for (int l = 0; l < n; l++) {
            if (dis[j][a] >= 0 && dis[l][b] >= 0) {
              if ((dis[j][l] < 0) ||
                  (dis[j][l] > (dis[j][a] + c + dis[l][b]))) {
                dis[j][l] = dis[j][a] + c + dis[l][b];
                dis[l][j] = dis[j][a] + c + dis[l][b];
              }
            }
          }
        }
      } else {
        cin >> a >> b;
        cout << dis[a - 1][b - 1] << endl;
      }
    }
  }
}

Error: TLE

Fixed submission:

#include <iostream>
#include <vector>
using namespace std;

#define FOR(i, a) for (int i = 0; i < (int)(a); i++)
#define pb push_back
#define clr clear()
#define sz size()
typedef unsigned int ui;

class edge {
public:
  int b, e;
  int cost;

  void set(int s, int g, int c) {
    b = s;
    e = g;
    cost = c;
  }
};

class graph {
public:
  vector<int> n;
  vector<edge> e;

  void set(void) {
    n.clr;
    e.clr;
  }

  int Nexist(int a) {
    FOR(i, n.sz) {
      if (a == n[i])
        return i;
    }
    return -1;
  }

  int Eexist(int a, int b) {
    for (ui i = 0; i < e.sz; i++) {
      if (e[i].b == a && e[i].e == b)
        return i;
      if (e[i].b == b && e[i].e == a)
        return i;
    }
    return -1;
  }

  void Nadd(int a) {
    if (!n.sz)
      n.pb(a);
    else if (Nexist(a) < 0) {
      ui i = 0;
      while (n[i] < a && i < n.sz)
        i++;
      n.insert(n.begin() + i, a);
    }
  }

  void Eadd(edge a) {
    if (!e.sz)
      e.pb(a);
    else {
      ui i = 0;
      while (e[i].cost < a.cost && i < e.sz)
        i++;
      e.insert(e.begin() + i, a);
    }
    Nadd(a.b);
    Nadd(a.e);
  }

  graph prim(void) {
    graph res;

    res.set();

    if (!e.sz)
      return res;
    else {
      res.Eadd(e[0]);

      while (res.n.sz < n.sz) {
        FOR(i, e.sz) {
          if (res.Nexist(e[i].b) >= 0 && res.Nexist(e[i].e) < 0) {
            res.Eadd(e[i]);
            i = 0;
          } else if (res.Nexist(e[i].b) < 0 && res.Nexist(e[i].e) >= 0) {
            res.Eadd(e[i]);
            i = 0;
          }
        }
      }
      return res;
    }
  }

  int dijkstra(int s, int g) {
    vector<int> at;
    vector<edge> tmp;
    int min, min_num, min_pos;

    at.clr;
    tmp.clr;
    for (int i = 0; i < (int)e.sz; i++)
      tmp.pb(e[i]);
    for (int i = 0; i < (int)n.sz; i++) {
      if (i == s)
        at.push_back(0);
      else
        at.push_back(-1);
    }

    while (tmp.size()) {
      min = -1;
      min_num = -1;
      min_pos = -1;
      for (int i = 0; i < (int)n.sz; i++) {
        if (at[i] >= 0) {
          for (int j = 0; j < (int)tmp.sz; j++) {
            if (tmp[j].b == i) {
              if (min < 0 || min > tmp[j].cost + at[i]) {
                min = tmp[j].cost + at[i];
                min_num = tmp[j].e;
                min_pos = j;
              }
            } else if (tmp[j].e == i) {
              if (min < 0 || min > tmp[j].cost + at[i]) {
                min = tmp[j].cost + at[i];
                min_num = tmp[j].b;
                min_pos = j;
              }
            }
          }
        }
      }
      if (min < 0)
        return -1;
      if (at[min_num] < 0 || at[min_num] > min)
        at[min_num] = min;
      if (min_num == g)
        return min;
      tmp.erase(tmp.begin() + min_pos);
    }
    return -1;
  }

  vector<int> warshall_floyd(void) {
    vector<int> at;
    int tmp;
    for (ui i = 0; i < n.sz; i++) {
      for (ui j = 0; j < n.sz; j++) {
        if (i == j)
          at.pb(0);
        else {
          tmp = Eexist(i, j);
          if (tmp >= 0)
            at.pb(e[tmp].cost);
          else
            at.pb(-1);
        }
      }
    }

    for (ui k = 0; k < n.sz; k++) {
      for (ui i = 0; i < n.sz; i++) {
        for (ui j = 0; j < n.sz; j++) {
          if (at[i * n.sz + k] >= 0 && at[k * n.sz + j] >= 0) {
            if (at[i * n.sz + k] + at[k * n.sz + j] < at[i * n.sz + j] ||
                at[i * n.sz + j] < 0) {
              at[i * n.sz + j] = at[i * n.sz + k] + at[k * n.sz + j];
              at[j * n.sz + i] = at[i * n.sz + k] + at[k * n.sz + j];
            }
          }
        }
      }
    }
    return at;
  }
};

int main() {
  int n, k;
  int s, a, b, c, d, e;
  graph g;
  edge r;

  while (1) {
    cin >> n >> k;
    if (!n && !k)
      break;
    g.set();
    for (int i = 0; i < n; i++) {
      g.Nadd(i);
    }

    for (int i = 0; i < k; i++) {
      cin >> s;
      if (s) {
        cin >> c >> d >> e;
        r.set(c, d, e);
        g.Eadd(r);
      } else {
        cin >> a >> b;
        cout << g.dijkstra(a, b) << endl;
      }
    }
  }
}