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

#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
/*const int num = 16, ud[] = { -1, 0, 1, 0 }, lr[] = { 0, -1, 0, 1 }, nd = 4;
//const char wa[] = { 'u', 'l', 'd', 'r' };
int md[num][num];
int lm;
struct puzzle {
        int sp, p[num], mdp, cost;
        //string way;
        bool operator < (const puzzle &pu) const {
                for (int i = 0; i < num; i++) {
                        if (p[i] == pu.p[i]) continue;
                        return p[i] < pu.p[i];
                }
                return false;
        }
};
struct state {
        puzzle pu;
        //int es = pu.mdp + pu.cost;
        bool operator < (const state &s) const {
                return pu.mdp + pu.cost > s.pu.mdp + s.pu.cost;
                //return es > s.es;
        }
};
puzzle pu;
int astar(puzzle pz) {
        priority_queue<state> pq;
        map<puzzle, bool> m;
        state s;
        s.pu = pz;
        //s.es = pu.mdp;
        pq.push(s);
        state st, st1;
        puzzle p;
        int tx, ty, ns;
        while (!pq.empty()) {
                st = pq.top(); pq.pop();
                p = st.pu;
                //cout << "cost" <<  p.cost << endl;
                //cout << "mfp" << p.mdp << endl;
                if (!p.mdp) return p.cost;
                puzzle tmp;
                m[p] = true;
                int sx = p.sp / nd;
                int sy = p.sp % nd;
                for (int r = 0; r < nd; r++) {
                        tx = sx + ud[r];
                        ty = sy + lr[r];
                        tmp = p;
                        if (tx >= nd || tx < 0 || ty >= nd || ty < 0) continue;
                        ns = tx * nd + ty;
                        tmp.mdp = p.mdp - md[ns][p.p[ns] - 1] + md[sx*nd +
sy][p.p[ns] - 1]; tmp.sp = ns; swap(tmp.p[ns], tmp.p[sx * nd + sy]); tmp.cost =
p.cost + 1;
                        //cout << tmp.cost << endl;
                        if (!m[tmp]) {
                                st1.pu = tmp;
                                //st1.es = tmp.cost + tmp.mdp;
                                pq.push(st1);
                        }
                }
        }
}

/*int astar() {
        priority_queue<state> pq;
        map<puzzle, bool> m;
        state s;
        s.pu = pu;
        //s.es = pu.mdp;
        pq.push(s);
        state st, st1;
        puzzle p;
        int tx, ty, ns;
        while (!pq.empty()) {
                st = pq.top(); pq.pop();
                p = st.pu;
                //cout << "cost" <<  p.cost << endl;
                //cout << "mfp" << p.mdp << endl;
                if (!p.mdp) return p.cost;
                puzzle tmp;
                m[p] = true;
                int sx = p.sp / nd;
                int sy = p.sp % nd;
                for (int r = 0; r < nd; r++) {
                        tx = sx + ud[r];
                        ty = sy + lr[r];
                        tmp = p;
                        if (tx >= nd || tx < 0 || ty >= nd || ty < 0) continue;
                        ns = tx * nd + ty;
                        tmp.mdp = p.mdp - md[ns][p.p[ns] - 1] + md[sx*nd +
sy][p.p[ns] - 1]; tmp.sp = ns; swap(tmp.p[ns], tmp.p[sx * nd + sy]); tmp.cost =
p.cost + 1;
                        //cout << tmp.cost << endl;
                        if (!m[tmp]) {
                                st1.pu = tmp;
                                //st1.es = tmp.cost + tmp.mdp;
                                pq.push(st1);
                        }
                }
        }
}*/

/*int main() {
        int sum = 0;
        for (int i = 0; i < num; i++) {
                cin >> pu.p[i];
                if (!pu.p[i])  pu.sp = i;
        }
        for (int i = 0; i < num; i++)
                for (int j = 0; j < num; j++)
                        md[i][j] = abs(i / nd - j / nd) + abs(i%nd - j%nd);
        for (int i = 0; i < num; i++) {
                if (pu.p[i] == 0) continue;
                sum += md[i][pu.p[i] - 1];
        }
        pu.mdp = sum;
        pu.cost = 0;
        cout << astar(pu) << endl;
        return 0;
}*/
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
using namespace std;

static const int N = 4;
static const int N2 = 16;

static const int dx[4] = {0, -1, 0, 1};
static const int dy[4] = {1, 0, -1, 0};
static const int dir[4] = {'r', 'u', 'l', 'd'};
int MDT[N2][N2];

struct Puzzle {
  int f[N2], space, MD;
  int cost;

  bool operator<(const Puzzle &p) const {
    for (int i = 0; i < N2; ++i) {
      if (f[i] == p.f[i])
        continue;
      return f[i] < p.f[i];
    }
    return false;
  }
};

struct State {
  Puzzle puzzle;
  int estimated;
  bool operator<(const State &s) const { return estimated > s.estimated; }
};

int getALLMD(Puzzle pz) {
  int sum = 0;
  for (int i = 0; i < N2; ++i) {
    if (pz.f[i] == N2)
      continue;
    sum += MDT[i][pz.f[i] - 1];
  }
  return sum;
}

int astar(Puzzle s) {
  priority_queue<State> PQ;
  s.MD = getALLMD(s);
  s.cost = 0;
  map<Puzzle, bool> V;
  Puzzle u, v;
  State initial;
  initial.puzzle = s;
  initial.estimated = getALLMD(s);
  PQ.push(initial);

  while (!PQ.empty()) {
    State st = PQ.top();
    PQ.pop();
    u = st.puzzle;

    if (u.MD == 0)
      return u.cost;
    V[u] = true;

    int sx = u.space / N;
    int sy = u.space % N;

    for (int r = 0; r < 4; ++r) {
      int tx = sx + dx[r];
      int ty = sy + dy[r];
      if (tx < 0 || ty < 0 || tx >= N || ty >= N)
        continue;
      v = u;

      v.MD -= MDT[tx * N + ty][v.f[tx * N + ty] - 1];
      v.MD += MDT[sx * N + sy][v.f[tx * N + ty] - 1];

      swap(v.f[sx * N + sy], v.f[tx * N + ty]);
      v.space = tx * N + ty;
      if (!V[v]) {
        v.cost++;
        State news;
        news.puzzle = v;
        news.estimated = v.cost + v.MD;
        PQ.push(news);
      }
    }
  }
  return -1;
}

int main() {
  for (int i = 0; i < N2; ++i) {
    for (int j = 0; j < N2; ++j) {
      MDT[i][j] = abs(i / N - j / N) + abs(i % N - j % N);
    }
  }
  Puzzle in;

  for (int i = 0; i < N2; ++i) {
    cin >> in.f[i];
    if (in.f[i] == 0) {
      in.f[i] = N2;
      in.space = i;
    }
  }
  cout << astar(in) << endl;
  return 0;
}

Error: MLE

Fixed submission:

#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
const int num = 16, ud[] = {-1, 0, 1, 0}, lr[] = {0, -1, 0, 1}, nd = 4;
// const char wa[] = { 'u', 'l', 'd', 'r' };
int md[num][num];
int lm;
struct puzzle {
  int sp, p[num], mdp, cost;
  // string way;
  bool operator<(const puzzle &pu) const {
    for (int i = 0; i < num; i++) {
      if (p[i] == pu.p[i])
        continue;
      return p[i] < pu.p[i];
    }
    return false;
  }
};
struct state {
  puzzle pu;
  // int es = pu.mdp + pu.cost;
  bool operator<(const state &s) const {
    return pu.mdp + pu.cost > s.pu.mdp + s.pu.cost;
    // return es > s.es;
  }
};
puzzle pu;
int astar(puzzle pz) {
  priority_queue<state> pq;
  map<puzzle, bool> m;
  state s;
  s.pu = pz;
  // s.es = pu.mdp;
  pq.push(s);
  state st, st1;
  puzzle p;
  int tx, ty, ns;
  while (!pq.empty()) {
    st = pq.top();
    pq.pop();
    p = st.pu;
    // cout << "cost" <<  p.cost << endl;
    // cout << "mfp" << p.mdp << endl;
    if (!p.mdp)
      return p.cost;
    puzzle tmp;
    m[p] = true;
    int sx = p.sp / nd;
    int sy = p.sp % nd;
    for (int r = 0; r < nd; r++) {
      tx = sx + ud[r];
      ty = sy + lr[r];
      tmp = p;
      if (tx >= nd || tx < 0 || ty >= nd || ty < 0)
        continue;
      ns = tx * nd + ty;
      tmp.mdp = p.mdp - md[ns][p.p[ns] - 1] + md[sx * nd + sy][p.p[ns] - 1];
      tmp.sp = ns;
      swap(tmp.p[ns], tmp.p[sx * nd + sy]);
      tmp.cost = p.cost + 1;
      // cout << tmp.cost << endl;
      if (!m[tmp]) {
        st1.pu = tmp;
        // st1.es = tmp.cost + tmp.mdp;
        pq.push(st1);
      }
    }
  }
}

/*int astar() {
        priority_queue<state> pq;
        map<puzzle, bool> m;
        state s;
        s.pu = pu;
        //s.es = pu.mdp;
        pq.push(s);
        state st, st1;
        puzzle p;
        int tx, ty, ns;
        while (!pq.empty()) {
                st = pq.top(); pq.pop();
                p = st.pu;
                //cout << "cost" <<  p.cost << endl;
                //cout << "mfp" << p.mdp << endl;
                if (!p.mdp) return p.cost;
                puzzle tmp;
                m[p] = true;
                int sx = p.sp / nd;
                int sy = p.sp % nd;
                for (int r = 0; r < nd; r++) {
                        tx = sx + ud[r];
                        ty = sy + lr[r];
                        tmp = p;
                        if (tx >= nd || tx < 0 || ty >= nd || ty < 0) continue;
                        ns = tx * nd + ty;
                        tmp.mdp = p.mdp - md[ns][p.p[ns] - 1] + md[sx*nd +
sy][p.p[ns] - 1]; tmp.sp = ns; swap(tmp.p[ns], tmp.p[sx * nd + sy]); tmp.cost =
p.cost + 1;
                        //cout << tmp.cost << endl;
                        if (!m[tmp]) {
                                st1.pu = tmp;
                                //st1.es = tmp.cost + tmp.mdp;
                                pq.push(st1);
                        }
                }
        }
}*/

int main() {
  int sum = 0;
  for (int i = 0; i < num; i++) {
    cin >> pu.p[i];
    if (!pu.p[i])
      pu.sp = i;
  }
  for (int i = 0; i < num; i++)
    for (int j = 0; j < num; j++)
      md[i][j] = abs(i / nd - j / nd) + abs(i % nd - j % nd);
  for (int i = 0; i < num; i++) {
    if (pu.p[i] == 0)
      continue;
    sum += md[i][pu.p[i] - 1];
  }
  pu.mdp = sum;
  pu.cost = 0;
  cout << astar(pu) << endl;
  return 0;
}