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

#include <bits/stdc++.h>
using namespace std;

#define int long long
#define S second
#define F first
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define lb lower_bound
#define si(c) (int)((c).size())
#define lcm(a, b) (a * (b / __gcd(a, b)))
#define inf (int)(1e12)
#define endl '\\n'
#define mp make_pair
#define time(s) (double(clock() - s) / double(CLOCKS_PER_SEC))
#define debug(args...) _F(#args, args)
#define vi std::vector<int>
#define pii pair<int, int>
#define vpi vector<pii>

clock_t start;
mt19937_64 rng(chrono::system_clock::now().time_since_epoch().count());

template <typename T> void _F(const char *name, T arg1) {
  cerr << name << " = " << arg1 << endl;
}
template <typename T, typename... Args>
void _F(const char *names, T arg1, Args... args) {
  const char *name = strchr(names, ',');
  cerr.write(names, name - names) << " = " << arg1 << endl;
  _F(name + 2, args...);
}

template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &q) {
  in >> q.F >> q.S;
  return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, pair<T1, T2> &q) {
  out << q.F << " " << q.S;
  return out;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(pair<T1, T2> p1, pair<T1, T2> p2) {
  return {p1.F + p2.F, p1.S + p2.S};
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> p1, pair<T1, T2> p2) {
  return {p1.F - p2.F, p1.S - p2.S};
}

template <typename T> void Unique(vector<T> &v) {
  sort(all(v)), v.resize(distance(v.begin(), unique(all(v))));
}

void solve(int &test) {
  int n, m, k;
  cin >> n >> m >> k;
  string s[n];
  pii in, fi;
  cin >> in.first >> in.second >> fi.first >> fi.second;
  set<int> row[n], col[m];
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < m; j++)
      row[i].insert(j), col[j].insert(i);
    cin >> s[i];
  }

  in = in - mp((int)1, (int)1);
  fi = fi - mp((int)1, (int)1);
  int dis[n][m];
  memset(dis, -1, sizeof(dis));
  queue<pii> q;
  q.push(in);
  row[in.F].erase(in.S);
  col[in.S].erase(in.F);
  dis[in.F][in.S] = 0;
  while (!q.empty()) {
    int i = q.front().F;
    int j = q.front().S;
    if (i == fi.F && j == fi.S)
      break;
    // cout << q.front() << endl;
    // cout << dis[i][j] << endl;
    q.pop();
    auto it = row[i].upper_bound(j);
    while (it != end(row[i]) && s[i][*it] == '.' && abs(*it - j) <= k) {
      dis[i][*it] = dis[i][j] + 1;
      q.push(mp(i, *it));
      col[*it].erase(i);
      row[i].erase(it);
      it = row[i].upper_bound(j);
    }
    it = col[j].upper_bound(i);
    while (it != end(col[j]) && s[*it][j] == '.' && abs(*it - i) <= k) {
      dis[*it][j] = dis[i][j] + 1;
      q.push(mp(*it, j));
      row[*it].erase(j);
      col[j].erase(it);
      it = col[j].upper_bound(i);
    }
    it = col[j].upper_bound(i);
    while (si(col[j]) && it != begin(col[j]) && s[*(--it)][j] == '.' &&
           abs(*it - i) <= k) {
      dis[*it][j] = dis[i][j] + 1;
      q.push(mp(*it, j));
      row[*it].erase(j);
      col[j].erase(it);
      it = col[j].upper_bound(i);
    }
    it = row[i].upper_bound(j);
    while (si(row[i]) && it != begin(row[i]) && s[i][*(--it)] == '.' &&
           abs(*it - j) <= k) {
      dis[i][*it] = dis[i][j] + 1;
      q.push(mp(i, *it));
      col[*it].erase(i);
      row[i].erase(it);
      it = row[i].upper_bound(j);
    }
  }
  if (dis[fi.F][fi.S] != -1) {
    cout << dis[fi.F][fi.S] << endl;
  } else {
    cout << -1 << endl;
  }
}

signed main() {

  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);

  int t = 1;

  start = clock();

  cout << fixed << setprecision(20);

  // cin >> t;

  for (int i = 1; i <= t; ++i) {
    solve(i);
  }
  // cerr << time(start);
  return 0;
}


Error: TLE

Fixed submission:

// Problem : F - Pond Skater
// Contest : AtCoder - AtCoder Beginner Contest 170
// URL : https://atcoder.jp/contests/abc170/tasks/abc170_f
// Memory Limit : 1024 MB
// Time Limit : 3000 ms
// Powered by CP Editor (https://github.com/cpeditor/cpeditor)

#include <bits/stdc++.h>
using namespace std;
#define flush cin.ignore(numeric_limits<streamsize>::max(), '\\n')
#define fill(w, t) memset(w, t, sizeof(w))
#define google cout << "Case #" << countu << ": "
#define S(t) (ll) t.size()
#define bl '\\n'
#define nl cout << bl
#define cout1(a) cout << a << bl
#define cout2(a, b) cout << a << " " << b << bl
#define cout3(a, b, c) cout << a << " " << b << " " << c << bl
#define cout4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << bl
#define print(a, s, e)                                                         \\
  for (ll i = s; i <= e; i++) {                                                \\
    cout << a[i] << " ";                                                       \\
  }
#define rprint(a, s, e)                                                        \\
  for (ll i = s; i >= e; i--) {                                                \\
    cout << a[i] << " ";                                                       \\
  }
#define input(a, s, e) sfor(p, s, e) cin >> a[p]
#define all(v) v.begin(), v.end()
#define ll int
#define ldb long double
#define db double
#define ull unsigned long long
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define mk make_pair
#define pll pair<ll, ll>
#define pldb pair<ldb, ldb>
#define fi first
#define se second
#define vull vector<ull>
#define vll vector<ll>
#define vldb vector<ldb>
#define vpll vector<pll>
#define vpldb vector<pldb>
#define pqmin priority_queue<ll, vector<ll>, greater<ll>>       // minheap
#define pq priority_queue<ll>                                   // maxheap ll
#define pqpll priority_queue<pll>                               // maxheap pll
#define pqpllmin priority_queue<pll, vector<pll>, greater<pll>> // minheap pll
#define mll map<ll, ll>
#define mldb map<ldb, ldb>
#define umll unordered_map<ll, ll>
#define sll set<ll>
#define usll unordered_set<ll>
#define sfor(i, a, b) for (ll i = (a); i <= (b); ++i)
#define rfor(i, b, a) for (ll i = (b); i >= (a); --i)
const ll mod = 1e9 + 7;
const ll maxn = 1e6 + 1;
const ll llmax = (1ll << 60);
const int intmax = (1 << 30);
const ldb PI =
    3.14159265358979323846264338327950288419716939937510582097494459230781640628620899863;
// ll *fact , *ifact;
// vll primes;
// ll *spf;
// void sieve()
// {
// spf = new ll[maxn+1];
// fill(spf,0);
// spf[0]=0; spf[1]=1;
// for(ll i =2; i<=maxn; i++)
// {
// if(spf[i])
// continue;
// spf[i]=i;
// for(ll j = i*i; j<=maxn; j+=i)
// {
// if(spf[j]==0)
// spf[j]=i;
// }
// }
// for (ll p=2; p<=maxn; p++)
// if (spf[p]==p)
// primes.pb(p);
// }
// vll primes1;
// void sieve2(ll l,ll r)
// {
// bool isprime[r-l+1];
// fill(isprime,1);
// if(l==1)
// isprime[0]=false;
// ll base;
// for(ll i=0;primes[i]*primes[i]<=r;i++)
// {
// base = (l/primes[i])*primes[i];
// if(base<l)
// {
// base += primes[i];
// }
// for(long long j=base;j<=r;j+=primes[i])
// {
// isprime[j-l]=false;
// }
// if(base==primes[i]){
// isprime[base-l]=true;
// }
// }
// for(int i=0;i<r-l+1;i++)
// {
// if(isprime[i])
// primes1.pb(i+l);
// }
// }
// // void primefactorization(ll x,mll &mp)
// // {
// //      for(ll i=0;primes[i]*primes[i]<=x;i++)
// //     {
// //         while(x%primes[i]==0)
// //         {
// //             mp[primes[i]]++;
// //             x/=primes[i];
// //         }
// //     }
// //     if(x!=1)
// //     {
// //         mp[x]++;
// //     }
// // }
// void primefactorization(ll n,mll &mp)
// {
// while(n!=1)
// {
// mp[spf[n]]++;
// n/=spf[n];
// }
// }
//
// bool primeornot(ll n)
// {
// for(ll i=0;primes[i]*primes[i]<=n;i++)
// {
// if(n%primes[i]==0)
// {
// return false;
// }
// }
// return true;
// }
//
// void allfactors(vll &v,ll n)
// {
// for(ll i=1;i*i<=n;i++)
// {
// if(n%i==0)
// {
// v.pb(i);
// if(i*i!=n)
// {
// v.pb(n/i);
// }
// }
// }
// sort(v.begin(),v.end());
// }
//
// ll power(ll a,ll n)
// {
// ll res=1;
// while(n)
// {
// if(n%2){
// res=( (res%mod) * (a%mod)) % mod;
// }
// a=( (a%mod) * (a%mod) ) % mod;
// n/=2;
// }
// res%=mod;
// return res;
// }
//
// ll modInv(ll a){
// return power(a,mod-2)%mod;
// }
//
// void modFact()
// {
// ll n = maxn;
// ifact=new ll[n+1];
// fact=new ll[n+1];
// fact[0]=fact[1]=1;
// for(int i=2;i<=n;i++)
// {
// fact[i]=(i*fact[i-1])%mod;
// }
// ifact[n]=modInv(fact[n]);
// for(int i=n-1;i>=0;i--)
// {
// ifact[i]=((i+1)*ifact[i+1])%mod;
// }
// }
//
// ll ncr(ll n, ll r)
// {
// if(n<r || r<0)
// return 0;
// ll ans=fact[n];
// ans*=ifact[r];
// ans%=mod;
// ans*=ifact[n-r];
// ans%=mod;
// return ans;
// }
//
// ll npr(ll n, ll r)
// {
// if(n<r || r<0)
// return 0;
// ll ans=fact[n];
// ans*=ifact[n-r];
// return ans%mod;
// }
//
// ll lcm(ll a,ll b)
// {
// ll x=__gcd(a,b);
// a/=x;
// b/=x;
// ll sum=a*b*x;
// return sum;
// }
//
// bool ispalindrome(string str,ll l,ll r)
// {
// while(l<=r)
// {
// if(str[l]!=str[r])
// return false;
// l++;
// r--;
// }
// return true;
// }
//
// ll reversenum(ll n)
// {
// ll ans=0;
// while(n)
// {
// ans= (ans*10)+n%10;
// n/=10;
// }
// return ans;
// }
//
// void fraction(string &str, ll &num,ll &den)
// {
// ll n = str.length();
// ll count_after_dot = 0;
// bool dot_seen = false;
//
// for (ll i = 0; i < n; i++)
// {
// if (str[i] != '.')
// {
// num = num*10 + (str[i] - '0');
// if (dot_seen == true)
// count_after_dot++;
// }
// else
// dot_seen = true;
// }
// if (dot_seen == false)
// {
// den=1;
// return;
// }
// ll dem = (ll)pow(10, count_after_dot);
// ll g = __gcd(num, dem);
// num=num/g;
// den = dem/g;
// return;
// }
//
// string convert_to_bit(ll a,int bit)
// {
// string s;
// while(a>0){
// s+=(a%2)+48;
// a/=2;
// }
// while(s.size()<bit)
// s+='0';
// reverse(s.begin(),s.end());
// return s;
// }
//
// string tobinary(ll n)
// {
// if (n==0) return "0";
// else if (n==1) return "1";
// else if (n%2 == 0) return tobinary(n/2) + "0";
// else if (n%2 != 0) return tobinary(n/2) + "1";
// }
// #define countsetbit  __builtin_popcount
//
// ll countbit(ll n)
// {
// return (ll)log2(n)+1;
// }
//
// ll setbit(ll n, ll k)
// {
// return (n | (1 << (k - 1)));
// }
//
// ll clearbit(ll n, ll k)
// {
// return (n & (~(1 << (k - 1))));
// }
//
// ll togglebit(ll n, ll k)
// {
// return (n ^ (1 << (k - 1)));
// }
// ifstream cin("b_read_on.txt"); ofstream cout("output3.txt");
// Use (<<) for multiplication
// Use (>>) for division
// ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);cout<<fixed;cerr.tie(NULL);
// find_by_order -> value at index
// order_of_key -> index of value
// while using (1<<i) use ((ll)1<<(ll)i)
// in Floyd-Warshall Algo, k is outer loop
// If an element was not initially in map and if asked mp[a],the element gets
// inserted a%=mod take a lot of time... try to use it minimum and use memset as
// it reduces a lot of time usage...use if(a>=mod) a%=mod
// cout<<(double) can be harmful , always use printf(%.9llf)...take
// scanf("%lf",&p[i][j]) as input , not llf; use s.erase(it++) for erasing
// iterator and then moving to the next one never use adj.resize(n) as value is
// persistent, always erase use __builtin_popcountll() for ll
// no of prime numbers in range : (70,19) , (1000,168) , (100000,1229) ,
// (sqrt(10^9),3409) ;
// always check the use of segment tree using bottom-up dp

// ll h,w;

void solve(ll countu) {
  ll h, w, k;
  cin >> h >> w >> k;
  ll x1, y1, x2, y2;
  cin >> x1 >> y1 >> x2 >> y2;
  x1--;
  y1--;
  x2--;
  y2--;
  string str[h];
  sfor(i, 0, h - 1) { cin >> str[i]; }
  ll ans[h][w];
  ans[x2][y2] = -1;
  bool vis[h][w];
  fill(vis, 0);
  queue<pll> t;
  vis[x1][y1] = 1;
  ans[x1][y1] = 0;
  t.push({x1, y1});
  while (S(t)) {
    pll p = t.front();
    t.pop();
    // ll tx = p.fi,ty=p.se;
    if (p.fi == x2 && p.se == y2)
      break;
    bool f1 = 1, f2 = 1, f3 = 1, f4 = 1;
    for (ll i = 1; i <= k && p.fi + i < h; i++) {
      if (!f1)
        break;
      if (str[p.fi + i][p.se] == '@')
        f1 = false;
      if (vis[p.fi + i][p.se] == 0 && str[p.fi + i][p.se] == '.') {
        ans[p.fi + i][p.se] = ans[p.fi][p.se] + 1;
        if (p.fi + i == x2 && p.se == y2) {
          cout << ans[x2][y2];
          return;
        }
        vis[p.fi + i][p.se] = 1;
        t.push({p.fi + i, p.se});
      }
    }
    for (ll i = 1; i <= k && p.fi - i >= 0; i++) {
      if (!f2)
        break;
      if (str[p.fi - i][p.se] == '@')
        f2 = false;
      if (vis[p.fi - i][p.se] == 0 && str[p.fi - i][p.se] == '.') {
        ans[p.fi - i][p.se] = ans[p.fi][p.se] + 1;
        if (p.fi - i == x2 && p.se == y2) {
          cout << ans[x2][y2];
          return;
        }
        vis[p.fi - i][p.se] = 1;
        t.push({p.fi - i, p.se});
      }
    }
    for (ll i = 1; i <= k && p.se - i >= 0; i++) {
      if (!f3)
        break;
      if (str[p.fi][p.se - i] == '@')
        f3 = false;
      if (vis[p.fi][p.se - i] == 0 && str[p.fi][p.se - i] == '.') {
        ans[p.fi][p.se - i] = ans[p.fi][p.se] + 1;
        if (p.fi == x2 && p.se - i == y2) {
          cout << ans[x2][y2];
          return;
        }
        vis[p.fi][p.se - i] = 1;
        t.push({p.fi, p.se - i});
      }
    }
    for (ll i = 1; i <= k && p.se + i < w; i++) {
      if (!f4)
        break;
      if (str[p.fi][p.se + i] == '@')
        f4 = false;
      if (vis[p.fi][p.se + i] == 0 && str[p.fi][p.se + i] == '.') {
        ans[p.fi][p.se + i] = ans[p.fi][p.se] + 1;
        if (p.fi == x2 && p.se + i == y2) {
          cout << ans[x2][y2];
          return;
        }
        vis[p.fi][p.se + i] = 1;
        t.push({p.fi, p.se + i});
      }
    }
  }
  cout << ans[x2][y2];
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  srand(time(0));

  ll t = 1;
  // cin>>t;
  sfor(i, 1, t) solve(i);

  return 0;
}