結果

問題 No.2858 Make a Palindrome
ユーザー SnowBeenDidingSnowBeenDiding
提出日時 2024-08-28 17:25:48
言語 C++23
(gcc 12.3.0 + boost 1.83.0)
結果
WA  
実行時間 -
コード長 5,846 bytes
コンパイル時間 5,990 ms
コンパイル使用メモリ 316,052 KB
実行使用メモリ 43,228 KB
最終ジャッジ日時 2024-08-28 17:26:00
合計ジャッジ時間 11,786 ms
ジャッジサーバーID
（参考情報） 		judge3 / judge1
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 WA -
testcase_01 WA -
testcase_02 WA -
testcase_03 WA -
testcase_04 WA -
testcase_05 AC 102 ms
6,944 KB
testcase_06 WA -
testcase_07 WA -
testcase_08 WA -
testcase_09 WA -
testcase_10 WA -
testcase_11 WA -
testcase_12 WA -
testcase_13 WA -
testcase_14 WA -
testcase_15 WA -
testcase_16 WA -
testcase_17 WA -
testcase_18 WA -
testcase_19 WA -
testcase_20 AC 55 ms
38,088 KB
testcase_21 WA -
testcase_22 AC 33 ms
21,692 KB
testcase_23 AC 54 ms
38,028 KB
testcase_24 WA -
testcase_25 AC 50 ms
30,108 KB
testcase_26 AC 43 ms
28,784 KB
testcase_27 AC 61 ms
42,728 KB
testcase_28 WA -
testcase_29 AC 56 ms
39,680 KB
testcase_30 AC 61 ms
43,152 KB
testcase_31 AC 62 ms
43,208 KB
testcase_32 WA -
testcase_33 WA -
testcase_34 AC 59 ms
43,072 KB
testcase_35 AC 60 ms
43,120 KB
testcase_36 WA -
testcase_37 WA -
testcase_38 AC 61 ms
43,048 KB
testcase_39 AC 62 ms
43,048 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <atcoder/all>
#include <bits/stdc++.h>
#define rep(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
using namespace atcoder;
using namespace std;

typedef long long ll;

template <typename T> T ceil_div(T a, T b) {
    if (b < 0)
        a = -a, b = -b;
    return (a >= 0 ? (a + b - 1) / b : a / b);
}

struct RollingHash {
    int n;
    static const ll base1 = 1009;
    static const ll base2 = 2009;
    static const ll mod1 = 1000000007;
    static const ll mod2 = 1000000009;
    vector<ll> hash1, hash2, pow1, pow2;

    RollingHash() {}
    RollingHash(const string &S) {
        n = (int)S.size();
        hash1.assign(n + 1, 0);
        hash2.assign(n + 1, 0);
        pow1.assign(n + 1, 1);
        pow2.assign(n + 1, 1);
        for (int i = 0; i < n; ++i) {
            hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1;
            hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2;
            pow1[i + 1] = (pow1[i] * base1) % mod1;
            pow2[i + 1] = (pow2[i] * base2) % mod2;
        }
    }

    /**
     * S の [l, r) のハッシュ値を返す
     * O(1)
     */
    inline pair<ll, ll> get(int l, int r) const {
        ll res1 = hash1[r] - hash1[l] * pow1[r - l] % mod1;
        if (res1 < 0)
            res1 += mod1;
        ll res2 = hash2[r] - hash2[l] * pow2[r - l] % mod2;
        if (res2 < 0)
            res2 += mod2;
        return make_pair(res1, res2);
    }

    /**
     * S のハッシュ値を返す
     * O(1)
     */
    inline pair<ll, ll> hash() const { return get(0, (int)hash1.size() - 1); }

    /**
     * LCP (Longest Common Prefix)
     * O( log N )
     */
    inline int getLCP(int a, int b) const {
        int len = min((int)hash1.size() - a, (int)hash1.size() - b);
        int low = 0, high = len;
        while (high - low > 1) {
            int mid = (low + high) >> 1;
            if (get(a, a + mid) != get(b, b + mid))
                high = mid;
            else
                low = mid;
        }
        return low;
    }

    /**
     * hash h1 と 長さ h2_len の文字列の hash h2 を結合
     */
    pair<ll, ll> concat(pair<ll, ll> h1, pair<ll, ll> h2, ll h2_len) {
        if (h2_len < pow1.size())
            return make_pair((h1.first * pow1[h2_len] + h2.first) % mod1,
                             (h1.second * pow2[h2_len] + h2.second) % mod2);
        return make_pair(
            (h1.first * pow_mod(base1, h2_len + 1, mod1) + h2.first) % mod1,
            (h1.second * pow_mod(base2, h2_len + 1, mod2) + h2.second) % mod2);
    }

    /**
     * 文字列の最小周期を返す
     */
    int max_repeat(bool multiple_only = false) {
        for (int i = 1; i < n; i++) {
            if (multiple_only && n % i != 0)
                continue;
            if (n - i < i)
                break;
            if (get(0, n - i) == get(i, n)) {
                return i;
            }
        }
        return n;
    }

    /**
     * hash h を count 回結合 (WIP)
     */
    pair<ll, ll> times(pair<ll, ll> h, ll len, ll count) {
        pair<ll, ll> ret = {0, 0}, now = h;
        ll pw = 1;
        while (count) {
            if (count & 1)
                ret = concat(ret, now, len * pw);
            now = concat(now, now, len * pw);
            count >>= 1;
            pw <<= 1;
        }
        return ret;
    }
};

int max_pal_len(string s) {
    // 回文の最大半径を返す
    int ret = 0;

    // 奇数長
    vector<int> odd(s.size());
    for (int i = 0, l = 0, r = -1; i < s.size(); i++) {
        int k = (i > r) ? 1 : min(odd[l + r - i], r - i);
        while (0 <= i - k && i + k < s.size() && s[i - k] == s[i + k])
            k++;
        odd[i] = k--;
        ret = max(ret, k * 2 + 1);
        if (i + k > r)
            l = i - k, r = i + k;
    }
    ret = max(ret, *max_element(odd.begin(), odd.end()) * 2 - 1);

    // 偶数長
    vector<int> even(s.size());
    for (int i = 0, l = 0, r = -1; i < s.size(); i++) {
        int k = (i > r) ? 0 : min(even[l + r - i + 1], r - i + 1);
        while (0 <= i - k - 1 && i + k < s.size() && s[i - k - 1] == s[i + k])
            k++;
        even[i] = k--;
        ret = max(ret, k * 2);
        if (i + k > r)
            l = i - k - 1, r = i + k;
    }
    ret = max(ret, *max_element(even.begin(), even.end()) * 2);
    return ret;
}

template <typename T, typename S> bool chmin(T &a, S b) {
    if (a > b) {
        a = b;
        return 1;
    }
    return 0;
}

bool is_pal(string s) { return s == string(s.rbegin(), s.rend()); }

void solve() {
    int n, m;
    string s;
    cin >> n >> m >> s;
    if (max_pal_len(s) >= m) {
        cout << 1 << '\n';
        return;
    }
    string ss = s + s;
    if (max_pal_len(ss) >= m) {
        cout << 2 << '\n';
        return;
    }
    string sss = s + s + s;
    if (max_pal_len(sss) >= m) {
        cout << 3 << '\n';
        return;
    }

    string ttt = sss;
    reverse(ttt.begin(), ttt.end());
    RollingHash sh(sss), th(ttt);
    int len = ttt.size();
    int ans = 2e9;
    if (is_pal(s)) {
        ans = ceil_div(m, n);
    }
    auto f = [&](int l) {
        rep(i, 0, n) {
            bool isPal = sh.get(i, i + l) == th.get(len - l - i, len - i);
            if (isPal) {
                int rad = (l - 1) / 2;
                int midl = i + rad;
                int midr = midl + (l % 2 == 0);
                if (midr >= n)
                    continue;
                int nw = midl == midr ? 1 : 2;
                int need = ceil_div(m - nw, 2);
                int needl = need - midl;
                int needr = need - (n - midr);
                chmin(ans, ceil_div(needl, n) + ceil_div(needr, n) + 1);
            }
        }
    };
    f(n);
    f(n + 1);
    cout << (ans == 2e9 ? -1 : ans) << '\n';
}

int main() {
    int t;
    cin >> t;
    while (t--)
        solve();
}
0