oj.uz

답안 #46699

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
46699 2018-04-22T15:11:09 Z minkank 회문 (APIO14_palindrome) C++17
73 / 100
 1000 ms 35460 KB 
#include <bits/stdc++.h>
#pragma GCC optimization("O3")
#define ll long long
using namespace std;
const ll mod = (ll) 1e9+9;
const ll base = 29;
int lg2[300005];
void prepLg2(int bound){
    for(int i=2;i<=bound;i++)
        lg2[i] = lg2[i>>1] + 1;
}
struct suffixArray{
    int sa[300005], saRank[300005], tmp[300005];
    int lcp[300005][19];
    int strLen, gap;
 
    bool saCmp(int x,int y){
        if (saRank[x] != saRank[y])
            return saRank[x] < saRank[y];
        return x+gap < strLen && y+gap < strLen ? saRank[x+gap] < saRank[y+gap] : x > y;
    }
 
    void build_lcp(string &s){
        int k = 0;
        for(int i = 0; i < strLen; i ++){
            if (saRank[i] != strLen - 1){
                for (int j = sa[saRank[i] + 1]; max(i+k, j+k) < strLen && s[i + k] == s[j + k];)  ++k;
                lcp[saRank[i]][0] = k;
                if (k) k--;
            }
        }
        for(int k = 1; k < 19; k ++){
            for(int i = 0; i < strLen; i ++)
                if (i + (1<<k) < strLen)
                    lcp[i][k] = min(lcp[i][k-1], lcp[i+(1<<(k-1))][k-1]);
                else break;
        }
    }
 
    int getLcp(int l,int r){
        if (l > r)  swap(l, r);
        if (l == r) return strLen - sa[l];
        int k = lg2[r - l];
        return min(lcp[l][k], lcp[r-(1<<k)][k]);
    }
 
    void build(string &s, int isIndexFromOne = 0){
        strLen = s.size();
        //for(int i = 0; i < strLen; i ++)
        //    lcp[i].assign(20, 0);
 
        for(int i = 0; i < strLen; i ++)
            sa[i] = i, saRank[i] = s[i];
 
        for(gap = 1;;gap *= 2){
            sort(sa, sa + strLen, [&](int a, int b) {return this->saCmp(a, b);});
            //sort(sa.begin(), sa.begin() + strLen, saCmp);
            for(int i = 0; i < strLen; i ++) tmp[i+1] = tmp[i] + saCmp(sa[i], sa[i+1]);
            for(int i = 0; i < strLen; i ++) saRank[sa[i]] = tmp[i];
            if (tmp[strLen-1] == strLen-1) break;
        }
        build_lcp(s);
    }
};
int n;
string s[2];
suffixArray suff;
ll hashCode[2][300000], pBase[300000];
void prepHash(){
    pBase[0] = 1;
    for(int i=1;i<300000;i++)
        pBase[i] = pBase[i-1] * base % mod;
 
    hashCode[0][0] = s[0][0] - 'a' + 1;
    hashCode[1][0] = s[1][0] - 'a' + 1;
    for(int i=1;i<n;i++)
        hashCode[0][i] = (hashCode[0][i-1] + pBase[i] * (s[0][i] - 'a' + 1)) % mod,
        hashCode[1][i] = (hashCode[1][i-1] + pBase[i] * (s[1][i] - 'a' + 1)) % mod;
}
bool checkPalindrome(int l1,int r1){
    int l2 = n-1-r1;
    int r2 = n-1-l1;
    ll val1 = (hashCode[0][r1] - (l1 == 0 ? 0 : hashCode[0][l1-1]) + mod) % mod;
    ll val2 = (hashCode[1][r2] - (l2 == 0 ? 0 : hashCode[1][l2-1]) + mod) % mod;
    val1 = val1 * pBase[max(0, r2 - r1)] % mod;
    val2 = val2 * pBase[max(0, r1 - r2)] % mod;
    return val1 == val2;
}
 
long long ans;
 
long long solve(int p, int sz) {
    int id = suff.saRank[p];
    int l = id;
    for(int i = 18; i >= 0; --i) {
        int cur = l - (1 << i);
        if(cur < 0) continue;
        if(suff.lcp[cur][i] < sz) {
            if((n - cur) <= ans / sz) return 0;
        }
        else l = cur;
    }
    int r = id;
    for(int i = 18; i >= 0; --i) {
        if(suff.lcp[r][i] < sz) {
            int cur = min(n - 1, r + (1 << i));
            if((cur - l + 1) <= ans / sz) return 0;
        }
        else r = min(n - 1, r + (1 << i));
    }
    return 1LL * sz * (r - l + 1);
}
 
int main(){
    prepLg2(300000);
    iostream::sync_with_stdio(0);
    cin >> s[0];
    n = s[0].size();
    s[1] = s[0];
    reverse(s[1].begin(), s[1].end());
    suff.build(s[0]);
    prepHash();
    int sz0, sz1;
    sz0 = 0, sz1 = 1;
    ans = 0;
    for(int i = n - 1; i >= 0; --i) {
        int p0 = i + 2 * sz0 - 1; 
        int p1 = i + 2 * sz1 - 2;
        if(p0 >= p1) ans = max(ans, solve(i, p0 - i + 1));
        else ans = max(ans, solve(i, p1 - i + 1));
        if(i == 0) continue;
        sz0++, sz1++;
        while(sz0) {
            p0 = i - 1 + 2 * sz0 - 1;
            if(!checkPalindrome(i - 1, p0)) sz0--;
            else break;
        }
        while(sz1) {
            p1 = i - 1 + 2 * sz1 - 2;
            if(!checkPalindrome(i - 1, p1)) sz1--;
            else break;
        }
    }
    cout << ans;
}

Compilation message

palindrome.cpp:2:0: warning: ignoring #pragma GCC optimization [-Wunknown-pragmas]
 #pragma GCC optimization("O3")

Subtask #1
8.0 / 8.0

# 결과 실행 시간 메모리 Grader output
1 Correct 6 ms 3912 KB Output is correct
2 Correct 6 ms 3968 KB Output is correct
3 Correct 6 ms 4024 KB Output is correct
4 Correct 6 ms 4204 KB Output is correct
5 Correct 6 ms 4204 KB Output is correct
6 Correct 6 ms 4204 KB Output is correct
7 Correct 7 ms 4204 KB Output is correct
8 Correct 6 ms 4204 KB Output is correct
9 Correct 7 ms 4204 KB Output is correct
10 Correct 6 ms 4204 KB Output is correct
11 Correct 8 ms 4204 KB Output is correct
12 Correct 6 ms 4204 KB Output is correct
13 Correct 6 ms 4204 KB Output is correct
14 Correct 7 ms 4204 KB Output is correct
15 Correct 7 ms 4204 KB Output is correct
16 Correct 6 ms 4204 KB Output is correct
17 Correct 7 ms 4204 KB Output is correct
18 Correct 6 ms 4204 KB Output is correct
19 Correct 6 ms 4204 KB Output is correct
20 Correct 6 ms 4204 KB Output is correct
21 Correct 6 ms 4204 KB Output is correct
22 Correct 7 ms 4204 KB Output is correct
23 Correct 7 ms 4204 KB Output is correct
24 Correct 7 ms 4204 KB Output is correct
25 Correct 7 ms 4204 KB Output is correct
26 Correct 6 ms 4204 KB Output is correct
27 Correct 6 ms 4204 KB Output is correct
28 Correct 6 ms 4204 KB Output is correct
29 Correct 6 ms 4204 KB Output is correct
30 Correct 6 ms 4204 KB Output is correct
31 Correct 7 ms 4204 KB Output is correct
32 Correct 6 ms 4204 KB Output is correct

Subtask #2
15.0 / 15.0

# 결과 실행 시간 메모리 Grader output
1 Correct 7 ms 4220 KB Output is correct
2 Correct 7 ms 4220 KB Output is correct
3 Correct 7 ms 4220 KB Output is correct
4 Correct 7 ms 4220 KB Output is correct
5 Correct 7 ms 4348 KB Output is correct
6 Correct 7 ms 4348 KB Output is correct
7 Correct 9 ms 4348 KB Output is correct
8 Correct 8 ms 4348 KB Output is correct
9 Correct 8 ms 4348 KB Output is correct
10 Correct 7 ms 4348 KB Output is correct
11 Correct 7 ms 4348 KB Output is correct
12 Correct 9 ms 4348 KB Output is correct

Subtask #3
24.0 / 24.0

# 결과 실행 시간 메모리 Grader output
1 Correct 26 ms 5224 KB Output is correct
2 Correct 17 ms 5244 KB Output is correct
3 Correct 17 ms 5244 KB Output is correct
4 Correct 19 ms 5352 KB Output is correct
5 Correct 19 ms 5352 KB Output is correct
6 Correct 20 ms 5352 KB Output is correct
7 Correct 18 ms 5352 KB Output is correct
8 Correct 15 ms 5352 KB Output is correct
9 Correct 15 ms 5352 KB Output is correct
10 Correct 19 ms 5352 KB Output is correct

Subtask #4
26.0 / 26.0

# 결과 실행 시간 메모리 Grader output
1 Correct 153 ms 14588 KB Output is correct
2 Correct 155 ms 14588 KB Output is correct
3 Correct 143 ms 14588 KB Output is correct
4 Correct 184 ms 14588 KB Output is correct
5 Correct 297 ms 14624 KB Output is correct
6 Correct 224 ms 14624 KB Output is correct
7 Correct 150 ms 14624 KB Output is correct
8 Correct 138 ms 14624 KB Output is correct
9 Correct 126 ms 14624 KB Output is correct
10 Correct 244 ms 14704 KB Output is correct

Subtask #5
0 / 27.0

# 결과 실행 시간 메모리 Grader output
1 Correct 534 ms 35332 KB Output is correct
2 Correct 495 ms 35460 KB Output is correct
3 Correct 512 ms 35460 KB Output is correct
4 Correct 473 ms 35460 KB Output is correct
5 Execution timed out 1038 ms 35460 KB Time limit exceeded
6 Halted 0 ms 0 KB -