Problem p00223 (C++) — buggy submission, verdict: Memory Limit Exceeded

#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <vector>
#define all(n) n.begin(), n.end()
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define PPPinsert(a, b, c, d, e, f) PPP(PP(P(a, b), P(c, d)), P(e, f))
#define F first
#define S second
#define pb push_back
#define INF (1 << 27)
#define EPS 1e-10
#define equals(a, b) (fabs((a) - (b)) < EPS)

using namespace std;
typedef pair<int, int> P;
typedef pair<P, P> PP;
typedef pair<PP, P> PPP;
typedef unsigned long long ull;
typedef long long ll;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};

int rdir(int i) {
  switch (i) {
  case 0:
    return 2;
  case 1:
    return 3;
  case 2:
    return 0;
  case 3:
    return 1;
  default:
    return -1;
  }
}

class Pox {
private:
  PPP element;

public:
  Pox() {}
  Pox(PPP element) : element(element) {}

  PPP get() { return element; }

  void print() {
    cout << "takayuki " << element.F.F.F << "," << element.F.F.S
         << " : kazuyuki " << element.F.S.F << " : " << element.F.S.S
         << " : cost " << element.S.F << " : distance " << element.S.S << endl;
  }
};

struct Comparator_X {
  bool operator()(Pox &a, Pox &b) {
    if (a.get().S.F != a.get().S.F)
      return a.get().S.F < b.get().S.F;
    return a.get().S.S < b.get().S.S;
  }
};

int main() {
  int h, w;
  while (true) {

    cin >> w >> h;
    if (w + h == 0)
      break;
    P takayuki, kazuyuki;
    cin >> takayuki.F >> takayuki.S;
    cin >> kazuyuki.F >> kazuyuki.S;
    takayuki.F--, takayuki.S--, kazuyuki.F--, kazuyuki.S--;
    PPP first_element; // PPP(PP(P(takayuki-x,takayuki-y),P(kazuyuki-x,kazuyuki-y)),P(cost,distance))
    first_element =
        PPPinsert(takayuki.F, takayuki.S, kazuyuki.F, kazuyuki.S, 0,
                  abs(takayuki.F - kazuyuki.F) + abs(takayuki.S - kazuyuki.S));

    bool bmap[h][w];
    // bool used_t[h][w],used_h[h][w];
    bool used_X[h][w][h][w];
    rep(i, h) {
      rep(j, w) {
        cin >> bmap[i][j];
        // used_t[i][j] = false,used_h[i][j] = false;
        rep(k, h) rep(l, w) used_X[i][j][k][l] = false;
      }
    }

    if (takayuki.F == kazuyuki.F && takayuki.S == kazuyuki.S) {
      cout << 0 << endl;
      continue;
    }

    // used_t[takayuki.S][takayuki.F] = used_h[kazuyuki.S][kazuyuki.F] = true;
    used_X[takayuki.S][takayuki.F][kazuyuki.S][kazuyuki.F] = true;

    // priority_queue<Pox,vector<Pox>,Comparator_X> pq;
    Pox fst = Pox(first_element);
    // pq.push(fst);
    deque<Pox> deq;
    deq.push_front(fst);

    bool fin = false;

    int men = INF;

    while (!deq.empty()) {
      // Pox pox = pq.top(); pq.pop();
      // pox.print();
      Pox pox = deq.front();
      deq.pop_front();
      if (pox.get().S.F >= men)
        continue;

      for (int i = 0; i < 4; i++) {
        int t_nx, t_ny, h_nx, h_ny;
        t_nx = pox.get().F.F.F + dx[i], t_ny = pox.get().F.F.S + dy[i];
        h_nx = pox.get().F.S.F + dx[rdir(i)],
        h_ny = pox.get().F.S.S + dy[rdir(i)];

        if ((bmap[t_ny][t_nx] ||
             !(0 <= t_nx && t_nx < w && 0 <= t_ny && t_ny < h)) &&
            (bmap[h_ny][h_nx] ||
             !(0 <= h_nx && h_nx < w && 0 <= h_ny && h_ny < h)))
          continue;

        if (!(0 <= t_nx && t_nx < w && 0 <= t_ny && t_ny < h) ||
            bmap[t_ny][t_nx])
          t_nx = pox.get().F.F.F, t_ny = pox.get().F.F.S;

        if (!(0 <= h_nx && h_nx < w && 0 <= h_ny && h_ny < h) ||
            bmap[h_ny][h_nx])
          h_nx = pox.get().F.S.F, h_ny = pox.get().F.S.S;

        if (used_X[t_ny][t_nx][h_ny][h_nx])
          continue;

        if (t_nx == h_nx && t_ny == h_ny) {
          // cout << pox.get().S.F+1 << endl;
          men = min(men, pox.get().S.F + 1);
          fin = true;
          break;
        }

        used_X[t_ny][t_nx][h_ny][h_nx] = true;
        Pox inpox = Pox(PPPinsert(t_nx, t_ny, h_nx, h_ny, pox.get().S.F + 1,
                                  abs(t_nx - h_nx) + abs(t_ny - h_ny)));
        // pq.push(inpox);
        if (deq.front().get().S.F >= inpox.get().S.F) {
          deq.push_front(inpox);
        } else {
          deq.push_back(inpox);
        }
      }
      // if(fin)break;
    }

    if (!fin)
      cout << "NA" << endl;
    else
      cout << men << endl;
  }
  return 0;
}

Error: MLE

Fixed submission:

#include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <vector>
#define all(n) n.begin(), n.end()
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define PPPinsert(a, b, c, d, e, f) PPP(PP(P(a, b), P(c, d)), P(e, f))
#define F first
#define S second
#define pb push_back
#define INF (1 << 27)
#define EPS 1e-10
#define equals(a, b) (fabs((a) - (b)) < EPS)

using namespace std;
typedef pair<int, int> P;
typedef pair<P, P> PP;
typedef pair<PP, P> PPP;
typedef unsigned long long ull;
typedef long long ll;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};

int rdir(int i) {
  switch (i) {
  case 0:
    return 2;
  case 1:
    return 3;
  case 2:
    return 0;
  case 3:
    return 1;
  default:
    return -1;
  }
}

class Pox {
private:
  PPP element;

public:
  Pox() {}
  Pox(PPP element) : element(element) {}

  PPP get() { return element; }

  void print() {
    cout << "takayuki " << element.F.F.F << "," << element.F.F.S
         << " : kazuyuki " << element.F.S.F << " : " << element.F.S.S
         << " : cost " << element.S.F << " : distance " << element.S.S << endl;
  }
};

struct Comparator_X {
  bool operator()(Pox &a, Pox &b) {
    if (a.get().S.F != a.get().S.F)
      return a.get().S.F < b.get().S.F;
    return a.get().S.S < b.get().S.S;
  }
};

int main() {
  int h, w;
  while (true) {
    cin >> w >> h;
    if (w + h == 0)
      break;
    P takayuki, kazuyuki;
    cin >> takayuki.F >> takayuki.S;
    cin >> kazuyuki.F >> kazuyuki.S;

    PPP first_element; // PPP(PP(P(takayuki-x,takayuki-y),P(kazuyuki-x,kazuyuki-y)),P(cost,distance))
    first_element =
        PPPinsert(takayuki.F, takayuki.S, kazuyuki.F, kazuyuki.S, 0,
                  abs(takayuki.F - kazuyuki.F) + abs(takayuki.S - kazuyuki.S));

    bool bmap[h][w];
    bool used_t[h][w], used_h[h][w];
    rep(i, h) {
      rep(j, w) {
        cin >> bmap[i][j];
        used_t[i][j] = false, used_h[i][j] = false;
      }
    }

    used_t[takayuki.S][takayuki.F] = used_h[kazuyuki.S][kazuyuki.F] = true;

    priority_queue<Pox, vector<Pox>, Comparator_X> pq;
    pq.push(first_element);

    bool fin = false;

    while (!pq.empty()) {
      Pox pox = pq.top();
      pq.pop();

      for (int i = 0; i < 4; i++) {
        int t_nx, t_ny, h_nx, h_ny;
        t_nx = pox.get().F.F.F + dx[i], t_ny = pox.get().F.F.S + dy[i];
        h_nx = pox.get().F.S.F + dx[rdir(i)],
        h_ny = pox.get().F.S.S + dy[rdir(i)];

        if (used_t[t_ny][t_ny] && used_h[h_ny][h_nx])
          continue;

        if (!(0 <= t_nx && t_nx < w && 0 <= t_ny && t_ny < h) ||
            bmap[t_ny][t_nx])
          continue;

        if (!(0 <= h_nx && h_nx < w && 0 <= h_ny && h_ny < h) ||
            bmap[h_ny][h_nx])
          continue;

        if (t_nx == h_nx && t_ny == h_ny) {
          cout << pox.get().S.F + 1 << endl;
          fin = true;
          break;
        }

        used_h[h_ny][h_nx] = used_t[t_ny][t_nx] = true;
        Pox inpox = Pox(PPPinsert(t_nx, t_ny, h_nx, h_ny, pox.get().S.F + 1,
                                  abs(t_nx - h_nx) + abs(t_ny - h_ny)));
        pq.push(inpox);
      }
    }

    if (!fin)
      cout << "NA" << endl;
  }
  return 0;
}