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

// Bismillahir Rahmanir Rahim

// #pragma GCC optimize("Ofast,unroll-loops")
// #pragma GCC target("avx,avx2,fma")

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define xx first
#define yy second
#define sci(n) scanf("%d", &n)
#define scii(n, m) scanf("%d%d", &n, &m)
#define sciii(n, m, w) scanf("%d%d%d", &n, &m, &w)
#define scl(n) scanf("%lld", &n)
#define scll(n, m) scanf("%lld%lld", &n, &m)
#define sclll(n, m, w) scanf("%lld%lld%lld", &n, &m, &w)
#define pf(a) printf("%d\\n", a)
#define CASE(a) printf("Case %d: ", a)
#define dbg(i) printf("yo %d\\n", i)
#define endl '\\n'
#define READ freopen("input.txt", "r", stdin)
#define WRITE freopen("output.txt", "w", stdout);
#define pi acos(-1)
#define mem(a, b) memset(a, b, sizeof(a))
#define SQR(a) (a) * (a)
#define all(v) v.begin(), v.end()
#define pb push_back
#define pri priority_queue<int>
#define rev_pri priority_queue<int, vector<int>, greater<int>>
#define IOS                                                                    \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define mod 1000000007
#define inf INT_MAX
#define eps 1e-9

using namespace __gnu_pbds;
using namespace std;

// ll ncr(ll n,ll r){if(n==r)return 1;if(r==1)return n;if(dp[n][r]!=-1)return
// dp[n][r];return dp[n][r]=ncr(n-1,r)+ncr(n-1,r-1);}

// bit manipulations

// bool checkbit(int mask,int bit){return mask & (1<<bit);}
// int setbit(int mask,int bit){ return mask | (1<<bit) ; }
// int clearbit(int mask,int bit){return mask & ~(1<<bit);}
// int togglebit(int mask,int bit){return mask ^ (1<<bit);}
// int bitno(int mask) {return (int)__builtin_popcount(mask);}

template <typename T> T BigMod(T b, T p, T m) {
  if (p == 0)
    return 1;
  if (p % 2 == 0) {
    T s = BigMod(b, p / 2, m);
    return ((s % m) * (s % m)) % m;
  }
  return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T> T ModInv(T b, T m) { return BigMod(b, m - 2, m); }
template <typename T> T in() {
  char ch;
  T n = 0;
  bool ng = false;
  while (1) {
    ch = getchar();
    if (ch == '-') {
      ng = true;
      ch = getchar();
      break;
    }
    if (ch >= '0' && ch <= '9')
      break;
  }
  while (1) {
    n = n * 10 + (ch - '0');
    ch = getchar();
    if (ch < '0' || ch > '9')
      break;
  }
  return (ng ? -n : n);
}
template <typename T> T POW(T B, T P) {
  if (P == 0)
    return 1;
  if (P & 1)
    return B * POW(B, P - 1);
  else
    return SQR(POW(B, P / 2));
}
template <typename T> T Bigmod(T b, T p, T m) {
  if (p == 0)
    return 1;
  else if (!(p & 1))
    return SQR(Bigmod(b, p / 2, m)) % m;
  else
    return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T> T Dis(T x1, T lol, T x2, T y2) {
  return sqrt(SQR(x1 - x2) + SQR(lol - y2));
}
template <typename T> T Angle(T x1, T lol, T x2, T y2) {
  return atan(double(lol - y2) / double(x1 - x2));
}
template <typename T> T DIFF(T a, T b) {
  T d = a - b;
  if (d < 0)
    return -d;
  else
    return d;
}
template <typename T> T ABS(T a) {
  if (a < 0)
    return -a;
  else
    return a;
}
template <typename T> T gcd(T a, T b) {
  if (a < 0)
    return gcd(-a, b);
  if (b < 0)
    return gcd(a, -b);
  return (b == 0) ? a : gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) {
  if (a < 0)
    return lcm(-a, b);
  if (b < 0)
    return lcm(a, -b);
  return a * (b / gcd(a, b));
}
template <typename T> T euclide(T a, T b, T &x, T &y) {
  if (a < 0) {
    T d = euclide(-a, b, x, y);
    x = -x;
    return d;
  }
  if (b < 0) {
    T d = euclide(a, -b, x, y);
    y = -y;
    return d;
  }
  if (b == 0) {
    x = 1;
    y = 0;
    return a;
  } else {
    T d = euclide(b, a % b, x, y);
    T t = x;
    x = y;
    y = t - (a / b) * y;
    return d;
  }
}
template <typename T> void ia(T a[], int n) {
  for (int i = 0; i < n; i++)
    cin >> a[i];
}
template <typename T> void pa(T a[], int n) {
  for (int i = 0; i < n - 1; i++)
    cout << a[i] << " ";
  cout << a[n - 1] << endl;
}
template <typename T> ll isLeft(T a, T b, T c) {
  return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

///********************************MY CODE STARTS
///HERE********************************///

#define mxn 100005

vector<string> grid;
int n, m, k;
int x1, x2, lol, y2;

bool valid(int x, int y) {

  if (x < 0 || y < 0 || x >= n || y >= m || grid[x][y] != '.')
    return false;
  return true;
}

ll bfs(int sx, int sy) {
  ll dp[n + 5][m + 5];

  mem(dp, -1);
  queue<pii> q;
  q.push({sx, sy});
  dp[sx][sy] = 0;

  while (!q.empty()) {
    pii u = q.front();
    q.pop();

    for (int i = 1; i <= k; i++) {
      if (!valid(u.xx, u.yy + i))
        break;
      if (dp[u.xx][u.yy + i] != -1)
        break;
      dp[u.xx][u.yy + i] = dp[u.xx][u.yy] + 1;
      if (u.xx == x2 && u.yy + i == y2)
        return dp[x2][y2];
      q.push({u.xx, u.yy + i});
    }

    for (int i = -1; i >= -k; i--) {
      if (!valid(u.xx, u.yy + i))
        break;
      if (dp[u.xx][u.yy + i] != -1)
        break;
      dp[u.xx][u.yy + i] = dp[u.xx][u.yy] + 1;
      if (u.xx == x2 && u.yy + i == y2)
        return dp[x2][y2];
      q.push({u.xx, u.yy + i});
    }

    for (int i = 1; i <= k; i++) {
      if (!valid(u.xx + i, u.yy))
        break;
      if (dp[u.xx + i][u.yy] != -1)
        break;
      dp[u.xx + i][u.yy] = dp[u.xx][u.yy] + 1;
      if (u.xx + i == x2 && u.yy == y2)
        return dp[x2][y2];
      q.push({u.xx + i, u.yy});
    }

    for (int i = -1; i >= -k; i--) {
      if (!valid(u.xx + i, u.yy))
        break;
      if (dp[u.xx + i][u.yy] != -1)
        break;
      dp[u.xx + i][u.yy] = dp[u.xx][u.yy] + 1;
      if (u.xx + i == x2 && u.yy == y2)
        return dp[x2][y2];
      q.push({u.xx + i, u.yy});
    }
  }
  return dp[x2][y2];
}

ll bfs2(int sx, int sy) {
  ll dp[n + 5][m + 5];

  mem(dp, -1);
  queue<pii> q;
  q.push({sx, sy});
  dp[sx][sy] = 0;

  while (!q.empty()) {
    pii u = q.front();
    q.pop();

    for (int i = 1; i <= k; i++) {
      if (!valid(u.xx, u.yy + i))
        break;
      if (dp[u.xx][u.yy + i] != -1)
        break;
      dp[u.xx][u.yy + i] = dp[u.xx][u.yy] + 1;
      if (u.xx == x1 && u.yy + i == lol)
        return dp[x1][lol];
      q.push({u.xx, u.yy + i});
    }

    for (int i = -1; i >= -k; i--) {
      if (!valid(u.xx, u.yy + i))
        break;
      if (dp[u.xx][u.yy + i] != -1)
        break;
      dp[u.xx][u.yy + i] = dp[u.xx][u.yy] + 1;
      if (u.xx == x1 && u.yy + i == lol)
        return dp[x1][lol];
      q.push({u.xx, u.yy + i});
    }

    for (int i = 1; i <= k; i++) {
      if (!valid(u.xx + i, u.yy))
        break;
      if (dp[u.xx + i][u.yy] != -1)
        break;
      dp[u.xx + i][u.yy] = dp[u.xx][u.yy] + 1;
      if (u.xx + i == x1 && u.yy == lol)
        return dp[x1][lol];
      q.push({u.xx + i, u.yy});
    }

    for (int i = -1; i >= -k; i--) {
      if (!valid(u.xx + i, u.yy))
        break;
      if (dp[u.xx + i][u.yy] != -1)
        break;
      dp[u.xx + i][u.yy] = dp[u.xx][u.yy] + 1;
      if (u.xx + i == x1 && u.yy == lol)
        return dp[x1][lol];
      q.push({u.xx + i, u.yy});
    }
  }
  return dp[x1][lol];
}

const ll INF = 1e17;

ll bfs3(int sx, int sy) {
  ll dp[n + 5][m + 5];

  mem(dp, -1);
  queue<pii> q;
  q.push({sx, sy});
  dp[sx][sy] = 0;

  int ptr = 0;

  while (!q.empty()) {
    pii u = q.front();
    q.pop();
    ptr++;
    if (ptr > 20000000)
      return INF;

    for (int i = 1; i <= k; i++) {
      ptr++;
      if (ptr > 20000000)
        return INF;
      if (!valid(u.xx, u.yy + i))
        break;
      if (dp[u.xx][u.yy + i] != -1)
        continue;
      dp[u.xx][u.yy + i] = dp[u.xx][u.yy] + 1;
      if (u.xx == x2 && u.yy + i == y2)
        return dp[x2][y2];
      q.push({u.xx, u.yy + i});
    }

    for (int i = -1; i >= -k; i--) {
      ptr++;
      if (ptr > 20000000)
        return INF;
      if (!valid(u.xx, u.yy + i))
        break;
      if (dp[u.xx][u.yy + i] != -1)
        continue;
      dp[u.xx][u.yy + i] = dp[u.xx][u.yy] + 1;
      if (u.xx == x2 && u.yy + i == y2)
        return dp[x2][y2];
      q.push({u.xx, u.yy + i});
    }

    for (int i = 1; i <= k; i++) {
      ptr++;
      if (ptr > 20000000)
        return INF;
      if (!valid(u.xx + i, u.yy))
        break;
      if (dp[u.xx + i][u.yy] != -1)
        continue;
      dp[u.xx + i][u.yy] = dp[u.xx][u.yy] + 1;
      if (u.xx + i == x2 && u.yy == y2)
        return dp[x2][y2];
      q.push({u.xx + i, u.yy});
    }

    for (int i = -1; i >= -k; i--) {
      ptr++;
      if (ptr > 20000000)
        return INF;
      if (!valid(u.xx + i, u.yy))
        break;
      if (dp[u.xx + i][u.yy] != -1)
        continue;
      dp[u.xx + i][u.yy] = dp[u.xx][u.yy] + 1;
      if (u.xx + i == x2 && u.yy == y2)
        return dp[x2][y2];
      q.push({u.xx + i, u.yy});
    }
  }
  return dp[x2][y2];
}

int main() {
  // IOS;
  /*
      #ifndef ONLINE_JUDGE
        READ;
        WRITE;
      #endif
  */

  sciii(n, m, k);
  scii(x1, lol);
  scii(x2, y2);
  char buffer[m + 5];
  x1--;
  x2--;
  lol--;
  y2--;

  string s;

  for (int i = 0; i < n; i++) {
    scanf("%s", buffer);
    s = buffer;
    grid.pb(s);
  }

  ll ans = bfs(x1, lol);
  ans = min(bfs2(x2, y2), ans);
  ans = min(ans, bfs3(x1, lol));
  printf("%lld\\n", ans);

  return 0;
}


Error: TLE

Fixed submission:

// Bismillahir Rahmanir Rahim

// #pragma GCC optimize("Ofast,unroll-loops")
// #pragma GCC target("avx,avx2,fma")

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define xx first
#define yy second
#define sci(n) scanf("%d", &n)
#define scii(n, m) scanf("%d%d", &n, &m)
#define sciii(n, m, w) scanf("%d%d%d", &n, &m, &w)
#define scl(n) scanf("%lld", &n)
#define scll(n, m) scanf("%lld%lld", &n, &m)
#define sclll(n, m, w) scanf("%lld%lld%lld", &n, &m, &w)
#define pf(a) printf("%d\\n", a)
#define CASE(a) printf("Case %d: ", a)
#define dbg(i) printf("yo %d\\n", i)
#define endl '\\n'
#define READ freopen("input.txt", "r", stdin)
#define WRITE freopen("output.txt", "w", stdout);
#define pi acos(-1)
#define mem(a, b) memset(a, b, sizeof(a))
#define SQR(a) (a) * (a)
#define all(v) v.begin(), v.end()
#define pb push_back
#define pri priority_queue<int>
#define rev_pri priority_queue<int, vector<int>, greater<int>>
#define IOS                                                                    \\
  ios_base::sync_with_stdio(false);                                            \\
  cin.tie(NULL);                                                               \\
  cout.tie(NULL);
#define mod 1000000007
#define inf INT_MAX
#define eps 1e-9

using namespace __gnu_pbds;
using namespace std;

// ll ncr(ll n,ll r){if(n==r)return 1;if(r==1)return n;if(dp[n][r]!=-1)return
// dp[n][r];return dp[n][r]=ncr(n-1,r)+ncr(n-1,r-1);}

// bit manipulations

// bool checkbit(int mask,int bit){return mask & (1<<bit);}
// int setbit(int mask,int bit){ return mask | (1<<bit) ; }
// int clearbit(int mask,int bit){return mask & ~(1<<bit);}
// int togglebit(int mask,int bit){return mask ^ (1<<bit);}
// int bitno(int mask) {return (int)__builtin_popcount(mask);}

template <typename T> T BigMod(T b, T p, T m) {
  if (p == 0)
    return 1;
  if (p % 2 == 0) {
    T s = BigMod(b, p / 2, m);
    return ((s % m) * (s % m)) % m;
  }
  return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T> T ModInv(T b, T m) { return BigMod(b, m - 2, m); }
template <typename T> T in() {
  char ch;
  T n = 0;
  bool ng = false;
  while (1) {
    ch = getchar();
    if (ch == '-') {
      ng = true;
      ch = getchar();
      break;
    }
    if (ch >= '0' && ch <= '9')
      break;
  }
  while (1) {
    n = n * 10 + (ch - '0');
    ch = getchar();
    if (ch < '0' || ch > '9')
      break;
  }
  return (ng ? -n : n);
}
template <typename T> T POW(T B, T P) {
  if (P == 0)
    return 1;
  if (P & 1)
    return B * POW(B, P - 1);
  else
    return SQR(POW(B, P / 2));
}
template <typename T> T Bigmod(T b, T p, T m) {
  if (p == 0)
    return 1;
  else if (!(p & 1))
    return SQR(Bigmod(b, p / 2, m)) % m;
  else
    return ((b % m) * Bigmod(b, p - 1, m)) % m;
}
template <typename T> T Dis(T x1, T lol, T x2, T y2) {
  return sqrt(SQR(x1 - x2) + SQR(lol - y2));
}
template <typename T> T Angle(T x1, T lol, T x2, T y2) {
  return atan(double(lol - y2) / double(x1 - x2));
}
template <typename T> T DIFF(T a, T b) {
  T d = a - b;
  if (d < 0)
    return -d;
  else
    return d;
}
template <typename T> T ABS(T a) {
  if (a < 0)
    return -a;
  else
    return a;
}
template <typename T> T gcd(T a, T b) {
  if (a < 0)
    return gcd(-a, b);
  if (b < 0)
    return gcd(a, -b);
  return (b == 0) ? a : gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) {
  if (a < 0)
    return lcm(-a, b);
  if (b < 0)
    return lcm(a, -b);
  return a * (b / gcd(a, b));
}
template <typename T> T euclide(T a, T b, T &x, T &y) {
  if (a < 0) {
    T d = euclide(-a, b, x, y);
    x = -x;
    return d;
  }
  if (b < 0) {
    T d = euclide(a, -b, x, y);
    y = -y;
    return d;
  }
  if (b == 0) {
    x = 1;
    y = 0;
    return a;
  } else {
    T d = euclide(b, a % b, x, y);
    T t = x;
    x = y;
    y = t - (a / b) * y;
    return d;
  }
}
template <typename T> void ia(T a[], int n) {
  for (int i = 0; i < n; i++)
    cin >> a[i];
}
template <typename T> void pa(T a[], int n) {
  for (int i = 0; i < n - 1; i++)
    cout << a[i] << " ";
  cout << a[n - 1] << endl;
}
template <typename T> ll isLeft(T a, T b, T c) {
  return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

///********************************MY CODE STARTS
///HERE********************************///

#define mxn 100005

vector<string> grid;
int n, m, k;
int x1, x2, lol, y2;

bool valid(int x, int y) {

  if (x < 0 || y < 0 || x >= n || y >= m || grid[x][y] != '.')
    return false;
  return true;
}

int bfs(int sx, int sy) {
  ll dp[n + 5][m + 5];

  mem(dp, -1);
  queue<pii> q;
  q.push({sx, sy});
  dp[sx][sy] = 0;

  while (!q.empty()) {
    pii u = q.front();
    q.pop();

    for (int i = 1; i <= k; i++) {
      if (!valid(u.xx, u.yy + i))
        break;
      if (dp[u.xx][u.yy + i] != -1)
        continue;
      dp[u.xx][u.yy + i] = dp[u.xx][u.yy] + 1;
      if (u.xx == x2 && u.yy + i == y2)
        return dp[x2][y2];
      q.push({u.xx, u.yy + i});
    }

    for (int i = -1; i >= -k; i--) {
      if (!valid(u.xx, u.yy + i))
        break;
      if (dp[u.xx][u.yy + i] != -1)
        continue;
      dp[u.xx][u.yy + i] = dp[u.xx][u.yy] + 1;
      if (u.xx == x2 && u.yy + i == y2)
        return dp[x2][y2];
      q.push({u.xx, u.yy + i});
    }

    for (int i = 1; i <= k; i++) {
      if (!valid(u.xx + i, u.yy))
        break;
      if (dp[u.xx + i][u.yy] != -1)
        continue;
      dp[u.xx + i][u.yy] = dp[u.xx][u.yy] + 1;
      if (u.xx + i == x2 && u.yy == y2)
        return dp[x2][y2];
      q.push({u.xx + i, u.yy});
    }

    for (int i = -1; i >= -k; i--) {
      if (!valid(u.xx + i, u.yy))
        break;
      if (dp[u.xx + i][u.yy] != -1)
        continue;
      dp[u.xx + i][u.yy] = dp[u.xx][u.yy] + 1;
      if (u.xx + i == x2 && u.yy == y2)
        return dp[x2][y2];
      q.push({u.xx + i, u.yy});
    }
  }
  return dp[x2][y2];
}

int main() {
  // IOS;
  /*
      #ifndef ONLINE_JUDGE
        READ;
        WRITE;
      #endif
  */

  sciii(n, m, k);
  scii(x1, lol);
  scii(x2, y2);
  char buffer[m + 5];
  x1--;
  x2--;
  lol--;
  y2--;

  string s;

  for (int i = 0; i < n; i++) {
    scanf("%s", buffer);
    s = buffer;
    grid.pb(s);
  }

  ll ans = bfs(x1, lol);
  printf("%lld\\n", ans);

  return 0;
}