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

#define _USE_MATH_DEFINES
#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define reps(i, n) for (int i = 1; i <= (n); ++i)
#define repd(i, n) for (int i = (n)-1; i >= 0; --i)
#define repds(i, n) for (int i = (n); i > 0; --i)
#define loop(i, x, n) for (int i = (x); i < (n); ++i)
#define loops(i, x, n) for (int i = (x); i <= (n); ++i)
#define loopd(i, x, n) for (int i = (x); i > (n); --i)
#define loopds(i, x, n) for (int i = (x); i >= (n); --i)
#define itrep(i, a) for (auto i = begin(a); i != end(a); ++i)
#define itrepd(i, a) for (auto i = rbegin(a); i != rend(a); ++i)
#define each(i, x) for (auto &&i : x)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(a) ((int)a.size())
#define pow2(n) (n * n)
#define int ll
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
template <class T> using p_queue = priority_queue<T, vector<T>, greater<T>>;
constexpr ll inf = static_cast<ll>(1e18);
constexpr int iinf = static_cast<int>(1e9);
constexpr double dinf = 1e10;
constexpr ld ldinf = 1e18;
constexpr double eps = 1e-8;
ll mod = static_cast<ll>(1e9 + 7);
template <class T, class... Args> constexpr void mins(T &a, Args... args) {
  a = min<T>({a, args...});
}
template <class T, class... Args> constexpr void maxs(T &a, Args... args) {
  a = max<T>({a, args...});
}
template <class F> class FixPoint : private F {
public:
  explicit constexpr FixPoint(F &&f) : F(std::forward<F>(f)) {}
  template <class... Args>
  constexpr decltype(auto) operator()(Args &&...args) const {
    return F::operator()(*this, std::forward<Args>(args)...);
  }
};
template <class F> constexpr decltype(auto) funcs(F &&f) {
  return FixPoint<F>{std::forward<F>(f)};
}
template <class T> std::vector<T> vecs(int n, T &&val) {
  return std::vector<T>(std::forward<int>(n), std::forward<T>(val));
}
template <class... Args> decltype(auto) vecs(int n, Args &&...args) {
  return std::vector<decltype(vecs(std::forward<Args>(args)...))>(
      std::forward<int>(n), vecs(std::forward<Args>(args)...));
}
template <class V, class T> void fill(V &x, const T &val) { x = val; }
template <class V, class T> void fill(vector<V> &vec, const T &val) {
  for (auto &&v : vec)
    fill(v, val);
}

void solve() {
  int h, w;
  cin >> h >> w;
  int sx, sy, gx, gy;
  cin >> sx >> sy >> gx >> gy;
  --sx, --sy, --gx, --gy;
  vector<string> c(h);
  rep(i, h) cin >> c[i];

  vector<int> dx{1, 0, -1, 0}, dy{0, 1, 0, -1};
  auto d = vecs(h, w, int(inf));
  d[sx][sy] = 0;

  queue<pair<int, int>> que;
  que.emplace(sx, sy);
  while (!que.empty()) {
    vector<pair<int, int>> v;

    while (!que.empty()) {
      auto p = que.front();
      que.pop();
      int x = p.first, y = p.second;
      v.emplace_back(x, y);
      rep(i, 4) {
        auto nx = x + dx[i], ny = y + dy[i];
        if (nx < 0 || nx >= h || ny < 0 || ny >= w || c[nx][ny] == '#' ||
            d[nx][ny] != inf)
          continue;

        d[nx][ny] = d[x][y];
        que.emplace(nx, ny);
      }
    }

    each(x, v) {
      rep(i, 5) rep(j, 5) {
        int nx = x.first + i - 2, ny = x.second + j - 2;
        if (nx < 0 || nx >= h || ny < 0 || ny >= w || c[nx][ny] == '#' ||
            d[nx][ny] != inf)
          continue;
        d[nx][ny] = d[x.first][x.second] + 1;
        que.emplace(nx, ny);
      }
    }
  }

  cout << (d[gx][gy] != inf ? d[gx][gy] : -1) << endl;
}

signed main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(15);
  solve();
  cout.flush();
  return 0;
}

Error: TLE

Fixed submission:

#define _USE_MATH_DEFINES
#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (n); ++i)
#define reps(i, n) for (int i = 1; i <= (n); ++i)
#define repd(i, n) for (int i = (n)-1; i >= 0; --i)
#define repds(i, n) for (int i = (n); i > 0; --i)
#define loop(i, x, n) for (int i = (x); i < (n); ++i)
#define loops(i, x, n) for (int i = (x); i <= (n); ++i)
#define loopd(i, x, n) for (int i = (x); i > (n); --i)
#define loopds(i, x, n) for (int i = (x); i >= (n); --i)
#define itrep(i, a) for (auto i = begin(a); i != end(a); ++i)
#define itrepd(i, a) for (auto i = rbegin(a); i != rend(a); ++i)
#define each(i, x) for (auto &&i : x)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(a) ((int)a.size())
#define pow2(n) (n * n)
#define int ll
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
template <class T> using p_queue = priority_queue<T, vector<T>, greater<T>>;
constexpr ll inf = static_cast<ll>(1e18);
constexpr int iinf = static_cast<int>(1e9);
constexpr double dinf = 1e10;
constexpr ld ldinf = 1e18;
constexpr double eps = 1e-8;
ll mod = static_cast<ll>(1e9 + 7);
template <class T, class... Args> constexpr void mins(T &a, Args... args) {
  a = min<T>({a, args...});
}
template <class T, class... Args> constexpr void maxs(T &a, Args... args) {
  a = max<T>({a, args...});
}
template <class F> class FixPoint : private F {
public:
  explicit constexpr FixPoint(F &&f) : F(std::forward<F>(f)) {}
  template <class... Args>
  constexpr decltype(auto) operator()(Args &&...args) const {
    return F::operator()(*this, std::forward<Args>(args)...);
  }
};
template <class F> constexpr decltype(auto) funcs(F &&f) {
  return FixPoint<F>{std::forward<F>(f)};
}
template <class T> std::vector<T> vecs(int n, T &&val) {
  return std::vector<T>(std::forward<int>(n), std::forward<T>(val));
}
template <class... Args> decltype(auto) vecs(int n, Args &&...args) {
  return std::vector<decltype(vecs(std::forward<Args>(args)...))>(
      std::forward<int>(n), vecs(std::forward<Args>(args)...));
}
template <class V, class T> void fill(V &x, const T &val) { x = val; }
template <class V, class T> void fill(vector<V> &vec, const T &val) {
  for (auto &&v : vec)
    fill(v, val);
}

template <class T, class U> struct fpair {
  T first;
  U second;
  fpair(T fi = T(), U se = U()) : first(fi), second(se) {}
  bool operator<(const fpair &x) const { return first < x.first; }
  bool operator>(const fpair &x) const { return first > x.first; }
};

void solve() {
  int h, w;
  cin >> h >> w;
  int sx, sy, gx, gy;
  cin >> sx >> sy >> gx >> gy;
  --sx, --sy, --gx, --gy;
  vector<string> c(h);
  rep(i, h) cin >> c[i];

  auto id = [&](int val) {
    int l = val / (h * w * 5);
    int k = (val - h * w * 5 * l) / (h * w);
    int i = (val - h * w * 5 * l - h * w * k) / w;
    int j = val - (h * w * 5 * l + h * w * k + w * i);
    return make_tuple(i, j, k, l);
  };
  auto id2 = [&](int x, int y, int i, int j) {
    return w * x + y + h * w * i + h * w * 5 * j;
  };

  vector<int> dx{1, 0, -1, 0}, dy{0, 1, 0, -1};
  auto d = vecs(h * w * 5 * 5, int(inf));
  d[id2(sx, sy, 2, 2)] = 0;
  p_queue<fpair<int, int>> que;
  que.emplace(0, id2(sx, sy, 2, 2));
  while (!que.empty()) {
    auto p = que.top();
    que.pop();
    int x, y, cx, cy;
    tie(x, y, cx, cy) = id(p.second);
    if (d[p.second] != p.first)
      continue;
    rep(i, 4) {
      int nx = x + dx[i], ny = y + dy[i];
      if (nx < 0 || nx >= h || ny < 0 || ny >= w)
        continue;
      int ncx = cx + dx[i], ncy = cy + dy[i];
      if (ncx < 0 || ncx >= 5 || ncy < 0 || ncy >= 5)
        continue;
      if (c[nx][ny] == '.') {
        if (d[id2(nx, ny, 2, 2)] > p.first) {
          d[id2(nx, ny, 2, 2)] = p.first;
          que.emplace(p.first, id2(nx, ny, 2, 2));
        }
      }

      int cost = (cx == 2 && cy == 2 ? 1 : 0);
      if (d[id2(nx, ny, ncx, ncy)] > p.first + cost) {
        d[id2(nx, ny, ncx, ncy)] = p.first + cost;
        que.emplace(p.first + cost, id2(nx, ny, ncx, ncy));
      }
    }
  }

  int ans = inf;
  rep(i, 5) rep(j, 5) { mins(ans, d[id2(gx, gy, i, j)]); }

  cout << (ans != inf ? ans : -1) << endl;
}

signed main() {
  cin.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(15);
  solve();
  cout.flush();
  return 0;
}