結果
問題 | No.430 文字列検索 |
ユーザー | naskya |
提出日時 | 2021-03-26 18:49:24 |
言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
結果 |
TLE
(最新)
AC
(最初)
|
実行時間 | - |
コード長 | 10,528 bytes |
コンパイル時間 | 2,185 ms |
コンパイル使用メモリ | 166,884 KB |
実行使用メモリ | 6,824 KB |
最終ジャッジ日時 | 2024-11-10 00:54:27 |
合計ジャッジ時間 | 22,228 ms |
ジャッジサーバーID (参考情報) |
judge1 / judge3 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | AC | 2 ms
5,248 KB |
testcase_01 | AC | 1,985 ms
6,820 KB |
testcase_02 | AC | 1,990 ms
6,816 KB |
testcase_03 | AC | 1,987 ms
6,820 KB |
testcase_04 | AC | 2 ms
5,248 KB |
testcase_05 | AC | 1 ms
5,248 KB |
testcase_06 | AC | 2 ms
5,248 KB |
testcase_07 | AC | 2 ms
5,248 KB |
testcase_08 | AC | 10 ms
5,248 KB |
testcase_09 | AC | 2 ms
5,248 KB |
testcase_10 | AC | 7 ms
5,248 KB |
testcase_11 | TLE | - |
testcase_12 | AC | 1,982 ms
6,820 KB |
testcase_13 | AC | 1,989 ms
6,820 KB |
testcase_14 | AC | 1,986 ms
6,824 KB |
testcase_15 | TLE | - |
testcase_16 | AC | 1,992 ms
6,816 KB |
testcase_17 | AC | 1,986 ms
6,820 KB |
ソースコード
#pragma region template // clang-format off #if (defined __INTELLISENSE__) && (!defined PROPER) #define NDEBUG namespace std { #endif #ifdef LOCAL_NDEBUG #include <headers.hpp> #endif #ifdef LOCAL_DEBUG #include <debugger.hpp> #endif #include <cassert> #include <cctype> #include <cmath> #include <cstddef> #include <cstdint> #include <cstdio> #include <cstdlib> #include <algorithm> #include <bitset> #include <complex> #include <deque> #include <functional> #include <iostream> #include <iomanip> #include <limits> #include <list> #include <map> #include <numeric> #include <queue> #include <regex> #include <set> #include <sstream> #include <stack> #include <string> #include <tuple> #include <typeinfo> #include <type_traits> #include <utility> #include <vector> #if (defined __INTELLISENSE__) && (!defined PROPER) using namespace std; } #endif #ifdef DEBUGGER_HPP_INCLUDED #define FILE_LINE "[Debug] ./" + std::string(__FILE__) + ":" + std::to_string(__LINE__) + " in " + std::string(__func__) #define see(...) debugger::multi_print(#__VA_ARGS__, __VA_ARGS__) #define seetype(arg) debugger::multi_print(#arg, debugger::type_name<decltype(arg)>) #define here(...) do {debugger::output << FILE_LINE << ": \e[32mReached\e[39m\n"; see(__VA_ARGS__); debugger::output << (std::string(#__VA_ARGS__).empty() ? "" : "\n");} while(0) #define com(msg) debugger::output << FILE_LINE << ":\n \e[36mComment:\e[39m " << msg << "\n" #define local(x) do {x} while(0) #define alter(x, y) x #else #define see(...) (static_cast<void>(0)) #define seetype(arg) (static_cast<void>(0)) #define here(...) (static_cast<void>(0)) #define com(msg) (static_cast<void>(0)) #define local(x) (static_cast<void>(0)) #define alter(x, y) y #endif #if (defined DEBUGGER_HPP_INCLUDED) && (!defined NOWARN) #define warn(msg) debugger::output << FILE_LINE << ":\n \e[33mWarning:\e[39m " << msg << "\n" #else #define warn(msg) (static_cast<void>(0)) #endif #if (defined LOCAL_DEBUG) || (defined LOCAL_NDEBUG) || (defined __INTELLISENSE__) #define NOEXCEPT #define M_assert(expr) assert(expr) #define O_assert(expr) assert(expr) #else #define NOEXCEPT noexcept #define M_assert(expr) do {if(__builtin_expect(!(expr), 0)) {auto p = static_cast<std::int64_t*>(std::malloc(1 << 30)); for (int i = 0; i < (1 << 27); p[i] = 1, i += (1 << 9)); std::cerr << (*p);}} while(0) #define O_assert(expr) do {if(__builtin_expect(!(expr), 0)) {const auto X = std::string(1000, '-'); for(int i = 0; i < (1 << 18); i++) std::cout << X;}} while(0) #endif #define rep(i, n) for (std::make_signed_t<std::decay_t<decltype(n)>> i = 0; i < (n); ++i) #define rng(i, f, t, s) for (std::make_signed_t<std::decay_t<std::common_type_t<decltype(f), decltype(t)>>> i = (f); ((s) > 0) ? (i < (t)) : (i > (t)); i += (s)) #define erng(i, f, t, s) for (std::make_signed_t<std::decay_t<std::common_type_t<decltype(f), decltype(t)>>> i = (f); ((s) > 0) ? (i <= (t)) : (i >= (t)); i += (s)) [[maybe_unused]] constexpr int INF = 1000000005; [[maybe_unused]] constexpr long long LINF = 1000000000000000005LL; [[maybe_unused]] constexpr double EPS = 1e-9; [[maybe_unused]] constexpr long double LEPS = 1e-14L; [[maybe_unused]] constexpr int dy[9] = {1, 0, -1, 0, 1, 1, -1, -1, 0}; [[maybe_unused]] constexpr int dx[9] = {0, 1, 0, -1, -1, 1, 1, -1, 0}; template <class S, class T, class... U, class V = std::common_type_t<S, T, U...>> constexpr V Min(const S a, const T b, const U... c) { if constexpr (sizeof...(U)) return std::min((V) a, (V) Min(b, c...)); else return std::min((V) a, (V) b); } template <class S, class T, class... U, class V = std::common_type_t<S, T, U...>> constexpr V Max(const S a, const T b, const U... c) { if constexpr (sizeof...(U)) return std::max((V) a, (V) Max(b, c...)); else return std::max((V) a, (V) b); } // clang-format on #pragma endregion #pragma region lib_rolling_hash namespace lib { namespace internal { template <std::size_t N> using hash_type = std::conditional_t<(30 < N), std::uint64_t, std::uint32_t>; template <std::size_t N> constexpr hash_type<N> mask = (static_cast<hash_type<N>>(1) << N) - 1; template <std::size_t N> constexpr hash_type<N> mul_mod_1(const hash_type<N> lhs, const hash_type<N> rhs) { const hash_type<N> lhs_u = lhs >> N, lhs_d = lhs & mask<N>; const hash_type<N> rhs_u = rhs >> N, rhs_d = rhs & mask<N>; const hash_type<N> mid = lhs_d * rhs_u + lhs_u * rhs_d; return ((lhs_u * rhs_u) << 1) + lhs_d * rhs_d + ((mid & mask<N - 1>) << N) + (mid >> (N - 1)); } template <std::size_t N, class Tp1, class Tp2> constexpr Tp1 mul_mod_2(const Tp1 lhs, const Tp2 rhs) { const Tp2 rhs_d = rhs & mask<N>; const Tp1 lhs_u = lhs >> N, mid = lhs_u * rhs_d; return (lhs & mask<N>) *rhs_d + ((mid & mask<N - 1>) << N) + (mid >> (N - 1)); } template <std::size_t N> constexpr hash_type<N> clamp(const hash_type<N> x) { if (const hash_type<N> res = (x >> N) + (x & mask<N>); res < mask<N>) return res; else return res - mask<N>; } } // namespace internal namespace internal::rolling_hash_61 { using HashType = hash_type<61>; constexpr int MAX_N = 50050; constexpr std::uint32_t base = 998244353; constexpr HashType padding = mask<61> * mask<std::numeric_limits<HashType>::digits - 61>; struct base_pow_constexpr { HashType val[MAX_N + 1]; constexpr base_pow_constexpr() : val() { val[0] = 1; for (int i = 1; i <= MAX_N; ++i) val[i] = clamp<61>(mul_mod_2<31>(val[i - 1], base)); } }; // if you want MAX_N to be greater than constexpr-loop-limit (typically 262144 = 2^18 in GCC), // you should use `const` instead of `constexpr` // const base_pow_constexpr base_to_the_n; constexpr base_pow_constexpr base_to_the_n; std::vector<HashType> build_hash(const std::string& s) { const int N = static_cast<int>(s.size()); local(if constexpr (MAX_N == 250000) com("Did you check the value of MAX_N? (currently " << MAX_N << ")");); O_assert(N <= MAX_N); std::vector<HashType> res(N + 1); for (int i = 0; i < N; ++i) res[i + 1] = clamp<61>(mul_mod_2<31>(res[i], base) + static_cast<HashType>(s[i])); return res; } HashType substr_hash(const std::vector<HashType>& hash_vec, const int L_index, int cnt = std::numeric_limits<int>::max()) { const int N = static_cast<int>(hash_vec.size()); O_assert(0 <= L_index && L_index < N); local(if (N - L_index < cnt && cnt != std::numeric_limits<int>::max()) warn("substr was shortened (" << cnt << " -> " << (N - L_index) << ")");); cnt = std::min(cnt, N - L_index); return clamp<61>(hash_vec[L_index + cnt] + padding - mul_mod_1<31>(hash_vec[L_index], base_to_the_n.val[cnt])); } } // namespace internal::rolling_hash_61 #ifdef LOCAL_DEBUG namespace internal { class string_hash { public: using type = rolling_hash_61::HashType; string_hash(void) noexcept {} string_hash(const type h, const std::string& s) : v(h), source(s) {} bool operator==(const string_hash rhs) const { const bool same_hash = (v == rhs.v), same_string = (source == rhs.source); assert(same_hash == same_string); return same_string; } bool operator!=(const string_hash rhs) const { const bool same_hash = (v == rhs.v), same_string = (source == rhs.source); assert(same_hash == same_string); return !same_string; } type val(void) const noexcept { return v; } private: type v; std::string source; }; } // namespace internal class rolling_hash { public: using type = internal::rolling_hash_61::HashType; rolling_hash(void) {} rolling_hash(const std::string& s) : source(s), hash(internal::rolling_hash_61::build_hash(s)) {} // get hash of the whole string internal::string_hash whole_string(void) const { return internal::string_hash(hash.back(), source); } // get hash of the whole string internal::string_hash substr(void) const { return internal::string_hash(hash.back(), source); } // get hash of the substring of length len, starting at L_index internal::string_hash substr(const int L_index, int len = std::numeric_limits<int>::max()) const { return internal::string_hash(internal::rolling_hash_61::substr_hash(hash, L_index, len), source.substr(L_index, len)); } private: std::vector<type> hash; std::string source; }; #else namespace internal { class string_hash { public: using type = rolling_hash_61::HashType; string_hash(void) noexcept {} string_hash(const type h) noexcept : v(h) {} bool operator==(const string_hash rhs) const noexcept { return v == rhs.v; } bool operator!=(const string_hash rhs) const noexcept { return v != rhs.v; } type val(void) const noexcept { return v; } private: type v; }; } // namespace internal class rolling_hash { public: using type = internal::rolling_hash_61::HashType; rolling_hash(void) {} rolling_hash(const std::string& s) : hash(internal::rolling_hash_61::build_hash(s)) {} // get hash of the whole string internal::string_hash whole_string(void) const { return internal::string_hash(hash.back()); } // get hash of the whole string internal::string_hash substr(void) const { return internal::string_hash(hash.back()); } // get hash of the substring of length len, starting at L_index internal::string_hash substr(const int L_index, int len = std::numeric_limits<int>::max()) const { return internal::string_hash(internal::rolling_hash_61::substr_hash(hash, L_index, len)); } private: std::vector<type> hash; }; #endif } // namespace lib #pragma endregion void solve() { std::string S; int M; std::cin >> S >> M; const lib::rolling_hash S_hash(S); int ans = 0; rep(i, M) { std::string C; std::cin >> C; const auto C_whole_hash = lib::rolling_hash(C).whole_string(); rep(j, static_cast<int>(S.length() - C.length()) + 1) ans += (S_hash.substr(j, static_cast<int>(C.length())) == C_whole_hash); } std::cout << ans << "\n"; } int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(nullptr); std::cout.tie(nullptr); solve(); }