This submission is migrated from previous version of oj.uz, which used different machine for grading. This submission may have different result if resubmitted.
#include <bits/stdc++.h>
#define int long long
using namespace std;
namespace std {
template <typename T> ostream &operator<<(ostream &out, const vector<T> &vec) {
out << "[";
for (int i = 0; i < (int)vec.size(); ++i) {
out << vec[i];
if (i + 1 < (int)vec.size())
out << ", ";
}
return out << "]";
}
} // namespace std
void dbg_out() { cout << endl; }
template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) {
cout << ' ' << H;
dbg_out(T...);
}
#ifdef DEBUG
#define dbg(...) cout << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...)
#endif
template <const int32_t MOD> struct ModInt {
int32_t x;
ModInt() : x(0) {}
ModInt(long long u) : x(u % MOD) {
if (x < 0)
x += MOD;
}
friend bool operator==(const ModInt &a, const ModInt &b) {
return a.x == b.x;
}
friend bool operator!=(const ModInt &a, const ModInt &b) {
return a.x != b.x;
}
friend bool operator<(const ModInt &a, const ModInt &b) { return a.x < b.x; }
friend bool operator>(const ModInt &a, const ModInt &b) { return a.x > b.x; }
friend bool operator<=(const ModInt &a, const ModInt &b) {
return a.x <= b.x;
}
friend bool operator>=(const ModInt &a, const ModInt &b) {
return a.x >= b.x;
}
static ModInt sign(long long k) {
return ((k & 1) ? ModInt(MOD - 1) : ModInt(1));
}
ModInt &operator+=(const ModInt &m) {
x += m.x;
if (x >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(const ModInt &m) {
x -= m.x;
if (x < 0LL)
x += MOD;
return *this;
}
ModInt &operator*=(const ModInt &m) {
x = (1LL * x * m.x) % MOD;
return *this;
}
friend ModInt operator-(const ModInt &a) {
ModInt res(a);
if (res.x)
res.x = MOD - res.x;
return res;
}
friend ModInt operator+(const ModInt &a, const ModInt &b) {
return ModInt(a) += ModInt(b);
}
friend ModInt operator-(const ModInt &a, const ModInt &b) {
return ModInt(a) -= ModInt(b);
}
friend ModInt operator*(const ModInt &a, const ModInt &b) {
return ModInt(a) *= ModInt(b);
}
static long long fp(long long u, long long k) {
long long res = 1LL;
while (k > 0LL) {
if (k & 1LL)
res = (res * u) % MOD;
u = (u * u) % MOD;
k /= 2LL;
}
return res;
}
static constexpr int mod() { return MOD; }
ModInt fastpow(long long k) { return ModInt(fp(x, k)); }
ModInt inv() {
assert(x);
return ModInt(fp(x, MOD - 2));
}
ModInt &operator/=(const ModInt &m) { return *this *= ModInt(m).inv(); }
friend ModInt operator/(const ModInt &a, const ModInt &b) {
return ModInt(a) *= ModInt(b).inv();
}
friend ostream &operator<<(ostream &out, const ModInt &a) {
return out << a.x;
}
friend istream &operator>>(istream &in, ModInt &a) { return in >> a.x; }
};
const int MOD1 = 1e9 + 9, MOD2 = 1e9 + 7;
template <typename T1, typename T2> struct ModPair {
T1 x;
T2 y;
ModPair() : x(0), y(0) {}
ModPair(int u) : x(u), y(u) {}
ModPair(T1 _x, T2 _y) : x(_x), y(_y) {}
ModPair &operator+=(const ModPair &other) {
x += other.x;
y += other.y;
return *this;
}
ModPair &operator*=(const ModPair &other) {
x *= other.x;
y *= other.y;
return *this;
}
ModPair &operator-=(const ModPair &other) {
x -= other.x;
y -= other.y;
return *this;
}
friend ModPair operator+(const ModPair &a, const ModPair &b) {
return ModPair(a) += ModPair(b);
}
friend ModPair operator-(const ModPair &a, const ModPair &b) {
return ModPair(a) -= ModPair(b);
}
friend ModPair operator*(const ModPair &a, const ModPair &b) {
return ModPair(a) *= ModPair(b);
}
bool operator<(const ModPair &o) const { return pair(x, y) < pair(o.x, o.y); }
bool operator>(const ModPair &o) const { return pair(x, y) > pair(o.x, o.y); }
bool operator<=(const ModPair &o) const {
return pair(x, y) <= pair(o.x, o.y);
}
bool operator>=(const ModPair &o) const {
return pair(x, y) >= pair(o.x, o.y);
}
bool operator==(const ModPair &o) const {
return pair(x, y) == pair(o.x, o.y);
}
ModPair inv() { return ModPair(x.inv(), y.inv()); };
};
using H = ModPair<ModInt<MOD1>, ModInt<MOD2>>;
const int BASE = 311;
void solve() {
map<pair<int, int>, int> cache;
string s;
cin >> s;
int N = s.size();
dbg(s, N);
vector<H> po(N), prefix(N + 1), invPo(N);
po[0] = 1;
for (int i = 1; i < N; ++i) {
po[i] = po[i - 1] * BASE;
}
invPo[N - 1] = po[N - 1].inv();
for (int i = N - 1; i; --i)
invPo[i - 1] = invPo[i] * BASE;
for (int i = 0; i < N; ++i)
prefix[i + 1] = prefix[i] + po[i] * s[i];
auto getH = [&](int deb, int fin) {
return (prefix[fin] - prefix[deb]) * invPo[deb];
};
auto dfs = [&](auto rec, int deb, int fin) -> int {
if (deb == fin)
return 0;
if (deb + 1 == fin)
return 1;
if (cache.count({deb, fin}))
return cache[{deb, fin}];
int &ret = cache[{deb, fin}];
ret = 1;
for (int len = 1; 2 * len < fin - deb; ++len) {
if (getH(deb, deb + len) == getH(fin - len, fin))
ret = max(ret, 2 + rec(rec, deb + len, fin - len));
}
return ret;
};
cout << dfs(dfs, 0, N) << '\n';
}
signed main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
int nbTests;
cin >> nbTests;
for (int iTest(0); iTest < nbTests; ++iTest)
solve();
}
# | Verdict | Execution time | Memory | Grader output |
---|
Fetching results... |
# | Verdict | Execution time | Memory | Grader output |
---|
Fetching results... |
# | Verdict | Execution time | Memory | Grader output |
---|
Fetching results... |
# | Verdict | Execution time | Memory | Grader output |
---|
Fetching results... |