Submission #1146970

#	Time	Username	Problem	Language	Result	Execution time	Memory
1146970		Zero_OP	Palinilap (COI16_palinilap)	C++17	54 / 100	349 ms	41652 KiB

palinilap

#include <bits/stdc++.h>

using namespace std;

//loops (warning : long long)
#define FOR(i, l, r) for(int i = (l); i < (r); ++i)
#define ROF(i, r, l) for(int i = (r - 1); i >= l; --i)

//pairs, tuples
#define mp make_pair
#define mt make_tuple
#define ff first
#define ss second

//vectors
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define pb push_back
#define eb emplace_back
#define sum_of(v) accumulate(all(v), 0ll)
#define sz(v) (int)v.size()
#define compact(v) v.erase(unique(all(v)), end(v))

//binary search
#define lwb lower_bound
#define upb upper_bound

//other stuffs
#define dbg(x) "[" #x " = " << (x) << "]"
#define file(task) if(fopen(task".inp", "r")){ freopen(task".inp", "r", stdin); freopen(task".out", "w", stdout); }

template<typename T>
bool minimize(T& a, const T& b){
    if(a > b) return a = b, true;
    return false;
}

template<typename T>
bool maximize(T& a, const T& b){
    if(a < b) return a = b, true;
    return false;
}

using ll = long long;
using ull = unsigned long long;
using ld = long double;
using db = double;
using pi = pair<int, int>;
using pl = pair<ll, ll>;

using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vpi = vector<pi>;
using vpl = vector<pl>;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

template<int _mod, int _alphabet>
struct HashString{ //[1, N]
    const int mod = _mod;
    const int alphabet = _alphabet;

    int N;
    vi base;
    vector<array<int, 2>> h;

    int add(int a, int b){
        a += b; if(a >= mod) a -= mod;
        return a;
    }

    int subtract(int a, int b){
        a -= b; if(a < 0) a += mod;
        return a;
    }

    int multiply(int a, int b){
        return 1LL * a * b % mod;
    }

    HashString(vi& S, int N) : N(N), h(N + 2), base(N + 1) {
        base[0] = 1;
        FOR(i, 1, N + 1) assert(S[i] > 0);
        FOR(i, 1, N + 1) base[i] = multiply(base[i - 1], alphabet);
        FOR(i, 1, N + 1) h[i][0] = add(multiply(h[i - 1][0], alphabet), S[i]);
        ROF(i, N + 1, 1) h[i][1] = add(multiply(h[i + 1][1], alphabet), S[i]);
    }

    int get_hash_forward(int l, int r){
        return subtract(h[r][0], multiply(base[r - l + 1], h[l - 1][0]));
    }

    int get_hash_backward(int l, int r){
        return subtract(h[l][1], multiply(base[r - l + 1], h[r + 1][1]));
    }
};

struct PolynomialSegmentTree{
    vl st, sum_pos, lazy_pos, lazy_add;
    PolynomialSegmentTree(int n) : st(n << 2), sum_pos(n << 2), lazy_pos(n << 2), lazy_add(n << 2) {
        build(1, 1, n);
    }

    void build(int id, int l, int r){
        if(l == r){
            sum_pos[id] += l;
        } else{
            int mid = l + r >> 1;
            build(id << 1, l, mid);
            build(id << 1 | 1, mid + 1, r);
            sum_pos[id] = sum_pos[id << 1] + sum_pos[id << 1 | 1];
        }
    }

    void apply_add(int id, int l, int r, ll v){
        st[id] += v * (r - l + 1);
        lazy_add[id] += v;
    }

    void apply_pos(int id, int l, int r, ll v){
        st[id] += v * sum_pos[id];
        lazy_pos[id] += v;
    }

    void lazy_down(int id, int l, int r, int mid){
        if(lazy_add[id] != 0){
            apply_add(id << 1, l, mid, lazy_add[id]);
            apply_add(id << 1 | 1, mid + 1, r, lazy_add[id]);
            lazy_add[id] = 0;
        }

        if(lazy_pos[id]){
            apply_pos(id << 1, l, mid, lazy_pos[id]);
            apply_pos(id << 1 | 1, mid + 1, r, lazy_pos[id]);
            lazy_pos[id] = 0;
        }
    }

    void update_add(int id, int l, int r, int u, int v, int x){
        if(u <= l && r <= v){
            apply_add(id, l, r, x);
        } else{
            int mid = l + r >> 1;
            lazy_down(id, l, r, mid);
            if(u <= mid) update_add(id << 1, l, mid, u, v, x);
            if(mid < v)  update_add(id << 1 | 1, mid + 1, r, u, v, x);
            st[id] = st[id << 1] + st[id << 1 | 1];
        }
    }

    void update_pos(int id, int l, int r, int u, int v, int x){
        if(u <= l && r <= v){
            apply_pos(id, l, r, x);
        } else{
            int mid = l + r >> 1;
            lazy_down(id, l, r, mid);
            if(u <= mid) update_pos(id << 1, l, mid, u, v, x);
            if(mid < v)  update_pos(id << 1 | 1, mid + 1, r, u, v, x);
            st[id] = st[id << 1] + st[id << 1 | 1];
        }
    }

    void polynomial_update(int l, int r, int n){
        assert(1 <= l && l <= r && r <= n);
        update_pos(1, 1, n, l, r, 1);
        update_add(1, 1, n, l, r, -(l - 1));
    }

    void reversed_polynomial_update(int l, int r, int n){
        assert(1 <= l && l <= r && r <= n);
        update_pos(1, 1, n, l, r, -1);
        update_add(1, 1, n, l, r, (r + 1));
    }

    vl trace(int n){
        vl eval(n + 1);
        auto rec = [&](auto self, int id, int l, int r) -> void{
            if(l == r) eval[l] = st[id];
            else{
                int mid = l + r >> 1;
                lazy_down(id, l, r, mid);
                self(self, id << 1, l, mid);
                self(self, id << 1 | 1, mid + 1, r);
            }
        };
        rec(rec, 1, 1, n);
        return eval;
    }
};

void testcase(int ntestcase){
    string S;
    cin >> S;
    int N = sz(S);
    S = '?' + S;

    vi s(N + 1);
    FOR(i, 0, N) s[i + 1] = S[i + 1] - 'a' + 1;
    HashString<(int)1e9 + 9, 31> mod1(s, N);
    HashString<(int)1e9 + 2187, 73> mod2(s, N);

    function<bool(int, int, int, int)> match_palindrome = [&](int l1, int r1, int l2, int r2){ //1-index
        return (min(l1, l2) > 0 && max(r1, r2) <= N) &&
        (r1 - l1 == r2 - l2) &&
        (mod1.get_hash_forward(l1, r1) == mod1.get_hash_backward(l2, r2)) &&
        (mod2.get_hash_forward(l1, r1) == mod2.get_hash_backward(l2, r2));
    };

    vector<vl> addition(N + 1, vl(26));
    vi odd(N + 1), even(N + 1);

    PolynomialSegmentTree T(N);

    ll base = 0;
    FOR(i, 1, N + 1){ //addition
        if(i < N){
            //even start from i and i + 1
            int l = 1, r = min(i, N - i), eq = 0;
            while(l <= r){
                int mid = l + r >> 1;
                if(match_palindrome(i - mid + 1, i, i + 1, i + mid)){
                    eq = mid; l = mid + 1;
                } else r = mid - 1;
            }

//            cout << "dn\n";

            base += eq;
            even[i] = eq;

            if(even[i] > 0){
                T.polynomial_update(i - even[i] + 1, i, N);
                T.reversed_polynomial_update(i + 1, i + even[i], N);
            }

            if(i - eq > 0 && i + 1 + eq <= N){
//                cout << i << '\n';
                //try to replace S[i - eq] = S[i + eq + 1]
                //try to replace S[i + eq + 1] = S[i - eq]

                int extra = 1;
                l = 1, r = N;
                while(l <= r){
                    int mid = l + r >> 1;
                    if(match_palindrome(i - eq - mid, i - eq - 1, i + eq + 2, i + eq + mid + 1)){
                        extra = 1 + mid;
                        l = mid + 1;
                    } else r = mid - 1;
                }

                int a = s[i - eq];
                int b = s[i + eq + 1];
                addition[i - eq][b] += extra;
                addition[i + eq + 1][a] += extra;
            }
        }

        int l = 2, r = min(i, N - i + 1), eq = 1;
        while(l <= r){
            int mid = l + r >> 1;
            if(match_palindrome(i - mid + 1, i, i, i + mid - 1)){
                eq = mid; l = mid + 1;
            } else r = mid - 1;
        }

        base += eq;
        odd[i] = eq;

        if(odd[i] > 1){ //because change the center let unchanged
            T.polynomial_update(i - odd[i] + 1, i - 1, N);
            T.reversed_polynomial_update(i + 1, i + odd[i] - 1, N);
        }

        if(i - eq > 0 && i + eq <= N){
            //try to replace S[i - eq] = S[i + eq]
            //try to replace S[i + eq] = S[i - eq]

            int extra = 1;
            l = 1, r = N;
            while(l <= r){
                int mid = l + r >> 1;
                if(match_palindrome(i - eq - mid, i - eq - 1, i + eq + 1, i + eq + mid)){
                    extra = 1 + mid; l = mid + 1;
                } else r = mid - 1;
            }

            int a = s[i - eq];
            int b = s[i + eq];
            addition[i - eq][b] += extra;
            addition[i + eq][a] += extra;
        }
    }

    vl loss = T.trace(N);
//    return;
    ll max_delta = 0;
    FOR(i, 1, N + 1){
        FOR(c, 0, 26) if(c != s[i]){
            ll cur = addition[i][c] - loss[i];
            maximize(max_delta, cur);
        }
    }
    cout << max_delta + base << '\n';
}

int main(){
    ios_base::sync_with_stdio(0); cin.tie(0);

#ifdef LOCAL
    freopen("task.inp", "r", stdin);
#endif // LOCAL

    int T = 1;
//    cin >> T;
    FOR(i, 0, T) testcase(i);

    return 0;
}

• Subtask 1: 17 / 17
• Subtask 2: 37 / 37
• Subtask 3: 0 / 46