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

// Author: Pakhomovee
#include <algorithm>
#include <assert.h>
#include <chrono>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace std;
using namespace std::chrono;

void solve() {
  auto start = system_clock::now();
  int h, w, k;
  cin >> h >> w >> k;
  int x1, y1, x2, y2;
  cin >> x1 >> y1 >> x2 >> y2;
  vector<vector<bool>> matr(h, vector<bool>(w, true));
  for (int i = 0; i < h; ++i) {
    for (int j = 0; j < w; ++j) {
      char x;
      cin >> x;
      if (x == '@') {
        matr[i][j] = false;
      }
    }
  }

  deque<pair<int, int>> q1;
  vector<vector<int>> dist1(h, vector<int>(w, 1e9));
  dist1[x1 - 1][y1 - 1] = 0;
  q1.push_back({x1 - 1, y1 - 1});
  while (!q1.empty()) {
    auto end = system_clock::now();
    if (duration_cast<milliseconds>(end - start).count() > 2000) {
      break;
    }
    pair<int, int> x = q1.front();
    q1.pop_front();
    for (int i = 1; i <= 1; ++i) {
      if (x.first - i >= 0 && matr[x.first - i][x.second]) {
        if (dist1[x.first - i][x.second] > dist1[x.first][x.second] + 1) {
          dist1[x.first - i][x.second] = dist1[x.first][x.second] + 1;
          q1.push_back({x.first - i, x.second});
        }
      }
      if (x.second - i >= 0 && matr[x.first][x.second - i]) {
        if (dist1[x.first][x.second - i] > dist1[x.first][x.second] + 1) {
          dist1[x.first][x.second - i] = dist1[x.first][x.second] + 1;
          q1.push_back({x.first, x.second - i});
        }
      }
      if (x.first + i < h && matr[x.first + i][x.second]) {
        if (dist1[x.first + i][x.second] > dist1[x.first][x.second] + 1) {
          dist1[x.first + i][x.second] = dist1[x.first][x.second] + 1;
          q1.push_back({x.first + i, x.second});
        }
      }
      if (x.second + i < w && matr[x.first][x.second + i]) {
        if (dist1[x.first][x.second + i] > dist1[x.first][x.second] + 1) {
          dist1[x.first][x.second + i] = dist1[x.first][x.second] + 1;
          q1.push_back({x.first, x.second + i});
        }
      }
    }
  }

  if (dist1[x2 - 1][y2 - 1] == 1e9) {
    cout << -1;
    return;
  }

  deque<pair<int, int>> q;
  vector<vector<int>> dist(h, vector<int>(w, 1e9));
  dist[x1 - 1][y1 - 1] = 0;
  q.push_back({x1 - 1, y1 - 1});
  while (!q.empty()) {
    auto end = system_clock::now();
    if (duration_cast<milliseconds>(end - start).count() > 2000) {
      break;
    }
    pair<int, int> x = q.front();
    if (x.first == x2 - 1 && x.second == y2 - 1) {
      cout << dist[x2 - 1][y2 - 1];
      return;
    }
    q.pop_front();
    vector<bool> ok(4, true);
    for (int i = 1; i <= k; ++i) {
      if (x.first - i >= 0 && ok[0]) {
        if (!matr[x.first - i][x.second]) {
          ok[0] = false;
        } else if (dist[x.first - i][x.second] > dist[x.first][x.second] + 1) {
          dist[x.first - i][x.second] = dist[x.first][x.second] + 1;
          q.push_back({x.first - i, x.second});
        }
      }
      if (x.second - i >= 0 && ok[1]) {
        if (!matr[x.first][x.second - i]) {
          ok[1] = false;
        } else if (dist[x.first][x.second - i] > dist[x.first][x.second] + 1) {
          dist[x.first][x.second - i] = dist[x.first][x.second] + 1;
          q.push_back({x.first, x.second - i});
        }
      }
      if (x.first + i < h && ok[2]) {
        if (!matr[x.first + i][x.second]) {
          ok[2] = false;
        } else if (dist[x.first + i][x.second] > dist[x.first][x.second] + 1) {
          dist[x.first + i][x.second] = dist[x.first][x.second] + 1;
          q.push_back({x.first + i, x.second});
        }
      }
      if (x.second + i < w && ok[3]) {
        if (!matr[x.first][x.second + i]) {
          ok[3] = false;
        } else if (dist[x.first][x.second + i] > dist[x.first][x.second] + 1) {
          dist[x.first][x.second + i] = dist[x.first][x.second] + 1;
          q.push_back({x.first, x.second + i});
        }
      }
    }
  }
  if (true) {
    deque<pair<int, int>> q1;
    vector<vector<int>> dist1(h, vector<int>(w, 1e9));
    dist1[x1 - 1][y1 - 1] = 0;
    q1.push_back({x1 - 1, y1 - 1});
    while (!q1.empty()) {
      pair<int, int> x = q1.front();
      q1.pop_front();
      for (int i = 1; i <= 1; ++i) {
        if (x.first - i >= 0 && matr[x.first - i][x.second]) {
          if (dist1[x.first - i][x.second] > dist1[x.first][x.second] + 1) {
            dist1[x.first - i][x.second] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first - i, x.second});
          }
        }
        if (x.second - i >= 0 && matr[x.first][x.second - i]) {
          if (dist1[x.first][x.second - i] > dist1[x.first][x.second] + 1) {
            dist1[x.first][x.second - i] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first, x.second - i});
          }
        }
        if (x.first + i < h && matr[x.first + i][x.second]) {
          if (dist1[x.first + i][x.second] > dist1[x.first][x.second] + 1) {
            dist1[x.first + i][x.second] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first + i, x.second});
          }
        }
        if (x.second + i < w && matr[x.first][x.second + i]) {
          if (dist1[x.first][x.second + i] > dist1[x.first][x.second] + 1) {
            dist1[x.first][x.second + i] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first, x.second + i});
          }
        }
      }
    }

    if (dist1[x2 - 1][y2 - 1] == 1e9) {
      cout << -1;
      return;
    }

    deque<pair<int, int>> q;
    vector<vector<int>> dist(h, vector<int>(w, 1e9));
    dist[x1 - 1][y1 - 1] = 0;
    q.push_back({x1 - 1, y1 - 1});
    while (!q.empty()) {
      pair<int, int> x = q.front();
      if (x.first == x2 - 1 && x.second == y2 - 1) {
        cout << dist[x2 - 1][y2 - 1];
        return;
      }
      q.pop_front();
      vector<bool> ok(4, true);
      for (int i = 1;; ++i) {
        if (!ok[0] && !ok[1] && !ok[2] && !ok[3]) {
          break;
        }
        if (x.first - i >= 0 && ok[0]) {
          if (!matr[x.first - i][x.second]) {
            ok[0] = false;
          } else if (dist[x.first - i][x.second] >
                     dist[x.first][x.second] + (i + k - 1) / k) {
            dist[x.first - i][x.second] =
                dist[x.first][x.second] + (i + k - 1) / k;
            q.push_back({x.first - i, x.second});
          } else {
            ok[0] = false;
          }
        } else {
          ok[0] = false;
        }
        if (x.second - i >= 0 && ok[1]) {
          if (!matr[x.first][x.second - i]) {
            ok[1] = false;
          } else if (dist[x.first][x.second - i] >
                     dist[x.first][x.second] + (i + k - 1) / k) {
            dist[x.first][x.second - i] =
                dist[x.first][x.second] + (i + k - 1) / k;
            q.push_back({x.first, x.second - i});
          } else {
            ok[1] = false;
          }
        } else {
          ok[1] = false;
        }
        if (x.first + i < h && ok[2]) {
          if (!matr[x.first + i][x.second]) {
            ok[2] = false;
          } else if (dist[x.first + i][x.second] >
                     dist[x.first][x.second] + (i + k - 1) / k) {
            dist[x.first + i][x.second] =
                dist[x.first][x.second] + (i + k - 1) / k;
            q.push_back({x.first + i, x.second});
          } else {
            ok[2] = false;
          }
        } else {
          ok[2] = false;
        }
        if (x.second + i < w && ok[3]) {
          if (!matr[x.first][x.second + i]) {
            ok[3] = false;
          } else if (dist[x.first][x.second + i] >
                     dist[x.first][x.second] + (i + k - 1) / k) {
            dist[x.first][x.second + i] =
                dist[x.first][x.second] + (i + k - 1) / k;
            q.push_back({x.first, x.second + i});
          } else {
            ok[3] = false;
          }
        } else {
          ok[3] = false;
        }
      }
    }
  }
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  auto start = system_clock::now();

  solve();

  auto end = system_clock::now();
  cerr << "Time: " << duration_cast<milliseconds>(end - start).count() << "ms"
       << endl;
}


Error: TLE

Fixed submission:

// Author: Pakhomovee
#include <algorithm>
#include <assert.h>
#include <chrono>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace std;
using namespace std::chrono;

void solve() {
  int h, w, k;
  cin >> h >> w >> k;
  int x1, y1, x2, y2;
  cin >> x1 >> y1 >> x2 >> y2;
  vector<vector<bool>> matr(h, vector<bool>(w, true));
  for (int i = 0; i < h; ++i) {
    for (int j = 0; j < w; ++j) {
      char x;
      cin >> x;
      if (x == '@') {
        matr[i][j] = false;
      }
    }
  }
  if (h < 100 || w < 100) {
    deque<pair<int, int>> q1;
    vector<vector<int>> dist1(h, vector<int>(w, 1e9));
    dist1[x1 - 1][y1 - 1] = 0;
    q1.push_back({x1 - 1, y1 - 1});
    while (!q1.empty()) {
      pair<int, int> x = q1.front();
      q1.pop_front();
      for (int i = 1; i <= 1; ++i) {
        if (x.first - i >= 0 && matr[x.first - i][x.second]) {
          if (dist1[x.first - i][x.second] > dist1[x.first][x.second] + 1) {
            dist1[x.first - i][x.second] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first - i, x.second});
          }
        }
        if (x.second - i >= 0 && matr[x.first][x.second - i]) {
          if (dist1[x.first][x.second - i] > dist1[x.first][x.second] + 1) {
            dist1[x.first][x.second - i] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first, x.second - i});
          }
        }
        if (x.first + i < h && matr[x.first + i][x.second]) {
          if (dist1[x.first + i][x.second] > dist1[x.first][x.second] + 1) {
            dist1[x.first + i][x.second] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first + i, x.second});
          }
        }
        if (x.second + i < w && matr[x.first][x.second + i]) {
          if (dist1[x.first][x.second + i] > dist1[x.first][x.second] + 1) {
            dist1[x.first][x.second + i] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first, x.second + i});
          }
        }
      }
    }

    if (dist1[x2 - 1][y2 - 1] == 1e9) {
      cout << -1;
      return;
    }

    deque<pair<int, int>> q;
    vector<vector<int>> dist(h, vector<int>(w, 1e9));
    dist[x1 - 1][y1 - 1] = 0;
    q.push_back({x1 - 1, y1 - 1});
    while (!q.empty()) {
      pair<int, int> x = q.front();
      if (x.first == x2 - 1 && x.second == y2 - 1) {
        cout << dist[x2 - 1][y2 - 1];
        return;
      }
      q.pop_front();
      vector<bool> ok(4, true);
      for (int i = 1;; ++i) {
        if (!ok[0] && !ok[1] && !ok[2] && !ok[3]) {
          break;
        }
        if (x.first - i >= 0 && ok[0]) {
          if (!matr[x.first - i][x.second]) {
            ok[0] = false;
          } else if (dist[x.first - i][x.second] >
                     dist[x.first][x.second] + (i + k - 1) / k) {
            dist[x.first - i][x.second] =
                dist[x.first][x.second] + (i + k - 1) / k;
            q.push_back({x.first - i, x.second});
          } else {
            ok[0] = false;
          }
        } else {
          ok[0] = false;
        }
        if (x.second - i >= 0 && ok[1]) {
          if (!matr[x.first][x.second - i]) {
            ok[1] = false;
          } else if (dist[x.first][x.second - i] >
                     dist[x.first][x.second] + (i + k - 1) / k) {
            dist[x.first][x.second - i] =
                dist[x.first][x.second] + (i + k - 1) / k;
            q.push_back({x.first, x.second - i});
          } else {
            ok[1] = false;
          }
        } else {
          ok[1] = false;
        }
        if (x.first + i < h && ok[2]) {
          if (!matr[x.first + i][x.second]) {
            ok[2] = false;
          } else if (dist[x.first + i][x.second] >
                     dist[x.first][x.second] + (i + k - 1) / k) {
            dist[x.first + i][x.second] =
                dist[x.first][x.second] + (i + k - 1) / k;
            q.push_back({x.first + i, x.second});
          } else {
            ok[2] = false;
          }
        } else {
          ok[2] = false;
        }
        if (x.second + i < w && ok[3]) {
          if (!matr[x.first][x.second + i]) {
            ok[3] = false;
          } else if (dist[x.first][x.second + i] >
                     dist[x.first][x.second] + (i + k - 1) / k) {
            dist[x.first][x.second + i] =
                dist[x.first][x.second] + (i + k - 1) / k;
            q.push_back({x.first, x.second + i});
          } else {
            ok[3] = false;
          }
        } else {
          ok[3] = false;
        }
      }
    }
  } else {
    deque<pair<int, int>> q1;
    vector<vector<int>> dist1(h, vector<int>(w, 1e9));
    dist1[x1 - 1][y1 - 1] = 0;
    q1.push_back({x1 - 1, y1 - 1});
    while (!q1.empty()) {
      pair<int, int> x = q1.front();
      q1.pop_front();
      for (int i = 1; i <= 1; ++i) {
        if (x.first - i >= 0 && matr[x.first - i][x.second]) {
          if (dist1[x.first - i][x.second] > dist1[x.first][x.second] + 1) {
            dist1[x.first - i][x.second] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first - i, x.second});
          }
        }
        if (x.second - i >= 0 && matr[x.first][x.second - i]) {
          if (dist1[x.first][x.second - i] > dist1[x.first][x.second] + 1) {
            dist1[x.first][x.second - i] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first, x.second - i});
          }
        }
        if (x.first + i < h && matr[x.first + i][x.second]) {
          if (dist1[x.first + i][x.second] > dist1[x.first][x.second] + 1) {
            dist1[x.first + i][x.second] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first + i, x.second});
          }
        }
        if (x.second + i < w && matr[x.first][x.second + i]) {
          if (dist1[x.first][x.second + i] > dist1[x.first][x.second] + 1) {
            dist1[x.first][x.second + i] = dist1[x.first][x.second] + 1;
            q1.push_back({x.first, x.second + i});
          }
        }
      }
    }

    if (dist1[x2 - 1][y2 - 1] == 1e9) {
      cout << -1;
      return;
    }

    deque<pair<int, int>> q;
    vector<vector<int>> dist(h, vector<int>(w, 1e9));
    dist[x1 - 1][y1 - 1] = 0;
    q.push_back({x1 - 1, y1 - 1});
    while (!q.empty()) {
      pair<int, int> x = q.front();
      if (x.first == x2 - 1 && x.second == y2 - 1) {
        cout << dist[x2 - 1][y2 - 1];
        return;
      }
      q.pop_front();
      vector<bool> ok(4, true);
      for (int i = 1; i <= k; ++i) {
        if (x.first - i >= 0 && ok[0]) {
          if (!matr[x.first - i][x.second]) {
            ok[0] = false;
          } else if (dist[x.first - i][x.second] >
                     dist[x.first][x.second] + 1) {
            dist[x.first - i][x.second] = dist[x.first][x.second] + 1;
            q.push_back({x.first - i, x.second});
          }
        }
        if (x.second - i >= 0 && ok[1]) {
          if (!matr[x.first][x.second - i]) {
            ok[1] = false;
          } else if (dist[x.first][x.second - i] >
                     dist[x.first][x.second] + 1) {
            dist[x.first][x.second - i] = dist[x.first][x.second] + 1;
            q.push_back({x.first, x.second - i});
          }
        }
        if (x.first + i < h && ok[2]) {
          if (!matr[x.first + i][x.second]) {
            ok[2] = false;
          } else if (dist[x.first + i][x.second] >
                     dist[x.first][x.second] + 1) {
            dist[x.first + i][x.second] = dist[x.first][x.second] + 1;
            q.push_back({x.first + i, x.second});
          }
        }
        if (x.second + i < w && ok[3]) {
          if (!matr[x.first][x.second + i]) {
            ok[3] = false;
          } else if (dist[x.first][x.second + i] >
                     dist[x.first][x.second] + 1) {
            dist[x.first][x.second + i] = dist[x.first][x.second] + 1;
            q.push_back({x.first, x.second + i});
          }
        }
      }
    }
  }
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  auto start = system_clock::now();

  solve();

  auto end = system_clock::now();
  cerr << "Time: " << duration_cast<milliseconds>(end - start).count() << "ms"
       << endl;
}