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

#include <algorithm>
#include <chrono>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#define forr(i, start, count) for (int i = (start); i < (start) + (count); ++i)
#define set_map_includes(set, elt) (set.find((elt)) != set.end())
#define readint(i)                                                             \\
  int i;                                                                       \\
  cin >> i
#define readll(i)                                                              \\
  ll i;                                                                        \\
  cin >> i
#define readdouble(i)                                                          \\
  double i;                                                                    \\
  cin >> i
#define readstring(s)                                                          \\
  string s;                                                                    \\
  cin >> s

typedef long long ll;

using namespace std;

int main() {
  cout.precision(17);
  ll modd = 1000 * 1000 * 1000 + 7;
  mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
  uniform_int_distribution<int> rand_gen(
      0, modd); // rand_gen(rng) gets the rand no
  ll infinit = 10000000000000000;

  /*    int n = 50;
      vector<int> a(n*n);
      forr(i,0,n*n) { a[i] = i+1; }
      forr(i,0,n*n) {
          int k = rand_gen(rng) % (n*n);
          swap(a[0], a[k]);
      }

      cout << n << endl;
      for(auto x : a) {cout << x << " "; } cout << endl;
      return 0;  */

  //    readint(test_cases);

  // 3841 is correct for current ac2.in !!!!!!!

  forr(t, 1, 1) {
    readint(n);

    int ret = 0;
    vector<bool> already_gone(n * n, false);
    vector<int> answer(n * n);
    forr(i, 0, n) {
      forr(j, 0, n) { answer[n * i + j] = min({i, j, n - 1 - i, n - 1 - j}); }
    }

    forr(i, 0, n * n) {
      readint(kk);
      kk--;
      ret += answer[kk];
      already_gone[kk] = true;

      stack<int> todo;

      todo.push(kk);

      while (!todo.empty()) {
        int current = todo.top();
        todo.pop();

        int val = answer[current] + !already_gone[current];
        for (int dir : vector<int>{-1, 1, n, -n}) {
          int x = current + dir;
          if ((x >= 0) && (x < n * n) &&
              ((x % n == current % n) || (x / n == current / n))) {
            if (answer[x] > val) {
              answer[x] = val;
              todo.push(x);
            }
          }
        }
      }
    }

    cout << ret << endl;
  }
  return 0;
}


Error: TLE

Fixed submission:

#include <algorithm>
#include <chrono>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#define forr(i, start, count) for (int i = (start); i < (start) + (count); ++i)
#define set_map_includes(set, elt) (set.find((elt)) != set.end())
#define readint(i)                                                             \\
  int i;                                                                       \\
  cin >> i
#define readll(i)                                                              \\
  ll i;                                                                        \\
  cin >> i
#define readdouble(i)                                                          \\
  double i;                                                                    \\
  cin >> i
#define readstring(s)                                                          \\
  string s;                                                                    \\
  cin >> s

typedef long long ll;

using namespace std;

template <class T> class depth_first_search_iterator {
public:
  stack<pair<T, T>> todo;
  function<bool(T)> notvisited;
  function<void(T)> mark_visited;
  function<set<T>(T)> neighbors;

  depth_first_search_iterator() {}

  depth_first_search_iterator(T start, function<bool(T)> notv,
                              function<void(T)> mark_v,
                              function<set<T>(T)> neigh)
      : notvisited(notv), mark_visited(mark_v), neighbors(neigh), end_(false),
        current(start), prev(start) {
    todo.push(make_pair(start, start));
    operator++();
  }

  void operator++() {
    end_ = true;
    while (!todo.empty()) {
      current = todo.top().first;
      prev = todo.top().second;
      todo.pop();
      if (notvisited(current)) {
        mark_visited(current);
        for (const T x : neighbors(current)) {
          todo.push(make_pair(x, current));
        }
        end_ = false;
        break;
      }
    }
  }

  T operator*() { return current; }

  T previous() { return prev; }

  bool end() { return end_; }

private:
  T current; // contains current node
  T prev;    // contains previous node
  bool end_;
};

template <class T> class breadth_first_search_iterator {
public:
  queue<pair<T, T>> todo;
  function<bool(T)> notvisited;
  function<void(T)> mark_visited;
  function<set<T>(T)> neighbors;

  breadth_first_search_iterator() {}

  breadth_first_search_iterator(T start, function<bool(T)> notv,
                                function<void(T)> mark_v,
                                function<set<T>(T)> neigh)
      : notvisited(notv), mark_visited(mark_v), neighbors(neigh), end_(false),
        current(start), prev(start) {
    todo.push(make_pair(start, start));
    operator++();
  }

  void operator++() {
    end_ = true;
    while (!todo.empty()) {
      current = todo.front().first;
      prev = todo.front().second;
      todo.pop();
      if (notvisited(current)) {
        mark_visited(current);
        for (const T x : neighbors(current)) {
          todo.push(make_pair(x, current));
        }
        end_ = false;
        break;
      }
    }
  }

  T operator*() { return current; }

  T previous() { return prev; }

  bool end() { return end_; }

private:
  T current; // current node
  T prev;    // previous node
  bool end_;
};

template <class T> class Graph {
  // allows only single connection between two vertices
public:
  vector<T> vertices;
  vector<set<int>> neighbors;
  depth_first_search_iterator<int> dfs_iterator;
  breadth_first_search_iterator<int> bfs_iterator;
  vector<bool> visited;

  Graph() {}

  Graph(int n) {
    for (int i = 0; i < n; ++i) {
      AddVertex(0);
    }
  }

  void AddVertex(T val) {
    vertices.push_back(val);
    neighbors.push_back(set<int>());
  }

  bool EdgeExists(int i, int j) {
    return (neighbors[i].find(j) != neighbors[i].end());
  }

  void AddEdge(int i, int j) {
    if (!EdgeExists(i, j)) {
      neighbors[i].insert(j);
      if (i != j) {
        neighbors[j].insert(i);
      }
    }
  }

  T &operator[](int i) { return vertices[i]; }

  void RemoveEdge(int i, int j) {
    if (EdgeExists(i, j)) {
      neighbors[i].erase(find(neighbors[i].begin(), neighbors[i].end(), j));
      neighbors[j].erase(find(neighbors[j].begin(), neighbors[j].end(), i));
    }
  }

  void dfs_init(int start) {
    visited = vector<bool>(vertices.size(), false);
    dfs_iterator = depth_first_search_iterator<int>(
        start, [this](int x) { return !visited[x]; },
        [this](int x) { visited[x] = true; },
        [this](int x) { return neighbors[x]; });
  }

  void bfs_init(int start) {
    visited = vector<bool>(vertices.size(), false);
    bfs_iterator = breadth_first_search_iterator<int>(
        start, [this](int x) { return !visited[x]; },
        [this](int x) { visited[x] = true; },
        [this](int x) { return neighbors[x]; });
  }

  void print_() {
    forr(i, 0, vertices.size()) {
      for (auto x : neighbors[i]) {
        if (i <= x) {
          cout << i << "-" << x << endl;
        }
      }
    }
  }
};

int main() {
  cout.precision(17);
  ll modd = 1000 * 1000 * 1000 + 7;
  mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
  uniform_int_distribution<int> rand_gen(
      0, modd); // rand_gen(rng) gets the rand no
  ll infinit = 10000000000000000;

  /*    int n = 50;
      vector<int> a(n*n);
      forr(i,0,n*n) { a[i] = i+1; }
      forr(i,0,n*n) {
          int k = rand_gen(rng) % (n*n);
          swap(a[0], a[k]);
      }

      cout << n << endl;
      for(auto x : a) {cout << x << " "; } cout << endl;
      return 0;  */

  //    readint(test_cases);

  // 3841 is correct for current ac2.in !!!!!!!

  forr(t, 1, 1) {
    readint(n);

    int ret = 0;
    Graph<int> g(n * n + 1);
    forr(i, 0, n) {
      forr(j, 0, n) {
        int pt = n * i + j;
        if (i > 0) {
          g.AddEdge(pt, n * (i - 1) + j);
        }
        if (i < n - 1) {
          g.AddEdge(pt, n * (i + 1) + j);
        }
        if (j > 0) {
          g.AddEdge(pt, n * i + (j - 1));
        }
        if (j < n - 1) {
          g.AddEdge(pt, n * i + (j + 1));
        }
      }
    }
    forr(i, 0, n) {
      g.AddEdge(n * n, n * (0) + i);
      g.AddEdge(n * n, n * (n - 1) + i);
      g.AddEdge(n * n, n * i + 0);
      g.AddEdge(n * n, n * i + n - 1);
    }
    vector<bool> already_gone(n * n, false);
    vector<int> answer(n * n);
    forr(i, 0, n) {
      forr(j, 0, n) { answer[n * i + j] = min({i, j, n - 1 - i, n - 1 - j}); }
    }

    forr(i, 0, n * n) {
      readint(kk);
      kk--;
      ret += answer[kk];
      already_gone[kk] = true;

      stack<int> todo;

      todo.push(kk);

      while (!todo.empty()) {
        int current = todo.top();
        todo.pop();

        int val = answer[current] + !already_gone[current];
        for (int x : g.neighbors[current]) {
          if (answer[x] > val) {
            answer[x] = val;
            todo.push(x);
          }
        }
      }
    }

    cout << ret << endl;
  }
  return 0;
}