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

#include <bits/stdc++.h>

#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = int(a); i < int(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)

#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rrep(...) _overload(__VA_ARGS__, _rrange, _rrep, )(__VA_ARGS__)

#define _all(arg) begin(arg), end(arg)
#define uniq(arg) sort(_all(arg)), (arg).erase(unique(_all(arg)), end(arg))
#define getidx(ary, key) lower_bound(_all(ary), key) - begin(ary)
#define clr(a, b) memset((a), (b), sizeof(a))
#define bit(n) (1LL << (n))
#define popcount(n) (__builtin_popcountll(n))

using namespace std;

template <class T> bool chmax(T &a, const T &b) {
  return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
  return (b < a) ? (a = b, 1) : 0;
}

using ll = long long;
using R = long double;
const R EPS = 1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R &r) { return (r > EPS) - (r < -EPS); }
inline R sq(R x) { return sqrt(max(x, 0.0L)); }

const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};

// Problem Specific Parameter:

int board[10][10];
using state = tuple<int, int, int>;
vector<state> ans;

void dfs(int rest) {
  if (rest == 0) {
    bool ng = false;
    ;
    rep(i, 10) rep(j, 10) ng |= board[i][j];
    if (ng == false) {
      for (auto &it : ans) {
        int y, x, s;
        tie(y, x, s) = it;
        cout << x << " " << y << " " << s << endl;
      }
      exit(0);
    }
    return;
  }

  rep(i, 10) rep(j, 10) {
    if (board[i][j] == 0)
      continue;

    // small
    {
      int num = 0;
      int ci = i + 1, cj = j;
      rep(a, 10) rep(b, 10) if (abs(a - ci) + abs(b - cj) <= 1) num +=
          min(1, board[a][b]);

      if (num == 5) {
        rep(a, 10) rep(b, 10) if (abs(a - ci) + abs(b - cj) <= 1) board[a][b]--;
        ans.push_back(state(ci, cj, 1));
        dfs(rest - 1);
        ans.pop_back();
        rep(a, 10) rep(b, 10) if (abs(a - ci) + abs(b - cj) <= 1) board[a][b]++;
      }
    }

    // med
    {
      int num = 0;
      int ci = i + 1, cj = j + 1;
      rep(a, 10) rep(b, 10) if (max(abs(a - ci), abs(b - cj)) <= 1) num +=
          min(1, board[a][b]);

      if (num == 9) {
        rep(a, 10) rep(b, 10) if (max(abs(a - ci), abs(b - cj)) <= 1)
            board[a][b]--;
        ans.push_back(state(ci, cj, 2));
        dfs(rest - 1);
        ans.pop_back();
        rep(a, 10) rep(b, 10) if (max(abs(a - ci), abs(b - cj)) <= 1)
            board[a][b]++;
      }
    }

    // large
    {
      int num = 0;
      int ci = i + 2, cj = j;
      rep(a, 10) rep(b, 10) if (abs(a - ci) + abs(b - cj) <= 2) num +=
          min(1, board[a][b]);

      if (num == 13) {
        rep(a, 10) rep(b, 10) if (abs(a - ci) + abs(b - cj) <= 2) board[a][b]--;
        ans.push_back(state(ci, cj, 3));
        dfs(rest - 1);
        ans.pop_back();
        rep(a, 10) rep(b, 10) if (abs(a - ci) + abs(b - cj) <= 2) board[a][b]++;
      }
    }

    return;
  }
  return;
}

int main(void) {
  int n;
  cin >> n;
  rep(i, 10) rep(j, 10) cin >> board[i][j];
  dfs(n);
  return 0;
}

Error: MLE

Fixed submission:

#include <bits/stdc++.h>
#define range(i, a, b) for (int(i) = (a); (i) < (b); (i)++)
#define rep(i, n) range(i, 0, n)
using namespace std;

int n;
int a[10][10];

class state {
public:
  int a[10][10];
  bool operator<(state b) const {
    rep(i, 10) rep(j, 10) if (a[i][j] != b.a[i][j]) return a[i][j] < b.a[i][j];
    return false;
  }
};

set<pair<state, int>> ss;

int dp[310];

bool dfs(int depth, state board, int sum) {
  if (ss.find(make_pair(board, depth)) != ss.end())
    return false;
  if (depth == n) {
    rep(i, 10) rep(j, 10) if (board.a[i][j] != a[i][j]) return false;
    return true;
  }

  if (dp[sum] == 0)
    return false;
  ss.insert(make_pair(board, depth));

  const int res = n - depth - 1;

  int b[5][5] = {{0, 0, 1, 0, 0},
                 {0, 1, 1, 1, 0},
                 {1, 1, 1, 1, 1},
                 {0, 1, 1, 1, 0},
                 {0, 0, 1, 0, 0}};
  if (sum >= 13 && dp[sum - 13] && (sum - 13) >= 5 * res) {
    rep(i, 6) rep(j, 6) {
      state nboard = board;
      rep(k, 5) rep(l, 5) nboard.a[i + k][j + l] += b[k][l];
      bool ok = true;
      rep(c, 10) rep(d, 10) if (nboard.a[c][d] > a[c][d]) ok = false;
      if (!ok)
        continue;
      if (dfs(depth + 1, nboard, sum - 13)) {
        cout << j + 2 << " " << i + 2 << " " << 3 << endl;
        return true;
      }
    }
  }

  int m[3][3] = {{1, 1, 1}, {1, 1, 1}, {1, 1, 1}};
  if (sum >= 9 && dp[sum - 9] && (sum - 9) >= 5 * res &&
      13 * res >= (sum - 9)) {
    rep(i, 8) rep(j, 8) {
      state nboard = board;
      rep(k, 3) rep(l, 3) nboard.a[i + k][j + l] += m[k][l];
      bool ok = true;
      rep(c, 10) rep(d, 10) if (nboard.a[c][d] > a[c][d]) ok = false;
      if (!ok)
        continue;
      if (dfs(depth + 1, nboard, sum - 9)) {
        cout << j + 1 << " " << i + 1 << " " << 2 << endl;
        return true;
      }
    }
  }

  int s[3][3] = {{0, 1, 0}, {1, 1, 1}, {0, 1, 0}};
  if (sum >= 5 && dp[sum - 5] && 13 * res >= (sum - 5)) {
    rep(i, 8) rep(j, 8) {
      state nboard = board;
      rep(k, 3) rep(l, 3) nboard.a[i + k][j + l] += s[k][l];
      bool ok = true;
      rep(c, 10) rep(d, 10) if (nboard.a[c][d] > a[c][d]) ok = false;
      if (!ok)
        continue;
      if (dfs(depth + 1, nboard, sum - 5)) {
        cout << j + 1 << " " << i + 1 << " " << 1 << endl;
        return true;
      }
    }
  }
  return false;
}

int main(void) {
  dp[0] = 1;
  rep(i, 200) if (dp[i]) dp[i + 13] = dp[i];
  rep(i, 200) if (dp[i]) dp[i + 9] = dp[i];
  rep(i, 200) if (dp[i]) dp[i + 5] = dp[i];

  cin >> n;
  rep(i, 10) rep(j, 10) cin >> a[i][j];
  state init;
  rep(i, 10) rep(j, 10) init.a[i][j] = 0;
  int sum = 0;
  rep(i, 10) rep(j, 10) sum += a[i][j];
  dfs(0, init, sum);
  return 0;
}