Halc's Library

This documentation is automatically generated by online-judge-tools/verification-helper

---

Project maintained by halc-git Hosted on GitHub Pages — Theme by mattgraham

Verify/verify-yosupo-string/enumerate_palindromes-rollinghash.test.cpp

• View this file on GitHub
• Last update: 2024-10-22 20:46:56+09:00
• Problem: https://judge.yosupo.jp/problem/enumerate_palindromes

Depends on

• String/RollingHash.hpp
• Template/InOut.hpp
• Template/Macro.hpp
• Template/Template.hpp
• Template/Util.hpp

Code

#define PROBLEM "https://judge.yosupo.jp/problem/enumerate_palindromes"
#include "../../String/RollingHash.hpp"
#include "../../Template/Template.hpp"
void solve() {
    STR(S);
    RollingHash<string> roll;
    auto st = roll.build(S);
    reverse(all(S));
    auto rev = roll.build(S);
    vec(ll, ans, len(S) * 2 - 1);
    rep(i, len(S)) {
        ll ok = 1, ng = min(i + 1, len(S) - i) + 1;
        while (ng - ok > 1) {
            ll mid = (ok + ng) >> 1;
            if (roll.query(st, i - mid + 1, i + mid) ==
                roll.query(rev, len(S) - i - mid, len(S) - i + mid - 1)) {
                ok = mid;
            } else {
                ng = mid;
            }
        }
        ans[i << 1] = (ok << 1) - 1;
    }
    rep(i, len(S) - 1) {
        ll ok = 0, ng = min(i + 1, len(S) - i - 1) + 1;
        while (ng - ok > 1) {
            ll mid = (ok + ng) >> 1;
            if (roll.query(st, i - mid + 1, i + mid + 1) ==
                roll.query(rev, len(S) - i - mid - 1, len(S) - i + mid - 1)) {
                ok = mid;
            } else {
                ng = mid;
            }
        }
        ans[(i << 1) + 1] = ok << 1;
    }
    out(ans);
}
int main() { solve(); }

#line 1 "Verify/verify-yosupo-string/enumerate_palindromes-rollinghash.test.cpp"
#define PROBLEM "https://judge.yosupo.jp/problem/enumerate_palindromes"
#line 2 "String/RollingHash.hpp"
#include <chrono>
#include <random>
#include <vector>

// https://qiita.com/keymoon/items/11fac5627672a6d6a9f6
template <typename S>
struct RollingHash {
    using u64 = uint64_t;
    static const u64 MOD = (1ULL << 61) - 1;
    static const u64 MASK31 = (1ULL << 31) - 1;
    static const u64 MASK30 = (1ULL << 30) - 1;
    std::vector<u64> powers;
    u64 base, fixed;
    static inline u64 add(u64 a, u64 b) {
        if ((a += b) >= MOD) a -= MOD;
        return a;
    }
    static inline u64 calc_mod(u64 x) {
        u64 xu = x >> 61, xd = x & MOD;
        u64 ret = xu + xd;
        if (ret >= MOD) ret -= MOD;
        return ret;
    }
    static inline u64 mul(u64 a, u64 b) {
        u64 au = a >> 31, ad = a & MASK31, bu = b >> 31, bd = b & MASK31;
        u64 mid = ad * bu + au * bd;
        u64 midu = mid >> 30, midd = mid & MASK30;
        return calc_mod(((au * bu) << 1) + midu + (midd << 31) + ad * bd);
    }
    static inline u64 generate_base() {
        std::mt19937_64 mt(
            std::chrono::steady_clock::now().time_since_epoch().count());
        std::uniform_int_distribution<u64> rand(1ULL << 60, MOD - 1);
        return rand(mt);
    }
    explicit RollingHash(u64 base_number = generate_base(),
                         u64 fixed_number = 1ULL << 31) {
        base = base_number;
        fixed = fixed_number;
        powers = {1};
    }
    std::vector<u64> build(const S &s) {
        uint32_t sz = s.size();
        std::vector<u64> hashed(sz + 1, 0);
        while (powers.size() <= sz) {
            powers.emplace_back(mul(powers.back(), base));
        }
        for (uint32_t i = 0; i < sz; i++) {
            hashed[i + 1] = add(mul(hashed[i], base), s[i] + fixed);
        }
        return hashed;
    }
    u64 query(const std::vector<u64> &s, uint32_t lf, uint32_t ri) {
        int64_t ret = s[ri] - mul(s[lf], powers[ri - lf]);
        if (ret < 0) ret += MOD;
        return ret;
    }
    u64 combine(u64 h1, u64 h2, uint32_t h2len) {
        return add(mul(h1, powers[h2len]), h2);
    }
    uint32_t lcp(const std::vector<u64> &a, uint32_t l1, uint32_t r1,
                 const std::vector<u64> &b, uint32_t l2, uint32_t r2) {
        uint32_t ok = 0, ng = std::min((r1 - l1), (r2 - l2)) + 1;
        while (ng - ok > 1) {
            uint32_t mid = (ok + ng) >> 1;
            if (query(a, l1, l1 + mid) == query(b, l2, l2 + mid))
                ok = mid;
            else
                ng = mid;
        }
        return ok;
    }
};
#line 2 "Template/Template.hpp"
#include <bits/stdc++.h>
using namespace std;

#line 8 "Template/InOut.hpp"
inline void scan() {}
inline void scan(int32_t &a) { std::cin >> a; }
inline void scan(uint32_t &a) { std::cin >> a; }
inline void scan(int64_t &a) { std::cin >> a; }
inline void scan(uint64_t &a) { std::cin >> a; }
inline void scan(char &a) { std::cin >> a; }
inline void scan(float &a) { std::cin >> a; }
inline void scan(double &a) { std::cin >> a; }
inline void scan(long double &a) { std::cin >> a; }
inline void scan(std::vector<bool> &vec) {
    for (int32_t i = 0; i < vec.size(); i++) {
        int a;
        scan(a);
        vec[i] = a;
    }
}
inline void scan(std::string &a) { std::cin >> a; }
template <class T>
inline void scan(std::vector<T> &vec);
template <class T, size_t size>
inline void scan(std::array<T, size> &vec);
template <class T, class L>
inline void scan(std::pair<T, L> &p);
template <class T, size_t size>
inline void scan(T (&vec)[size]);
template <class T>
inline void scan(std::vector<T> &vec) {
    for (auto &i : vec) scan(i);
}
template <class T>
inline void scan(std::deque<T> &vec) {
    for (auto &i : vec) scan(i);
}
template <class T, size_t size>
inline void scan(std::array<T, size> &vec) {
    for (auto &i : vec) scan(i);
}
template <class T, class L>
inline void scan(std::pair<T, L> &p) {
    scan(p.first);
    scan(p.second);
}
template <class T, size_t size>
inline void scan(T (&vec)[size]) {
    for (auto &i : vec) scan(i);
}
template <class T>
inline void scan(T &a) {
    std::cin >> a;
}
inline void in() {}
template <class Head, class... Tail>
inline void in(Head &head, Tail &...tail) {
    scan(head);
    in(tail...);
}
inline void print() { std::cout << ' '; }
inline void print(const bool &a) { std::cout << a; }
inline void print(const int32_t &a) { std::cout << a; }
inline void print(const uint32_t &a) { std::cout << a; }
inline void print(const int64_t &a) { std::cout << a; }
inline void print(const uint64_t &a) { std::cout << a; }
inline void print(const char &a) { std::cout << a; }
inline void print(const char a[]) { std::cout << a; }
inline void print(const float &a) { std::cout << a; }
inline void print(const double &a) { std::cout << a; }
inline void print(const long double &a) { std::cout << a; }
inline void print(const std::string &a) {
    for (auto &&i : a) print(i);
}
template <class T>
inline void print(const std::vector<T> &vec);
template <class T, size_t size>
inline void print(const std::array<T, size> &vec);
template <class T, class L>
inline void print(const std::pair<T, L> &p);
template <class T, size_t size>
inline void print(const T (&vec)[size]);
template <class T>
inline void print(const std::vector<T> &vec) {
    if (vec.empty()) return;
    print(vec[0]);
    for (auto i = vec.begin(); ++i != vec.end();) {
        std::cout << ' ';
        print(*i);
    }
}
template <class T>
inline void print(const std::deque<T> &vec) {
    if (vec.empty()) return;
    print(vec[0]);
    for (auto i = vec.begin(); ++i != vec.end();) {
        std::cout << ' ';
        print(*i);
    }
}
template <class T, size_t size>
inline void print(const std::array<T, size> &vec) {
    print(vec[0]);
    for (auto i = vec.begin(); ++i != vec.end();) {
        std::cout << ' ';
        print(*i);
    }
}
template <class T, class L>
inline void print(const std::pair<T, L> &p) {
    print(p.first);
    std::cout << ' ';
    print(p.second);
}
template <class T, size_t size>
inline void print(const T (&vec)[size]) {
    print(vec[0]);
    for (auto i = vec; ++i != end(vec);) {
        std::cout << ' ';
        print(*i);
    }
}
template <class T>
inline void print(const T &a) {
    std::cout << a;
}
inline void out() { std::cout << '\n'; }
template <class T>
inline void out(const T &t) {
    print(t);
    std::cout << '\n';
}
template <class Head, class... Tail>
inline void out(const Head &head, const Tail &...tail) {
    print(head);
    std::cout << ' ';
    out(tail...);
}
inline void Yes(bool i = true) { out(i ? "Yes" : "No"); }
inline void No(bool i = true) { out(i ? "No" : "Yes"); }
inline void Takahashi(bool i = true) { out(i ? "Takahashi" : "Aoki"); }
inline void Aoki(bool i = true) { out(i ? "Aoki" : "Takahashi"); }
inline void Alice(bool i = true) { out(i ? "Alice" : "Bob"); }
inline void Bob(bool i = true) { out(i ? "Bob" : "Alice"); }
inline void First(bool i = true) { out(i ? "First" : "Second"); }
inline void Second(bool i = true) { out(i ? "Second" : "First"); }
inline void Possible(bool i = true) { out(i ? "Possible" : "Impossible"); }
inline void Impossible(bool i = true) { out(i ? "Impossible" : "Possible"); }
inline void fls() { std::flush(std::cout); }
struct IOsetup {
    IOsetup() {
        std::ios::sync_with_stdio(false);
        std::cin.tie(nullptr);
        std::cout << std::fixed << std::setprecision(16);
    }
} iosetup;
#line 9 "Template/Util.hpp"
using ll = int64_t;
using ld = long double;
using ull = uint64_t;
using uint = uint32_t;
using pll = std::pair<ll, ll>;
using pii = std::pair<int32_t, int32_t>;
using vl = std::vector<ll>;
using vvl = std::vector<std::vector<ll>>;
using pdd = std::pair<ld, ld>;
using tuplis = std::array<ll, 3>;
template <class T>
using pq = std::priority_queue<T, std::vector<T>, std::greater<T>>;
constexpr ll LINF = (1LL << 62) - (1LL << 31);
constexpr int32_t INF = INT_MAX >> 1;
constexpr ll MINF = 1LL << 40;
constexpr ld DINF = std::numeric_limits<ld>::infinity();
constexpr int32_t MODD = 1000000007;
constexpr int32_t MOD = 998244353;
constexpr ld EPS = 1e-9;
constexpr ld PI = 3.1415926535897932;
const ll four[] = {0, 1, 0, -1, 0};
const ll eight[] = {0, 1, 1, 0, -1, -1, 1, -1, 0};
template <class T>
bool chmin(T &a, const T &b) {
    if (a > b) {
        a = b;
        return true;
    } else
        return false;
}
template <class T>
bool chmax(T &a, const T &b) {
    if (a < b) {
        a = b;
        return true;
    } else
        return false;
}
template <class T>
ll sum(const T &a) {
    return accumulate(std::begin(a), std::end(a), 0LL);
}
template <class T>
ld dsum(const T &a) {
    return accumulate(std::begin(a), std::end(a), 0.0L);
}
template <class T>
auto min(const T &a) {
    return *min_element(std::begin(a), std::end(a));
}
template <class T>
auto max(const T &a) {
    return *max_element(std::begin(a), std::end(a));
}
#line 1 "Template/Macro.hpp"
#define _overload3(_1, _2, _3, name, ...) name
#define _overload4(_1, _2, _3, _4, name, ...) name
#define _rep1(i, n) for (int64_t i = 0; i < (n); i++)
#define _rep2(i, a, b) for (int64_t i = (a); i < (b); i++)
#define _rep3(i, a, b, c) for (int64_t i = (a); i < (b); i += (c))
#define rep(...) _overload4(__VA_ARGS__, _rep3, _rep2, _rep1)(__VA_ARGS__)
#define _rrep1(i, n) for (int64_t i = (n) - 1; i >= 0; i--)
#define _rrep2(i, a, b) for (int64_t i = (b) - 1; i >= (a); i--)
#define rrep(...) _overload3(__VA_ARGS__, _rrep2, _rrep1)(__VA_ARGS__)
#define each(i, ...) for (auto&& i : __VA_ARGS__)
#define all(i) std::begin(i), std::end(i)
#define rall(i) std::rbegin(i), std::rend(i)
#define len(x) ((int64_t)(x).size())
#define fi first
#define se second
#define uniq(x) x.erase(unique(all(x)), std::end(x))
#define vec(type, name, ...) vector<type> name(__VA_ARGS__);
#define vv(type, name, h, ...) std::vector<std::vector<type>> name(h, std::vector<type>(__VA_ARGS__));
#define INT(...) int32_t __VA_ARGS__; in(__VA_ARGS__)
#define LL(...) int64_t __VA_ARGS__; in(__VA_ARGS__)
#define ULL(...) uint64_t __VA_ARGS__; in(__VA_ARGS__)
#define STR(...) std::string __VA_ARGS__; in(__VA_ARGS__)
#define CHR(...) char __VA_ARGS__; in(__VA_ARGS__)
#define LD(...) long double __VA_ARGS__; in(__VA_ARGS__)
#define VEC(type, name, size) std::vector<type> name(size); in(name)
#define VV(type, name, h, w) std::vector<std::vector<type>> name(h, std::vector<type>(w)); in(name)
#line 4 "Verify/verify-yosupo-string/enumerate_palindromes-rollinghash.test.cpp"
void solve() {
    STR(S);
    RollingHash<string> roll;
    auto st = roll.build(S);
    reverse(all(S));
    auto rev = roll.build(S);
    vec(ll, ans, len(S) * 2 - 1);
    rep(i, len(S)) {
        ll ok = 1, ng = min(i + 1, len(S) - i) + 1;
        while (ng - ok > 1) {
            ll mid = (ok + ng) >> 1;
            if (roll.query(st, i - mid + 1, i + mid) ==
                roll.query(rev, len(S) - i - mid, len(S) - i + mid - 1)) {
                ok = mid;
            } else {
                ng = mid;
            }
        }
        ans[i << 1] = (ok << 1) - 1;
    }
    rep(i, len(S) - 1) {
        ll ok = 0, ng = min(i + 1, len(S) - i - 1) + 1;
        while (ng - ok > 1) {
            ll mid = (ok + ng) >> 1;
            if (roll.query(st, i - mid + 1, i + mid + 1) ==
                roll.query(rev, len(S) - i - mid - 1, len(S) - i + mid - 1)) {
                ok = mid;
            } else {
                ng = mid;
            }
        }
        ans[(i << 1) + 1] = ok << 1;
    }
    out(ans);
}
int main() { solve(); }

Back to top page