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

#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
using VS = vector<string>;
template <class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define eFOR(i, a, n) for (int i = (a); i <= (n); ++i)
#define rFOR(i, a, n) for (int i = (n)-1; i >= (a); --i)
#define erFOR(i, a, n) for (int i = (n); i >= (a); --i)
#define each(i, a) for (auto &i : a)
#define SORT(a) sort(a.begin(), a.end())
#define rSORT(a) sort(a.rbegin(), a.rend())
#define fSORT(a, f) sort(a.begin(), a.end(), f)
#define all(a) a.begin(), a.end()
#define out(y, x) ((y) < 0 || h <= (y) || (x) < 0 || w <= (x))
#define tp(a, i) get<i>(a)
#define line cout << "-----------------------------\\n"
#define ENDL(i, n) ((i) == (n)-1 ? "\\n" : " ")
#define stop system("pause")
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10;
constexpr ld pi = 3.1415926535897932;
template <class T> inline bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
inline void init() {
  cin.tie(nullptr);
  cout.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(15);
}
template <class T> inline istream &operator>>(istream &is, vector<T> &v) {
  for (auto &a : v)
    is >> a;
  return is;
}
template <class T> inline istream &operator>>(istream &is, deque<T> &v) {
  for (auto &a : v)
    is >> a;
  return is;
}
template <class T, class U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
  is >> p.first >> p.second;
  return is;
}
template <class T> inline vector<T> vec(size_t a) { return vector<T>(a); }
template <class T> inline vector<T> defvec(T def, size_t a) {
  return vector<T>(a, def);
}
template <class T, class... Ts> inline auto vec(size_t a, Ts... ts) {
  return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T, class... Ts> inline auto defvec(T def, size_t a, Ts... ts) {
  return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...));
}
template <class T> inline void print(const T &a) { cout << a << "\\n"; }
template <class T, class... Ts> inline void print(const T &a, const Ts &...ts) {
  cout << a << " ";
  print(ts...);
}
template <class T> inline void print(const vector<T> &v) {
  for (int i = 0; i < v.size(); ++i)
    cout << v[i] << (i == v.size() - 1 ? "\\n" : " ");
}
template <class T> inline void print(const vector<vector<T>> &v) {
  for (auto &a : v)
    print(a);
}
inline string reversed(const string &s) {
  string t = s;
  reverse(all(t));
  return t;
}

class rollinghash {
  int base1 = 1007, base2 = 2009;
  int mod1 = 1000000007, mod2 = 998244353;
  VI hash1, hash2, power1, power2;

public:
  rollinghash(const string &s) {
    int n = s.size();
    hash1.resize(n + 1);
    hash2.resize(n + 1);
    rFOR(i, 0, n) {
      hash1[i] = (ll(hash1[i + 1]) * base1 + s[i]) % mod1;
      hash2[i] = (ll(hash2[i + 1]) * base2 + s[i]) % mod2;
    }
  }
  inline pair<int, int> hash(int l, char c) const {
    return {(ll(hash1[l]) * base1 + c) % mod1,
            (ll(hash2[l]) * base2 + c) % mod2};
  }
  inline pair<int, int> hash(int l) const { return {hash1[l], hash2[l]}; }
};

int main() {
  init();

  int n;
  cin >> n;
  VS s(n);
  vector<rollinghash> h;
  h.reserve(n);
  vector<pair<int, int>> a(n);
  FOR(i, 0, n) {
    cin >> s[i];
    h.emplace_back(s[i]);
    a[i] = h[i].hash(0);
  }
  SORT(a);

  ll ans = 0;
  FOR(i, 0, n) {
    VI cnt(26);
    each(j, s[i])++ cnt[j - 'a'];
    rFOR(j, 1, s[i].length()) {
      FOR(k, 0, 26) {
        if (cnt[k] == 0)
          continue;
        auto itr = lower_bound(all(a), h[i].hash(j + 1, 'a' + k));
        if (itr != a.end() && *itr == h[i].hash(j + 1, 'a' + k))
          ++ans;
      }
      --cnt[s[i][j] - 'a'];
    }
  }
  print(ans);

  return 0;
}

Error: TLE

Fixed submission:

#include <bits/stdc++.h>
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
using VS = vector<string>;
template <class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define eFOR(i, a, n) for (int i = (a); i <= (n); ++i)
#define rFOR(i, a, n) for (int i = (n)-1; i >= (a); --i)
#define erFOR(i, a, n) for (int i = (n); i >= (a); --i)
#define each(i, a) for (auto &i : a)
#define SORT(a) sort(a.begin(), a.end())
#define rSORT(a) sort(a.rbegin(), a.rend())
#define fSORT(a, f) sort(a.begin(), a.end(), f)
#define all(a) a.begin(), a.end()
#define out(y, x) ((y) < 0 || h <= (y) || (x) < 0 || w <= (x))
#define tp(a, i) get<i>(a)
#define line cout << "-----------------------------\\n"
#define ENDL(i, n) ((i) == (n)-1 ? "\\n" : " ")
#define stop system("pause")
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10;
constexpr ld pi = 3.1415926535897932;
template <class T> inline bool chmax(T &a, const T &b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <class T> inline bool chmin(T &a, const T &b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
inline void init() {
  cin.tie(nullptr);
  cout.tie(nullptr);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(15);
}
template <class T> inline istream &operator>>(istream &is, vector<T> &v) {
  for (auto &a : v)
    is >> a;
  return is;
}
template <class T> inline istream &operator>>(istream &is, deque<T> &v) {
  for (auto &a : v)
    is >> a;
  return is;
}
template <class T, class U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
  is >> p.first >> p.second;
  return is;
}
template <class T> inline vector<T> vec(size_t a) { return vector<T>(a); }
template <class T> inline vector<T> defvec(T def, size_t a) {
  return vector<T>(a, def);
}
template <class T, class... Ts> inline auto vec(size_t a, Ts... ts) {
  return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T, class... Ts> inline auto defvec(T def, size_t a, Ts... ts) {
  return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...));
}
template <class T> inline void print(const T &a) { cout << a << "\\n"; }
template <class T, class... Ts> inline void print(const T &a, const Ts &...ts) {
  cout << a << " ";
  print(ts...);
}
template <class T> inline void print(const vector<T> &v) {
  for (int i = 0; i < v.size(); ++i)
    cout << v[i] << (i == v.size() - 1 ? "\\n" : " ");
}
template <class T> inline void print(const vector<vector<T>> &v) {
  for (auto &a : v)
    print(a);
}
inline string reversed(const string &s) {
  string t = s;
  reverse(all(t));
  return t;
}

class rollinghash {
  int base1 = 1007, base2 = 2009;
  int mod1 = 1000000007, mod2 = 998244353;
  VI hash1, hash2, power1, power2;

public:
  rollinghash(const string &s) {
    int n = s.size();
    hash1.resize(n + 1);
    hash2.resize(n + 1);
    rFOR(i, 0, n) {
      hash1[i] = (ll(hash1[i + 1]) * base1 + s[i]) % mod1;
      hash2[i] = (ll(hash2[i + 1]) * base2 + s[i]) % mod2;
    }
  }

  inline pair<int, int> hash(int l) const { return {hash1[l], hash2[l]}; }
};

int cnt[26] = {};
int main() {
  init();

  int n;
  cin >> n;
  VS s(n);
  cin >> s;
  fSORT(s, [](string &a, string &b) { return a.length() > b.length(); });
  vector<rollinghash> h;
  h.reserve(n);
  FOR(i, 0, n) h.emplace_back(s[i]);

  ll ans = 0;
  map<pair<int, int>, int> m;
  FOR(j, 0, 26) {
    FOR(i, 0, n) {
      if (s[i][0] - 'a' == j) {
        if (s[i].length() == 1) {
          ans += cnt[s[i][0] - 'a'];
        } else {
          ans += m[h[i].hash(1)];
        }
      }
      int k = 0;
      for (; k < s[i].length() && s[i][k] - 'a' != j; ++k)
        ;
      if (k != s[i].length())
        ++cnt[j];
      for (++k; k < s[i].length(); ++k) {
        ++m[h[i].hash(k)];
      }
    }
    m.clear();
  }
  print(ans);

  return 0;
}