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

#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <string>
using namespace std;

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

static const int dx[4] = {-1, 0, 1, 0}; //??£??\\???{}
static const int dy[4] = {0, -1, 0, 1};
static const int dir[4] = {'u', 'l', 'd', 'r'};

int MDT[N2][N2]; //???????????????????????¢

struct Puzzle {
  int p[N2], space, MD;
  string path;

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

Puzzle state;
int limit;
int path[LIMIT];

int getAllMD(Puzzle pz) {
  int sum = 0;
  for (int i = 0; i < N2; i++) {
    if (pz.p[i] == N2)
      continue;
    sum += MDT[i][pz.p[i] - 1]; // i????????¨????????????j???????????????
  }
  return sum;
}

bool dfs(int depth, int prev) {
  if (state.MD == 0)
    return true;
  if (depth + state.MD > limit)
    return false;
  int sx = state.space / N;
  int sy = state.space % N;
  Puzzle tmp;

  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;
    if (max(prev, r) - min(prev, r) == 2)
      continue; //??¢?´¢???????????£??????????????????????????????prev
    tmp = state;
    state.MD -= MDT[tx * N + ty][state.p[tx * N + ty] - 1];
    state.MD += MDT[sx * N + sy][state.p[tx * N + ty] - 1];
    swap(state.p[tx * N + ty], state.p[sx * N + sy]);
    state.space = tx * N + ty;
    if (dfs(depth + 1, r)) {
      path[depth] = r;
      return true;
    }
    state = tmp; //??±??????????????????
  }
  return false;
}

string ida(Puzzle in) {
  in.MD = getAllMD(in);

  for (limit = in.MD; limit < LIMIT; limit++) {
    state = in;
    if (dfs(0, -100)) {
      string ans = "";
      for (int i = 0; i < limit; i++)
        ans += dir[path[i]]; //????°???????limit??¨??????????????°?§??????????
      return ans;
    }
  }
  return "unsolvable";
}

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.p[i];
    if (!in.p[i]) {
      in.p[i] = N2; // isTarget?????????
      in.space = i;
    }
  }

  string ans = ida(in);
  cout << ans.size() << endl;

  return 0;
}

Error: MLE

Fixed submission:

#include <iostream>
#include <map>
#include <queue>
#include <string>
using namespace std;

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

static const int dx[4] = {-1, 0, 1, 0}; //??£??\\???{}
static const int dy[4] = {0, -1, 0, 1};
static const int dir[4] = {'u', 'l', 'd', 'r'};

struct Puzzle {
  int p[N2], space;
  string path;

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

bool isTarget(Puzzle u) {
  for (int i = 0; i < N2; i++) {
    if (u.p[i] != i + 1)
      return false;
  }
  return true;
}

string bfs(Puzzle s) {
  queue<Puzzle> Q;
  map<Puzzle, bool> V; //????????´???Puzzle??§????????????????????§ <
                       //????????????????????¨????????????

  Puzzle u, v;
  s.path = "";
  Q.push(s);
  V[s] = true;
  while (!Q.empty()) {
    u = Q.front();
    Q.pop();
    if (isTarget(u))
      return u.path;      //????????????????????????????????§??????
    int sx = u.space / N; // space??????
    int sy = u.space % N; // space??????
    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;
      swap(v.p[u.space], v.p[tx * N + ty]); // spaca??¨?§???????????????????
      v.space = tx * N + ty;
      if (!V[v]) { //???????????¢?´¢?????????????????????????????????????????????????????????
        V[v] = true;
        v.path += dir[r];
        Q.push(v);
      }
    }
  }
  return "unsolvable";
}

int main() {
  Puzzle in;
  for (int i = 0; i < N2; i++) {
    cin >> in.p[i];
    if (!in.p[i]) {
      in.p[i] = N2; // isTarget?????????
      in.space = i;
    }
  }

  string ans = bfs(in);
  cout << ans.size() << endl;

  return 0;
}