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

#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}

// 定数たち
const ll INF = 1e18;
const double PI = 3.14159265358979323846264338327950;

// 最大公約数
ll gcd(ll x, ll y) {
  ll tmp = 0;
  if (x < y) {
    tmp = x;
    x = y;
    y = tmp;
  }
  while (y > 0) {
    ll r = x % y;
    x = y;
    y = r;
  }
  return x;
}

// 最大公倍数
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }

const int MAX = 1e6 + 1;
const ll MOD = 1e9 + 7;

long long fac[MAX], finv[MAX], inv[MAX];

// テーブルを作る前処理
void COMinit() {
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (int i = 2; i < MAX; i++) {
    fac[i] = fac[i - 1] * i % MOD;
    inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
    finv[i] = finv[i - 1] * inv[i] % MOD;
  }
}

struct mint {
  ll x; // typedef long long ll;
  mint(ll x = 0) : x((x % MOD + MOD) % MOD) {}
  mint operator-() const { return mint(-x); }
  mint &operator+=(const mint a) {
    if ((x += a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator-=(const mint a) {
    if ((x += MOD - a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator*=(const mint a) {
    (x *= a.x) %= MOD;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res += a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res -= a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res *= a;
  }
  mint pow(ll t) const {
    if (!t)
      return 1;
    mint a = pow(t >> 1);
    a *= a;
    if (t & 1)
      a *= *this;
    return a;
  }

  // for prime MOD
  mint inv() const { return pow(MOD - 2); }
  mint &operator/=(const mint a) { return (*this) *= a.inv(); }
  mint operator/(const mint a) const {
    mint res(*this);
    return res /= a;
  }
};

// 二項係数計算
long long COM(int n, int k) {
  if (n < k)
    return 0;
  if (n < 0 || k < 0)
    return 0;
  return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}

// 階乗
ll kaijo(ll k) {
  ll sum = 1;
  for (ll i = 1; i <= k; ++i) {
    sum *= i;
    sum %= 1000000000 + 7;
  }
  return sum;
}

long long modpow(long long a, long long n, long long MOD) {
  long long res = 1;
  while (n > 0) {
    if (n & 1)
      res = res * a % MOD;
    a = a * a % MOD;
    n >>= 1;
  }
  return res;
}

struct UnionFind {
  vector<int> par;
  UnionFind(int n) : par(n, -1) {}
  int root(int x) {
    if (par[x] < 0)
      return x;
    else
      return par[x] = root(par[x]);
  }
  bool issame(int x, int y) { return root(x) == root(y); }
  bool merge(int x, int y) {
    x = root(x);
    y = root(y);
    if (x == y)
      return false;
    if (par[x] > par[y])
      swap(x, y); // merge technique
    par[x] += par[y];
    par[y] = x;
    return true;
  }
  ll size(int x) { return -par[root(x)]; }
};

// 二項係数（大きい値用）
ll count(int n, int a) {
  ll bunshi = 1;
  for (int i = 0; i < a; i++) {
    bunshi *= (n - i);
    bunshi %= MOD;
  }
  ll bunbo = 1;
  for (int i = 1; i < a + 1; i++) {
    bunbo *= i;
    bunbo %= MOD;
  }
  bunbo = modpow(bunbo, MOD - 2, MOD);
  return (bunshi * bunbo) % MOD;
}

// 約数列挙。約数をvector<ll>で返す。計算量はsqrt(n)。
vector<ll> divisor(ll n) {
  vector<ll> ret;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  sort(begin(ret), end(ret));
  return (ret);
}

// グラフ
struct edge {
  ll to, cost;
};
// typedef pair<ll,ll> P;
struct graph {
  ll V;
  vector<vector<edge>> G;
  vector<ll> d;

  graph(ll n) { init(n); }

  void init(ll n) {
    V = n;
    G.resize(V);
    d.resize(V);
    rep(i, V) { d[i] = INF; }
  }

  void add_edge(ll s, ll t, ll cost) {
    edge e;
    e.to = t, e.cost = cost;
    G[s].push_back(e);
  }

  void dijkstra(ll s) {
    rep(i, V) { d[i] = INF; }
    d[s] = 0;
    priority_queue<P, vector<P>, greater<P>> que;
    que.push(P(0, s));
    while (!que.empty()) {
      P p = que.top();
      que.pop();
      ll v = p.second;
      if (d[v] < p.first)
        continue;
      for (auto e : G[v]) {
        if (d[e.to] > d[v] + e.cost) {
          d[e.to] = d[v] + e.cost;
          que.push(P(d[e.to], e.to));
        }
      }
    }
  }
};

// ここから開始
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, -1, 0, 1};

int main() {
  int h, w;
  cin >> h >> w;
  int si, sj;
  cin >> si >> sj;
  int ti, tj;
  cin >> ti >> tj;
  --si;
  --sj;
  --ti;
  --tj;
  vector<string> s(h);
  rep(i, h) cin >> s[i];
  const int INF = 1e9;
  vector<vector<int>> dist(h, vector<int>(w, INF));
  deque<P> q;
  dist[si][sj] = 0;
  q.emplace_back(si, sj);
  while (!q.empty()) {
    int i = q.front().first;
    int j = q.front().second;
    int d = dist[i][j];
    q.pop_front();
    if (dist[i][j] != d)
      continue;
    rep(v, 4) {
      int ni = i + di[v], nj = j + dj[v];
      if (ni < 0 || ni >= h || nj < 0 || nj >= w)
        continue;
      if (s[ni][nj] == '#')
        continue;
      if (dist[ni][nj] <= d)
        continue;
      dist[ni][nj] = d;
      q.emplace_front(ni, nj);
    }
    for (int ei = -2; ei <= 2; ++ei) {
      for (int ej = -2; ej <= 2; ++ej) {
        int ni = i + ei, nj = j + ej;
        if (ni < 0 || ni >= h || nj < 0 || nj >= w)
          continue;
        if (s[ni][nj] == '#')
          continue;
        if (dist[ni][nj] <= d + 1)
          continue;
        dist[ni][nj] = d + 1;
        q.emplace_back(ni, nj);
      }
    }
  }
  int ans = dist[ti][tj];
  if (ans == INF)
    ans = -1;
  cout << ans << endl;
  return 0;
}

Error: TLE

Fixed submission:

#include <bits/stdc++.h>

#define rep(i, n) for (int i = 0; i < (n); ++i)

using namespace std;
typedef pair<int, int> P;
typedef long long ll;
template <class T> inline bool chmax(T &a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T> inline bool chmin(T &a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}

// 最大公約数
ll gcd(ll x, ll y) {
  ll tmp = 0;
  if (x < y) {
    tmp = x;
    x = y;
    y = tmp;
  }
  while (y > 0) {
    ll r = x % y;
    x = y;
    y = r;
  }
  return x;
}

// 最大公倍数
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }

const int MAX = 1e6 + 1;
const ll MOD = 1e9 + 7;

long long fac[MAX], finv[MAX], inv[MAX];

// テーブルを作る前処理
void COMinit() {
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (int i = 2; i < MAX; i++) {
    fac[i] = fac[i - 1] * i % MOD;
    inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
    finv[i] = finv[i - 1] * inv[i] % MOD;
  }
}

struct mint {
  ll x; // typedef long long ll;
  mint(ll x = 0) : x((x % MOD + MOD) % MOD) {}
  mint operator-() const { return mint(-x); }
  mint &operator+=(const mint a) {
    if ((x += a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator-=(const mint a) {
    if ((x += MOD - a.x) >= MOD)
      x -= MOD;
    return *this;
  }
  mint &operator*=(const mint a) {
    (x *= a.x) %= MOD;
    return *this;
  }
  mint operator+(const mint a) const {
    mint res(*this);
    return res += a;
  }
  mint operator-(const mint a) const {
    mint res(*this);
    return res -= a;
  }
  mint operator*(const mint a) const {
    mint res(*this);
    return res *= a;
  }
  mint pow(ll t) const {
    if (!t)
      return 1;
    mint a = pow(t >> 1);
    a *= a;
    if (t & 1)
      a *= *this;
    return a;
  }

  // for prime MOD
  mint inv() const { return pow(MOD - 2); }
  mint &operator/=(const mint a) { return (*this) *= a.inv(); }
  mint operator/(const mint a) const {
    mint res(*this);
    return res /= a;
  }
};

// 二項係数計算
long long COM(int n, int k) {
  if (n < k)
    return 0;
  if (n < 0 || k < 0)
    return 0;
  return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}

// 階乗
ll kaijo(ll k) {
  ll sum = 1;
  for (ll i = 1; i <= k; ++i) {
    sum *= i;
    sum %= 1000000000 + 7;
  }
  return sum;
}

long long modpow(long long a, long long n, long long MOD) {
  long long res = 1;
  while (n > 0) {
    if (n & 1)
      res = res * a % MOD;
    a = a * a % MOD;
    n >>= 1;
  }
  return res;
}

// //sieve(MAX);でベクトルIsPrimeに「MAXまでの数値の素数の真偽」を格納する。
// struct Sieve {
//     int n;
//     vector<int> f, primes;
//     Sieve(int n=1):n(n), f(n+1) {
//         f[0] = f[1] = -1;
//         for (ll i = 2; i <= n; ++i) {
//         if (f[i]) continue;
//         primes.push_back(i);
//         f[i] = i;
//         for (ll j = i*i; j <= n; j += i) {
//             if (!f[j]) f[j] = i;
//         }
//         }
//     }
//     bool isPrime(int x) { return f[x] == x;}
//     vector<int> factorList(int x) {
//         vector<int> res;
//         while (x != 1) {
//         res.push_back(f[x]);
//         x /= f[x];
//         }
//         return res;
//     }
//     vector<P> factor(int x) {
//         vector<int> fl = factorList(x);
//         if (fl.size() == 0) return {};
//         vector<P> res(1, P(fl[0], 0));
//         for (int p : fl) {
//         if (res.back().first == p) {
//             res.back().second++;
//         } else {
//             res.emplace_back(p, 1);
//         }
//         }
//         return res;
//     }
// };
struct UnionFind {
  vector<int> par;
  UnionFind(int n) : par(n, -1) {}
  int root(int x) {
    if (par[x] < 0)
      return x;
    else
      return par[x] = root(par[x]);
  }
  bool issame(int x, int y) { return root(x) == root(y); }
  bool merge(int x, int y) {
    x = root(x);
    y = root(y);
    if (x == y)
      return false;
    if (par[x] > par[y])
      swap(x, y); // merge technique
    par[x] += par[y];
    par[y] = x;
    return true;
  }
  ll size(int x) { return -par[root(x)]; }
};

// 二項係数（大きい値用）
ll count(int n, int a) {
  ll bunshi = 1;
  for (int i = 0; i < a; i++) {
    bunshi *= (n - i);
    bunshi %= MOD;
  }
  ll bunbo = 1;
  for (int i = 1; i < a + 1; i++) {
    bunbo *= i;
    bunbo %= MOD;
  }
  bunbo = modpow(bunbo, MOD - 2, MOD);
  // cout<<(bunshi*bunbo)%MOD<<endl;
  return (bunshi * bunbo) % MOD;
}

// 約数列挙。約数をvector<ll>で返す。計算量はsqrt(n)。
vector<ll> divisor(ll n) {
  vector<ll> ret;
  for (ll i = 1; i * i <= n; i++) {
    if (n % i == 0) {
      ret.push_back(i);
      if (i * i != n)
        ret.push_back(n / i);
    }
  }
  sort(begin(ret), end(ret));
  return (ret);
}

// ここから開始
const ll INF = 1e18;
const double PI = 3.14159265358979323846264338327950;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};

int main() {
  int H, W;
  int ch, cw;
  int dh, dw;
  cin >> H >> W >> ch >> cw >> dh >> dw;
  ch--;
  cw--;
  dh--;
  dw--;
  string s[H];
  rep(i, H) cin >> s[i];

  ll dp[H][W];
  rep(i, H) rep(j, W) { dp[i][j] = INF; }

  dp[ch][cw] = 0;
  queue<pair<int, int>> que;
  que.push(make_pair(ch, cw));
  while (!que.empty()) {
    int i = que.front().first;
    int j = que.front().second;
    que.pop();
    for (int k = 0; k < 4; k++) {
      int newx = i + dx[k];
      int newy = j + dy[k];
      if (newx < 0 || H <= newx || newy < 0 || W <= newy)
        continue;
      if (s[newx][newy] == '.') {
        if (dp[newx][newy] > dp[i][j])
          que.push(make_pair(newx, newy));
        dp[newx][newy] = min(dp[newx][newy], dp[i][j]);
      }
    }
    for (int xx = -2; xx < 3; xx++) {
      for (int yy = -2; yy < 3; yy++) {
        int newx = i + xx;
        int newy = j + yy;
        if (newx < 0 || H <= newx || newy < 0 || W <= newy)
          continue;
        if (s[newx][newy] == '.') {
          if (dp[newx][newy] > dp[i][j] + 1)
            que.push(make_pair(newx, newy));
          dp[newx][newy] = min(dp[newx][newy], dp[i][j] + 1);
        }
      }
    }
  }
  // cout<<dh<<dw<<endl;
  if (dp[dh][dw] == INF)
    cout << -1 << endl;
  else
    cout << dp[dh][dw] << endl;
  // rep(i,H){
  //     rep(j,W){
  //         cout<<dp[i][j]<<"  ";
  //     }
  //     cout<<endl;
  // }

  // queue<pair<pair<int,int>,int> > que2;
  // que2.push(make_pair(make_pair(ch,cw),0));
  // bool vi[H][W];
  // rep(i,H)rep(j,W) vi[i][j]=false;
  // int ans = 1000000000;
  // while(!que2.empty()){
  //     int i = que2.front().first.first;
  //     int j = que2.front().first.second;
  //     int value = que2.front().second;
  //     que2.pop();
  //     // cout<<i<<j<<endl;
  //     vi[i][j]=true;
  //     if(i==dh&&j==dw) ans=min(ans,value);
  //     int past;
  //     for(int xx = -2; xx<3; xx++){
  //         for(int yy = -2; yy <3; yy++){
  //             int newx = i+xx;
  //             int newy = j+yy;
  //             if(visited[newx][newy]==-1||vi[newx][newy]) continue;
  //             if(newx<0||H<=newx||newy<0||W<=newy) continue;
  //             int newvalue = value;
  //             // cout<<newx<<newy<<endl;
  //             if(visited[newx][newy]!=visited[i][j]) newvalue++;
  //             que2.push(make_pair(make_pair(newx,newy),newvalue));
  //         }
  //     }
  // }
  // if(ans==1000000000) cout<<-1<<endl;
  // else cout<<ans<<endl;
  return 0;
}

// int visited[H][W];
// rep(i,H){
//     rep(j,W){
//         visited[i][j] = -1;
//     }
// }

// int idx = 0;
// rep(i,H){
//     rep(j,W){
//         if(visited[i][j]==-1&&s[i][j]=='.'){
//             queue<pair<int,int> > que;
//             que.push(make_pair(i,j));
//             while(!que.empty()){
//                 // cout<<i<<" "<<j<<endl;
//                 pair<int,int> p = que.front();
//                 que.pop();
//                 int xx = p.first;
//                 int yy = p.second;
//                 visited[xx][yy] = idx;
//                 // cout<<visited[xx][yy]<<endl;
//                 rep(k,4){
//                     if((0<=xx+dx[k])&&(xx+dx[k]<H)&&(0<=yy+dy[k])&&(yy+dy[k]<W)&&(visited[xx+dx[k]][yy+dy[k]]==-1)&&(s[xx+dx[k]][yy+dy[k]]=='.')){
//                         que.push(make_pair(xx+dx[k],yy+dy[k]));
//                     }
//                 }
//             }
//             idx++;
//         }
//     }
// }

// int dis[100000][100000]; //iグループからjグループの最短距離
// UnionFind tree(1000000);
// vector<int> v[100001];