結果

問題 No.599 回文かい
ユーザー mai
提出日時 2017-11-27 09:31:01
言語 C++17(1z)
(gcc 8.3.0)
結果
AC  
実行時間 523 ms
コード長 5,723 Byte
コンパイル時間 2,458 ms
使用メモリ 8,920 KB
最終ジャッジ日時 2019-10-12 09:50:34

テストケース

テストケース表示
入力 結果 実行時間
使用メモリ
0_0.txt AC 4 ms
6,872 KB
0_1.txt AC 3 ms
6,872 KB
0_2.txt AC 3 ms
6,872 KB
0_3.txt AC 3 ms
6,872 KB
1_0.txt AC 3 ms
8,920 KB
1_1.txt AC 4 ms
6,872 KB
1_2.txt AC 3 ms
6,876 KB
1_3.txt AC 3 ms
6,876 KB
1_4.txt AC 3 ms
6,872 KB
1_5.txt AC 3 ms
6,876 KB
2_0.txt AC 4 ms
6,872 KB
2_1.txt AC 4 ms
6,872 KB
2_2.txt AC 4 ms
6,872 KB
2_3.txt AC 4 ms
6,872 KB
2_4.txt AC 59 ms
6,876 KB
2_5.txt AC 8 ms
6,872 KB
2_6.txt AC 458 ms
6,876 KB
2_7.txt AC 523 ms
6,872 KB
3_0.txt AC 3 ms
6,876 KB
3_1.txt AC 4 ms
6,876 KB
3_2.txt AC 3 ms
6,876 KB
evil_0.txt AC 28 ms
6,876 KB
テストケース一括ダウンロード
コンパイルメッセージ
main.cpp: 関数 ‘ll dfs(int, int)’ 内:
main.cpp:148:24: 警告: 左シフト回数 >= 型の幅となっています [-Wshift-count-overflow]
     ll key = (right << 32) | left;
                        ^~

ソースコード

diff #
#pragma GCC optimize ("O3")
#pragma GCC target ("avx")
#include "bits/stdc++.h" // define macro "/D__MAI"

using namespace std;
typedef long long int ll;

#define xprintf(fmt,...) fprintf(stderr,fmt,__VA_ARGS__)
#define debugv(v) {printf("L%d %s > ",__LINE__,#v);for(auto e:v){cout<<e<<" ";}cout<<endl;}
#define debuga(m,w) {printf("L%d %s > ",__LINE__,#m);for(int x=0;x<(w);x++){cout<<(m)[x]<<" ";}cout<<endl;}
#define debugaa(m,h,w) {printf("L%d %s >\n",__LINE__,#m);for(int y=0;y<(h);y++){for(int x=0;x<(w);x++){cout<<(m)[y][x]<<" ";}cout<<endl;}}
#define ALL(v) (v).begin(),(v).end()
#define repeat(cnt,l) for(auto cnt=0ll;(cnt)<(l);++(cnt))
#define iterate(cnt,b,e) for(auto cnt=(b);(cnt)!=(e);++(cnt))
#define MD 1000000007ll
#define PI 3.1415926535897932384626433832795
#define EPS 1e-12
template<typename T1, typename T2> ostream& operator <<(ostream &o, const pair<T1, T2> p) { o << "(" << p.first << ":" << p.second << ")"; return o; }
template<typename iterator> inline size_t argmin(iterator begin, iterator end) { return distance(begin, min_element(begin, end)); }
template<typename iterator> inline size_t argmax(iterator begin, iterator end) { return distance(begin, max_element(begin, end)); }
template<typename T> T& maxset(T& to, const T& val) { return to = max(to, val); }
template<typename T> T& minset(T& to, const T& val) { return to = min(to, val); }
void bye(string s, int code = 0) { cout << s << endl; exit(0); }
mt19937_64 randdev(8901016);
inline ll rand_range(ll l, ll h) {
    return uniform_int_distribution<ll>(l, h)(randdev);
}

#ifdef __MAI
#define getchar_unlocked getchar
#define putchar_unlocked putchar
#endif
#ifdef __VSCC
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#endif
namespace {
#define isvisiblechar(c) (0x21<=(c)&&(c)<=0x7E)
    class MaiScanner {
    public:
        template<typename T> void input_integer(T& var) {
            var = 0;
            T sign = 1;
            int cc = getchar_unlocked();
            for (; cc<'0' || '9'<cc; cc = getchar_unlocked())
                if (cc == '-') sign = -1;
            for (; '0' <= cc&&cc <= '9'; cc = getchar_unlocked())
                var = (var << 3) + (var << 1) + cc - '0';
            var = var*sign;
        }
        inline int c() { return getchar_unlocked(); }
        inline MaiScanner& operator>>(int& var) {
            input_integer<int>(var);
            return *this;
        }
        inline MaiScanner& operator>>(long long& var) {
            input_integer<long long>(var);
            return *this;
        }
        inline MaiScanner& operator>>(string& var) {
            int cc = getchar_unlocked();
            for (; !isvisiblechar(cc); cc = getchar_unlocked());
            for (; isvisiblechar(cc); cc = getchar_unlocked())
                var.push_back(cc);
            return *this;
        }
        template<typename IT> void in(IT begin, IT end) {
            for (auto it = begin; it != end; ++it) *this >> *it;
        }
    };
}
MaiScanner scanner;



namespace std {
    template<typename T1, typename T2>
    class hash<pair<T1, T2>> {
    public:
        size_t operator()(const pair<T1, T2>& x) const {
            return hash<T1>()(x.first) ^ hash<T2>()(x.second);
        }
    };
}

class rollinghash {
    typedef unsigned long long rh_t;
    static const rh_t MD_1 = (rh_t)(1e9 + 21);
    static const rh_t PW = (rh_t)(1e9 + 7);
    static vector<rh_t> pow_table[2];
public:
    vector<rh_t> hashes[2];

    rollinghash() {}
    rollinghash(const string& s) {
        build(s);
    }

    inline pair<rh_t, rh_t> operator()(int begin, int end) {
        return pair<rh_t, rh_t>(
            (hashes[0][end] - hashes[0][begin] * pow_table[0][end - begin]),
            (hashes[1][end] - (hashes[1][begin] * pow_table[1][end - begin]) % MD_1 + MD_1) % MD_1
            );
    }

    void build_pow(size_t size) {
        ++size;
        if (pow_table[0].size() < size) {
            pow_table[0].reserve(size);
            pow_table[1].reserve(size);
            if (pow_table[0].empty())
                pow_table[0].push_back(1),
                pow_table[1].push_back(1);
            for (size_t i = pow_table[0].size(); i < size; ++i) {
                pow_table[0].push_back(pow_table[0].back() * PW);
                pow_table[1].push_back(pow_table[1].back() * PW%MD_1);
            }
        }
    }
    void build(const string& src) {
        size_t m = src.size() + 1;
        build_pow(m);
        hashes[0].resize(m);
        hashes[1].resize(m);
        hashes[0][0] = hashes[1][0] = 0;
        for (size_t i = 1; i < m; ++i) {
            rh_t c = src[i - 1];
            hashes[0][i] = hashes[0][i - 1] * PW + c;
            hashes[1][i] = (hashes[1][i - 1] * PW + c)%MD_1;
        }
    }
};
vector<rollinghash::rh_t> rollinghash::pow_table[2];


ll m, n, kei;
string str;
rollinghash rh;
unordered_map<ll, int> memo;


inline bool my_same(int left, int right, int k) {
    return rh(left,left+k) == rh(right-k,right);
}

ll dfs(int left, int right) {
    if (right - left <= 1) return 1;
    ll key = (right << 32) | left;
    if (memo.count(key))
        return memo[key];
    // + [left,right]を1つのブロック
    // + [left,left+k],[right-k,right] で1つのpair
    ll ans = 1;
    for (int k = 1; left + k <= right - k; ++k) {
        //cout << " " << make_pair(left + k, right - k) << endl;
        if (my_same(left, right, k))
            ans = (ans + dfs(left + k, right - k)) % MD;
    }
    //cout << make_pair(left,right)<<ans << endl;
    return memo[key] = ans;
}


int main() {
    scanner >> str;
    n = str.size();
    rh.build(str);


    ll ans = dfs(0, n);

    cout << ans << endl;

    return 0;
}
0