Suffix Array
(src/string/suffix_array.hpp)

• View this file on GitHub
• Last update: 2022-04-06 15:02:09+09:00
• Include: #include "src/string/suffix_array.hpp"

Depends on

• SFINAE (src/utils/sfinae.hpp)

Verified with

• test/library-checker/number_of_substrings.test.cpp
• test/library-checker/suffix_array.test.cpp

Code

#pragma once

/*
 * @file suffix_array.hpp
 * @brief Suffix Array
 */

#include <algorithm>
#include <numeric>
#include <vector>

#include "../utils/sfinae.hpp"

namespace workspace {

/*
 * @class suffix_array
 * @brief construct SA and LCP array.
 * @tparam str_type the type of string
 */
template <class str_type> class suffix_array {
  str_type str;
  std::vector<size_t> sa, rank, lcp;

  void construct_sa() {
    std::iota(sa.begin(), sa.end(), 0);
    std::sort(sa.begin(), sa.end(),
              [&](size_t i, size_t j) { return str[i] < str[j]; });

    for (size_t r{1}, c{}, *ptr{&sa.front()}, *tmp{ptr}; c != size();
         ++r, ptr = tmp)
      while (c != size() && str[*ptr] == str[*tmp]) ++c, rank[*tmp++] = r;

    for (size_t k{1}; k < size(); k <<= 1) {
      auto comp = [&](size_t i, size_t j) -> bool {
        if (rank[i] != rank[j]) return rank[i] < rank[j];
        return (i + k < size() ? rank[i + k] : 0) <
               (j + k < size() ? rank[j + k] : 0);
      };
      std::sort(sa.begin(), sa.end(), comp);

      std::vector<size_t> next_rank(size());
      for (size_t r{1}, c{}, *ptr{&sa.front()}, *tmp{ptr}; c != size();
           ++r, ptr = tmp)
        while (c != size() && !comp(*ptr, *tmp)) ++c, next_rank[*tmp++] = r;
      rank.swap(next_rank);
    }

    sa.emplace(sa.begin(), size());
    rank.emplace_back(0);
  }

  void construct_lcp() {
    for (size_t i{}, h{}; i != size(); ++i, h = h ? h - 1 : 0) {
      for (size_t j{sa[rank[i] - 1] + h}; i + h != size() && j != size();
           ++j, ++h)
        if (str[i + h] != str[j]) break;
      lcp[rank[i] - 1] = h;
    }
  }

 public:
  static constexpr size_t npos = -1;
  using char_type = element_type<str_type>;

  std::vector<size_t>::const_iterator begin() const { return sa.begin() + 1; }

  std::vector<size_t>::const_iterator end() const { return sa.end(); }

  /*
   * @fn operator[]
   * @brief find the i-th suffix
   * @param i the rank
   * @return index of the suffix
   */
  size_t operator[](size_t i) const { return sa[i + 1]; }

  /*
   * @fn size
   * @return length of the string
   */
  size_t size() const { return std::size(str); }

  template <class type = str_type, typename = typename type::value_type>
  suffix_array(const str_type &_str)
      : str(_str), sa(size()), rank(size()), lcp(size()) {
    construct_sa();
    construct_lcp();
  }

  template <class type = str_type, std::enable_if_t<std::is_array<type>::value,
                                                    std::nullptr_t> = nullptr>
  suffix_array(const str_type &_str) : sa(size()), rank(size()), lcp(size()) {
    std::copy(std::begin(_str), std::end(_str), str);
    construct_sa();
    construct_lcp();
  }

  /*
   * @fn find
   * @brief find (key) as a substring
   * @param key
   * @return index if found, npos if not found
   */
  size_t find(const str_type &key) const {
    using std::begin;
    using std::end;

    size_t lower{npos}, upper{size()};
    while (upper - lower > 1) {
      size_t mid = (lower + upper) >> 1;
      bool less = false;
      for (auto i{begin(str) + sa[mid]}, j{begin(key)}; j != end(key);
           ++i, ++j) {
        if (i == end(str) || *i < *j) {
          less = true;
          break;
        }
        if (*i > *j) break;
      }
      (less ? lower : upper) = mid;
    }

    if (upper == size()) return npos;
    for (auto i{begin(str) + sa[upper]}, j{begin(key)}; j != end(key); ++i, ++j)
      if (i == end(str) || *i != *j) return npos;
    return sa[upper];
  }

  /*
   * @return lengths of LCP of each adjacent pairs in the suffix
   * array
   */
  const std::vector<size_t> &lcp_array() const { return lcp; }
};

}  // namespace workspace

#line 2 "src/string/suffix_array.hpp"

/*
 * @file suffix_array.hpp
 * @brief Suffix Array
 */

#include <algorithm>
#include <numeric>
#include <vector>

#line 2 "src/utils/sfinae.hpp"

/**
 * @file sfinae.hpp
 * @brief SFINAE
 */

#include <cstdint>
#include <iterator>
#include <type_traits>

#ifndef __INT128_DEFINED__

#ifdef __SIZEOF_INT128__
#define __INT128_DEFINED__ 1
#else
#define __INT128_DEFINED__ 0
#endif

#endif

namespace std {

#if __INT128_DEFINED__

template <> struct make_signed<__uint128_t> { using type = __int128_t; };
template <> struct make_signed<__int128_t> { using type = __int128_t; };

template <> struct make_unsigned<__uint128_t> { using type = __uint128_t; };
template <> struct make_unsigned<__int128_t> { using type = __uint128_t; };

template <> struct is_signed<__uint128_t> : std::false_type {};
template <> struct is_signed<__int128_t> : std::true_type {};

template <> struct is_unsigned<__uint128_t> : std::true_type {};
template <> struct is_unsigned<__int128_t> : std::false_type {};

#endif

}  // namespace std

namespace workspace {

template <class Tp, class... Args> struct variadic_front { using type = Tp; };

template <class... Args> struct variadic_back;

template <class Tp> struct variadic_back<Tp> { using type = Tp; };

template <class Tp, class... Args> struct variadic_back<Tp, Args...> {
  using type = typename variadic_back<Args...>::type;
};

template <class type, template <class> class trait>
using enable_if_trait_type = typename std::enable_if<trait<type>::value>::type;

/**
 * @brief Return type of subscripting ( @c [] ) access.
 */
template <class _Tp>
using subscripted_type =
    typename std::decay<decltype(std::declval<_Tp&>()[0])>::type;

template <class Container>
using element_type = typename std::decay<decltype(*std::begin(
    std::declval<Container&>()))>::type;

template <class _Tp, class = void> struct has_begin : std::false_type {};

template <class _Tp>
struct has_begin<
    _Tp, std::__void_t<decltype(std::begin(std::declval<const _Tp&>()))>>
    : std::true_type {
  using type = decltype(std::begin(std::declval<const _Tp&>()));
};

template <class _Tp, class = void> struct has_size : std::false_type {};

template <class _Tp>
struct has_size<_Tp, std::__void_t<decltype(std::size(std::declval<_Tp>()))>>
    : std::true_type {};

template <class _Tp, class = void> struct has_resize : std::false_type {};

template <class _Tp>
struct has_resize<_Tp, std::__void_t<decltype(std::declval<_Tp>().resize(
                           std::declval<size_t>()))>> : std::true_type {};

template <class _Tp, class = void> struct has_mod : std::false_type {};

template <class _Tp>
struct has_mod<_Tp, std::__void_t<decltype(_Tp::mod)>> : std::true_type {};

template <class _Tp, class = void> struct is_integral_ext : std::false_type {};
template <class _Tp>
struct is_integral_ext<
    _Tp, typename std::enable_if<std::is_integral<_Tp>::value>::type>
    : std::true_type {};

#if __INT128_DEFINED__

template <> struct is_integral_ext<__int128_t> : std::true_type {};
template <> struct is_integral_ext<__uint128_t> : std::true_type {};

#endif

#if __cplusplus >= 201402

template <class _Tp>
constexpr static bool is_integral_ext_v = is_integral_ext<_Tp>::value;

#endif

template <typename _Tp, typename = void> struct multiplicable_uint {
  using type = uint_least32_t;
};
template <typename _Tp>
struct multiplicable_uint<
    _Tp,
    typename std::enable_if<(2 < sizeof(_Tp)) &&
                            (!__INT128_DEFINED__ || sizeof(_Tp) <= 4)>::type> {
  using type = uint_least64_t;
};

#if __INT128_DEFINED__

template <typename _Tp>
struct multiplicable_uint<_Tp,
                          typename std::enable_if<(4 < sizeof(_Tp))>::type> {
  using type = __uint128_t;
};

#endif

template <typename _Tp> struct multiplicable_int {
  using type =
      typename std::make_signed<typename multiplicable_uint<_Tp>::type>::type;
};

template <typename _Tp> struct multiplicable {
  using type = std::conditional_t<
      is_integral_ext<_Tp>::value,
      std::conditional_t<std::is_signed<_Tp>::value,
                         typename multiplicable_int<_Tp>::type,
                         typename multiplicable_uint<_Tp>::type>,
      _Tp>;
};

template <class> struct first_arg { using type = void; };

template <class _R, class _Tp, class... _Args>
struct first_arg<_R(_Tp, _Args...)> {
  using type = _Tp;
};

template <class _R, class _Tp, class... _Args>
struct first_arg<_R (*)(_Tp, _Args...)> {
  using type = _Tp;
};

template <class _G, class _R, class _Tp, class... _Args>
struct first_arg<_R (_G::*)(_Tp, _Args...)> {
  using type = _Tp;
};

template <class _G, class _R, class _Tp, class... _Args>
struct first_arg<_R (_G::*)(_Tp, _Args...) const> {
  using type = _Tp;
};

template <class _Tp, class = void> struct parse_compare : first_arg<_Tp> {};

template <class _Tp>
struct parse_compare<_Tp, std::__void_t<decltype(&_Tp::operator())>>
    : first_arg<decltype(&_Tp::operator())> {};

template <class _Container, class = void> struct get_dimension {
  static constexpr size_t value = 0;
};

template <class _Container>
struct get_dimension<_Container,
                     std::enable_if_t<has_begin<_Container>::value>> {
  static constexpr size_t value =
      1 + get_dimension<typename std::iterator_traits<
              typename has_begin<_Container>::type>::value_type>::value;
};

}  // namespace workspace
#line 13 "src/string/suffix_array.hpp"

namespace workspace {

/*
 * @class suffix_array
 * @brief construct SA and LCP array.
 * @tparam str_type the type of string
 */
template <class str_type> class suffix_array {
  str_type str;
  std::vector<size_t> sa, rank, lcp;

  void construct_sa() {
    std::iota(sa.begin(), sa.end(), 0);
    std::sort(sa.begin(), sa.end(),
              [&](size_t i, size_t j) { return str[i] < str[j]; });

    for (size_t r{1}, c{}, *ptr{&sa.front()}, *tmp{ptr}; c != size();
         ++r, ptr = tmp)
      while (c != size() && str[*ptr] == str[*tmp]) ++c, rank[*tmp++] = r;

    for (size_t k{1}; k < size(); k <<= 1) {
      auto comp = [&](size_t i, size_t j) -> bool {
        if (rank[i] != rank[j]) return rank[i] < rank[j];
        return (i + k < size() ? rank[i + k] : 0) <
               (j + k < size() ? rank[j + k] : 0);
      };
      std::sort(sa.begin(), sa.end(), comp);

      std::vector<size_t> next_rank(size());
      for (size_t r{1}, c{}, *ptr{&sa.front()}, *tmp{ptr}; c != size();
           ++r, ptr = tmp)
        while (c != size() && !comp(*ptr, *tmp)) ++c, next_rank[*tmp++] = r;
      rank.swap(next_rank);
    }

    sa.emplace(sa.begin(), size());
    rank.emplace_back(0);
  }

  void construct_lcp() {
    for (size_t i{}, h{}; i != size(); ++i, h = h ? h - 1 : 0) {
      for (size_t j{sa[rank[i] - 1] + h}; i + h != size() && j != size();
           ++j, ++h)
        if (str[i + h] != str[j]) break;
      lcp[rank[i] - 1] = h;
    }
  }

 public:
  static constexpr size_t npos = -1;
  using char_type = element_type<str_type>;

  std::vector<size_t>::const_iterator begin() const { return sa.begin() + 1; }

  std::vector<size_t>::const_iterator end() const { return sa.end(); }

  /*
   * @fn operator[]
   * @brief find the i-th suffix
   * @param i the rank
   * @return index of the suffix
   */
  size_t operator[](size_t i) const { return sa[i + 1]; }

  /*
   * @fn size
   * @return length of the string
   */
  size_t size() const { return std::size(str); }

  template <class type = str_type, typename = typename type::value_type>
  suffix_array(const str_type &_str)
      : str(_str), sa(size()), rank(size()), lcp(size()) {
    construct_sa();
    construct_lcp();
  }

  template <class type = str_type, std::enable_if_t<std::is_array<type>::value,
                                                    std::nullptr_t> = nullptr>
  suffix_array(const str_type &_str) : sa(size()), rank(size()), lcp(size()) {
    std::copy(std::begin(_str), std::end(_str), str);
    construct_sa();
    construct_lcp();
  }

  /*
   * @fn find
   * @brief find (key) as a substring
   * @param key
   * @return index if found, npos if not found
   */
  size_t find(const str_type &key) const {
    using std::begin;
    using std::end;

    size_t lower{npos}, upper{size()};
    while (upper - lower > 1) {
      size_t mid = (lower + upper) >> 1;
      bool less = false;
      for (auto i{begin(str) + sa[mid]}, j{begin(key)}; j != end(key);
           ++i, ++j) {
        if (i == end(str) || *i < *j) {
          less = true;
          break;
        }
        if (*i > *j) break;
      }
      (less ? lower : upper) = mid;
    }

    if (upper == size()) return npos;
    for (auto i{begin(str) + sa[upper]}, j{begin(key)}; j != end(key); ++i, ++j)
      if (i == end(str) || *i != *j) return npos;
    return sa[upper];
  }

  /*
   * @return lengths of LCP of each adjacent pairs in the suffix
   * array
   */
  const std::vector<size_t> &lcp_array() const { return lcp; }
};

}  // namespace workspace

Back to top page