Submission #564932

#	Time	Username	Problem	Language	Result	Execution time	Memory
564932		ac2hu	Palindromes (APIO14_palindrome)	C++14	23 / 100	1081 ms	131072 KiB

palindrome

#include <bits/stdc++.h>
#ifdef DEBUG
#include "../templates/debug.h"
#else 
#define deb(x...)
#endif
using namespace std;
typedef unsigned long long ull;
 
// Generate random base in (before, after) open interval:
int gen_base(const int before, const int after) {
    auto seed = std::chrono::high_resolution_clock::now().time_since_epoch().count();
    std::mt19937 mt_rand(seed);
    int base = std::uniform_int_distribution<int>(before+1, after)(mt_rand);
    return base % 2 == 0 ? base-1 : base;
}
 
struct PolyHash {/*{{{*/
    // -------- Static variables --------
    static const int mod = (int)1e9+123; // prime mod of polynomial hashing
    static std::vector<int> pow1;        // powers of base modulo mod
    static std::vector<ull> pow2;        // powers of base modulo 2^64
    static int base;                     // base (point of hashing)
 
    // --------- Static functons --------
    static inline int diff(int a, int b) { 
        // Diff between `a` and `b` modulo mod (0 <= a < mod, 0 <= b < mod)
        return (a -= b) < 0 ? a + mod : a;
    }
 
    // -------------- Variables of class -------------
    std::vector<int> pref1; // Hash on prefix modulo mod
    std::vector<ull> pref2; // Hash on prefix modulo 2^64
 
    // Cunstructor from string:
    PolyHash(const std::string& s)
        : pref1(s.size()+1u, 0)
        , pref2(s.size()+1u, 0)
    {
        assert(base < mod);
        const int n = s.size(); // Firstly calculated needed power of base:
        while ((int)pow1.size() <= n) {
            pow1.push_back(1LL * pow1.back() * base % mod);
            pow2.push_back(pow2.back() * base);
        }
        for (int i = 0; i < n; ++i) { // Fill arrays with polynomial hashes on prefix
            assert(base > s[i]);
            pref1[i+1] = (pref1[i] + 1LL * s[i] * pow1[i]) % mod;
            pref2[i+1] = pref2[i] + s[i] * pow2[i];
        }
    }
 
    // Polynomial hash of subsequence [pos, pos+len)
    // If mxPow != 0, value automatically multiply on base in needed power. Finally base ^ mxPow
    inline std::pair<int, ull> operator()(const int pos, const int len, const int mxPow = 0) const {
        int hash1 = pref1[pos+len] - pref1[pos];
        ull hash2 = pref2[pos+len] - pref2[pos];
        if (hash1 < 0) hash1 += mod;
        if (mxPow != 0) {
            hash1 = 1LL * hash1 * pow1[mxPow-(pos+len-1)] % mod;
            hash2 *= pow2[mxPow-(pos+len-1)];
        }
        return std::make_pair(hash1, hash2);
    }
};/*}}}*/
int PolyHash::base((int)1e9 + 7);
vector<int> PolyHash::pow1{1};
vector<ull> PolyHash::pow2{1};

int brute(string s){
    // O(n^2) is easy 
    // Find all palindromes and put it in a map and then itterate to find maximum
    int n = s.size();
    vector<vector<bool>> is_pali(n, vector<bool>(n));
    for(int siz = 0;siz<n;siz++){
        for(int i = 0;i + siz<n;i++){
            int j = i + siz;
            if(siz == 0)is_pali[i][j] = true;
            else if(siz == 1)is_pali[i][j] = (s[i] == s[j]);
            else is_pali[i][j] = ((s[i] == s[j])&&is_pali[i + 1][j - 1]);
        }
    }
    PolyHash hs(s);
    // map<pair<int,ull>, int> ma;
    unordered_map<int,int> ma;
    vector<int> mx(n + 1, 0);
    for(int siz = 0;siz<n;siz++){
        for(int i = 0;i+siz<n;i++){
            int j = i + siz;
            if(is_pali[i][j]){
                auto temp = hs(i, siz + 1, n);
                int val = ++ma[temp.first];
                mx[siz + 1] = max(mx[siz + 1], val);
            }
        }
    }
    deb(ma);
    int ans = 0;
    for(int i = 0;i<n + 1;i++){
        ans = max(ans, i*mx[i]);
    }
    return ans;
}
signed main(){
    string s;cin >> s;
    cout << brute(s) << "\n";
}

• Subtask 1: 8 / 8
• Subtask 2: 15 / 15
• Subtask 3: 0 / 24
• Subtask 4: 0 / 26
• Subtask 5: 0 / 27