text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int INF = 0x7f7f7f7f;
const long long INFLL = 0x7f7f7f7f7f7f7f7f;
vector<int> primes;
void init() {
bitset<40000> notprime;
notprime[0] = notprime[1] = true;
for (int i = 2; i < 200; i++) {
if (notprime[i]) {
for (int j = i * i; j < 40000; j += i) notprime[j] = true;
}
}
for (int i = 0; i < 40000; i++)
if (notprime[i] == false) primes.push_back(i);
}
int nonsquare(int n) {
int ans = 1;
int lim = sqrt(n);
for (int i = 0; primes[i] <= lim; i++) {
if (n % primes[i] == 0) {
int count = 0;
while (n % primes[i] == 0) {
n /= primes[i];
count++;
}
if (count % 2 == 1) ans *= primes[i];
}
}
if (n > 1) {
ans *= n;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Easy_DP:
init();
int n;
cin >> n;
int arr[n];
map<int, int> group;
vector<int> count;
for (int i = 0; i < n; i++) {
cin >> arr[i];
int res = nonsquare(arr[i]);
if (!group.count(res)) {
group.insert(pair<int, int>(res, count.size()));
count.push_back(1);
} else {
count[group[res]]++;
}
}
sort(count.begin(), count.end(), greater<int>());
vector<int> num;
vector<int> begin;
int start = 0;
for (int i = 0; i < count.size(); i++) {
for (int j = 0; j < count[i]; j++) {
begin.push_back(start);
num.push_back(i);
}
start += count[i];
}
long long dp[2][n + 2][n + 2];
memset(dp, 0, sizeof(dp));
dp[1][0][0] = 1;
for (int i = 1; i < n; i++) {
if (num[i] != num[i - 1]) {
for (int j = 0; j < i; j++) {
for (int k = 1; k <= j; k++) {
dp[i % 2][j][0] += dp[i % 2][j][k];
dp[i % 2][j][k] = 0;
}
}
}
for (int j = 0; j < i; j++) {
for (int k = 0; k <= j; k++) {
dp[(i + 1) % 2][j + 1][k + 1] =
(dp[(i + 1) % 2][j + 1][k + 1] +
(dp[i % 2][j][k] * (2 * (i - begin[i]) - k)) % MOD) %
MOD;
if (j > 0)
dp[(i + 1) % 2][j - 1][k] =
(dp[(i + 1) % 2][j - 1][k] + (dp[i % 2][j][k] * (j - k)) % MOD) %
MOD;
dp[(i + 1) % 2][j][k] =
(dp[(i + 1) % 2][j][k] +
(dp[i % 2][j][k] * (i + 1 - (2 * (i - begin[i]) - k + j - k))) %
MOD) %
MOD;
}
}
memset(dp[i % 2], 0, sizeof(dp[i % 2]));
}
cout << dp[n % 2][0][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
const int maxn = 305;
const int mod = 1000000007;
int a[maxn];
int tot;
int Array[maxn];
bool vis[maxn];
bool check(long long a) {
long long l = 1, r = 1e9;
long long mid;
while (l <= r) {
mid = (l + r) >> 1;
if (mid * mid >= a)
r = mid - 1;
else
l = mid + 1;
}
return l * l == a;
}
long long C[maxn][maxn];
long long fact[maxn];
void init() {
C[0][0] = 1;
C[1][0] = 1;
C[1][1] = 1;
for (int i = 2; i <= 300; i++) C[i][0] = 1;
for (int i = 2; i <= 300; i++)
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
fact[0] = 1;
for (int i = 1; i <= 300; i++) fact[i] = fact[i - 1] * i % mod;
}
int dp[maxn][maxn];
void solve() {
int cnt = Array[0];
dp[0][cnt - 1] = 1;
for (int i = 1; i < tot; i++) {
for (int j = 0; j < cnt; j++) {
for (int k = 0; k < Array[i]; k++) {
for (int m = 0; m <= min(j, k + 1); m++) {
dp[i][j + Array[i] - 1 - k - m] =
(dp[i][j + Array[i] - 1 - k - m] +
1LL * dp[i - 1][j] * C[Array[i] - 1][k] % mod * C[j][m] % mod *
C[cnt - 1 - j + 2][k + 1 - m] % mod) %
mod;
}
}
}
cnt += Array[i];
}
long long ans = dp[tot - 1][0];
for (int i = 0; i < tot; i++) {
ans = ans * fact[Array[i]];
ans %= mod;
}
cout << ans << endl;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
for (int j = i; j <= n; j++) {
if (check(1LL * a[i] * a[j])) {
vis[j] = 1;
Array[tot]++;
}
}
tot++;
}
init();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e6 + 20;
const double eps = 1e-8;
const long long mod = 1e9 + 7;
long long a[310];
long long fac[310];
long long inv[310];
void init() {
fac[0] = fac[1] = 1;
inv[0] = inv[1] = 1;
for (long long i = 2; i < 310; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
}
for (int i = 1; i < 310; i++) (inv[i] *= inv[i - 1]) %= mod;
}
long long C(long long n, long long k) {
long long ans = 0;
if (k > n) return ans;
ans = ((fac[n] * inv[k] % mod) * inv[n - k]) % mod;
return ans;
}
map<vector<int>, int> q;
long long dp[310];
int main() {
init();
int n;
while (~scanf("%d", &n)) {
q.clear();
for (int i = 0; i < n; i++) scanf("%lld", a + i);
for (int i = 0; i < n; i++) {
std::vector<int> v;
for (int j = 2; j * j <= a[i]; j++) {
int cnt = 0;
if (a[i] % j == 0) {
while (a[i] % j == 0) {
a[i] /= j;
cnt++;
}
}
if (cnt % 2) v.push_back((j));
}
if (a[i] > 1) v.push_back((a[i]));
q[v]++;
}
memset((dp), 0, sizeof(dp));
dp[0] = 1;
for (auto cnt : q) {
for (int i = n; i >= 0; i--) {
long long t = 0;
for (int k = 1; k <= cnt.second && k <= i; k++)
t = (t +
dp[i - k] * fac[cnt.second] % mod * C(cnt.second - 1, k - 1) %
mod * inv[k] % mod +
mod) %
mod;
dp[i] = t;
}
cout << endl;
}
long long ans = 0;
for (int i = 0; i <= n; i++) {
if ((n - i) % 2)
ans = (ans - fac[i] * dp[i] % mod + mod) % mod;
else
ans = (ans + fac[i] * dp[i] % mod + mod) % mod;
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int fac[1010], C[1010][1010];
map<int, int> mp;
int dp[2][1010];
inline int H(int n, int k) { return C[n + k - 1][k]; }
int main() {
int n;
gn(n);
for (int i = 0; i < n; i++) {
int u, v = 1;
gn(u);
for (int j = 2; j * j <= u; j++)
if (u % j == 0) {
int cnt = 0;
while (u % j == 0) u /= j, cnt++;
if (cnt & 1) v *= j;
}
v *= u;
mp[v]++;
}
for (int i = fac[0] = 1; i < 1010; i++)
fac[i] = (long long)fac[i - 1] * i % 1000000007;
for (int i = 0; i < 1010; i++)
for (int j = 0; j <= i; j++) {
if (j == 0 || i == j)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
}
int ok = 0, sum = mp.begin()->second - 1, len = sum + 1;
dp[0][sum] = fac[len];
for (map<int, int>::iterator it = ++mp.begin(); it != mp.end(); it++) {
ok ^= 1;
int cnt = it->second;
for (int i = 0; i <= n + 1; i++) dp[ok][i] = 0;
for (int i = 0; i < sum + cnt; i++) {
for (int j = 0; j <= sum; j++) {
for (int k = 0; k <= j && k <= i; k++) {
int t = cnt - i + k, tt = t - (j - k);
if (tt < 0 || t < 0 || len + 1 - j < tt) continue;
dp[ok][i] += (long long)dp[ok ^ 1][j] * C[len + 1 - j][tt] %
1000000007 * H(t, cnt - t) % 1000000007 * C[j][k] %
1000000007;
dp[ok][i] %= 1000000007;
}
}
}
for (int i = 0; i <= n + 1; i++)
dp[ok][i] = (long long)dp[ok][i] * fac[cnt] % 1000000007;
sum += cnt - 1;
len += cnt;
}
println(dp[ok][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
struct Union_Find {
vector<int> data;
Union_Find(int size) : data(size, -1) {}
bool Union(int x, int y) {
x = Find(x);
y = Find(y);
bool is_union = (x != y);
if (is_union) {
if (data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
return is_union;
}
int Find(int x) {
if (data[x] < 0) {
return x;
} else {
data[x] = Find(data[x]);
return data[x];
}
}
bool same(int x, int y) { return Find(x) == Find(y); }
int size(int x) { return -data[Find(x)]; }
};
bool square(ll x) {
ll ok = 0, ng = 1000000001;
while (ng - ok > 1) {
ll mid = (ng + ok) / 2;
if (mid * mid <= x)
ok = mid;
else
ng = mid;
}
return ok * ok == x;
}
ll f[305], fi[305], dp[305][305][305];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> a(n);
map<ll, ll> cnt;
for (int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
Union_Find uf(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (square(a[i] * a[j])) {
uf.Union(i, j);
}
}
}
map<ll, vector<ll> > memo;
for (int i = 0; i < n; i++) {
memo[uf.Find(i)].push_back(a[i]);
}
int used = 0;
dp[0][0][0] = 1;
for (auto p : memo) {
for (int i = 0; i < p.second.size(); i++) {
for (int k = 0; k <= i * 2; k++) {
for (int j = 0; j <= used - 2 * i + k + 1; j++) {
(dp[used + 1][j][k + 1] += dp[used][j][k] * (2 * i - k)) %= MOD;
if (j > 0) (dp[used + 1][j - 1][k] += dp[used][j][k] * j) %= MOD;
int rest = used - 2 * i + k - j + 1;
if (rest > 0) (dp[used + 1][j][k] += dp[used][j][k] * rest) %= MOD;
}
}
used++;
}
for (int j = 0; j <= 300; j++) {
for (int k = 1; k <= 300; k++) {
(dp[used][j + k][0] += dp[used][j][k]) %= MOD;
dp[used][j][k] = 0;
}
}
}
cout << dp[n][0][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long a[305];
int prt[305], num[305] = {0}, ha[305] = {0};
long long f[305][605] = {0};
long long c[305][305], jc[305];
int n;
bool pd(int i, int j) {
long long ha = sqrt(a[i] * a[j]);
if (ha * ha == a[i] * a[j]) return true;
return false;
}
int getfa(int x) {
if (x == prt[x]) return x;
return prt[x] = getfa(prt[x]);
}
void init() {
c[0][0] = 1;
for (int i = 1; i <= 300; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
jc[0] = 1;
for (int i = 1; i <= 300; i++) jc[i] = jc[i - 1] * i % mod;
}
void solve() {
int i, j, k, h;
int sum = num[1];
f[1][num[1] - 1] = 1;
for (i = 2; i <= num[0]; i++) {
for (j = 0; j <= sum - 1; j++)
for (k = 1; k <= num[i]; k++)
for (h = 0; h <= j && h <= k; h++) {
f[i][j - h + num[i] - k] += f[i - 1][j] * c[j][h] % mod *
c[num[i] - 1][k - 1] % mod *
c[sum + 1 - j][k - h] % mod;
f[i][j - h + num[i] - k] %= mod;
}
sum += num[i];
}
long long ans = f[num[0]][0];
for (int i = 1; i <= num[0]; i++) ans = ans * jc[num[i]] % mod;
printf("%lld\n", ans);
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) prt[i] = i;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (pd(i, j)) {
int f1, f2;
f1 = getfa(i);
f2 = getfa(j);
if (f1 != f2) prt[f1] = f2;
}
for (int i = 1; i <= n; i++) prt[i] = getfa(i);
for (int i = 1; i <= n; i++) {
if (ha[prt[i]] == 0) {
num[0]++;
ha[prt[i]] = num[0];
num[num[0]]++;
} else
num[ha[prt[i]]]++;
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int mo = 1000000007, N = 305;
int n, f[N][N], i, j, k, a[N], w, c[N], d[N], l, fac[N], s[N], p, x, C[N][N],
split[N][N], ans;
bool b[N];
inline bool isps(long long x) {
long long l = 1, r = mo - 7, m;
while (l < r) {
m = (l + r) >> 1;
if (m * m < x)
l = m + 1;
else
r = m;
}
return l * l == x;
}
bool cmp(int a, int b) { return a > b; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", a + i);
for (i = 1; i <= n; ++i)
if (!b[i]) {
for (j = i + 1, w = 0; j <= n; ++j)
if (isps(1ll * a[i] * a[j])) c[++w] = j;
for (j = 1; j <= w; ++j) b[c[j]] = 1;
d[++l] = ++w;
}
for (i = *fac = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mo;
for (i = ** C = 1; i <= n; ++i)
for (j = *C[i] = 1; j <= i; ++j)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mo;
split[1][1] = 1;
for (i = 2; i <= n; ++i)
for (j = 2, split[i][1] = 1; j <= i; ++j)
for (k = 1; k <= i - j + 1; ++k)
split[i][j] = (split[i][j] + split[i - k][j - 1]) % mo;
std::sort(d + 1, d + l + 1, cmp);
for (i = 1; i <= l; ++i) s[i] = s[i - 1] + d[i];
f[1][d[1] - 1] = 1;
for (i = 2; i <= l; ++i)
for (j = 0; j <= s[i] - i; ++j) {
int& x = f[i][j];
for (k = 1; k <= d[i]; ++k)
for (p = 0; p <= k; ++p)
if (j + p + k >= d[i] && s[i - 1] + 1 >= j + p - (d[i] - k))
x = (x + 1ll * f[i - 1][j + p - (d[i] - k)] * split[d[i]][k] % mo *
C[j + p - (d[i] - k)][p] % mo *
C[s[i - 1] + 1 - j - p + (d[i] - k)][k - p] % mo) %
mo;
}
for (i = 1, ans = *f[l]; i <= l; ++i) ans = 1ll * ans * fac[d[i]] % mo;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const long long MOD = 1e9 + 7, INF = 1e18 + 1;
using namespace std;
long long n, d[301][301], a[301], g[301][301], group[301], gr[301];
long long c[301][301], u[301][301], ptr, fact[301];
bool check(long long a, long long b) {
long long n = a * b;
long long l = 0, r = 1e9;
while (l < r) {
long long mid = (l + r) / 2;
if (mid * mid < n)
l = mid + 1;
else
r = mid;
}
return (l * l == n);
}
long long qpow(long long a, long long b) {
long long s = 1;
while (b) {
if (b % 2) s = s * a % MOD;
b /= 2;
a = a * a % MOD;
}
return s;
}
long long C(int n, int k) {
if (k > n || n < 0 || k < 0) return 0;
if (k == 0) return 1;
if (n == k) return 1;
if (u[n][k]) return c[n][k];
u[n][k] = 1;
c[n][k] = C(n - 1, k) + C(n - 1, k - 1);
while (c[n][k] >= MOD) c[n][k] -= MOD;
return c[n][k];
}
int main() {
cin >> n;
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = i * fact[i - 1] % MOD;
for (int i = 0; i < n; i++) scanf("%lld", &a[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (i != j && check(a[i], a[j])) group[i] = group[j];
}
if (!group[i]) group[i] = ++ptr;
gr[group[i]]++;
}
d[1][gr[1] - 1] = fact[gr[1]];
long long sum = 0;
for (int i = 2; i <= ptr; i++) {
sum += gr[i - 1];
for (int j = 0; j < sum; j++)
for (int k = 1; k <= min(gr[i], sum + 1); k++)
for (int f = 0; f <= min(k, j); f++)
if (d[i - 1][j]) {
long long r = d[i - 1][j];
r = r * fact[gr[i]] % MOD * C(gr[i] - 1, k - 1) % MOD;
r = r * C(j, f) % MOD * C(sum + 1 - j, k - f) % MOD;
d[i][j - f + gr[i] - k] += r;
if (d[i][j - f + gr[i] - k] >= MOD) d[i][j - f + gr[i] - k] -= MOD;
}
}
cout << d[ptr][0];
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 309;
const int mod = 1e9 + 7;
int f[maxn][maxn], C[maxn][maxn], b[maxn], a[maxn], fac[maxn];
int n;
inline void update(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
}
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void init(int mr) {
fac[0] = 1;
for (int i = 1; i <= mr; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
for (int i = 0; i <= mr; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
int main() {
n = read();
init(n);
for (int i = 1; i <= n; i++) {
int x = read(), res = 1;
for (int j = 2; j * j <= x; j++) {
int cnt = 0;
while (x % j == 0) {
x /= j;
cnt ^= 1;
}
if (cnt) res *= j;
}
if (x > 1) res *= x;
a[i] = res;
}
sort(a + 1, a + 1 + n);
a[n + 1] = -1;
int last = -1, cnt = 0;
for (int i = 1; i <= n + 1; i++) {
if (last == a[i])
cnt++;
else {
if (cnt) b[++b[0]] = cnt;
cnt = 1;
last = a[i];
}
}
sort(b + 1, b + 1 + b[0]);
int sum = b[1];
f[1][b[1] - 1] = 1;
for (int i = 1; i < b[0]; i++) {
for (int j = 0; j <= sum - i; j++)
for (int k = 1; k <= b[i + 1]; k++)
for (int p = 0; p <= j && p <= k; p++)
update(f[i + 1][j + b[i + 1] - k - p],
1ll * f[i][j] * C[b[i + 1] - 1][k - 1] % mod * C[j][p] % mod *
C[sum - 1 - j + 2][k - p] % mod);
sum += b[i + 1];
}
int ans = f[b[0]][0];
for (int i = 1; i <= b[0]; i++) ans = 1ll * ans * fac[b[i]] % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 301;
const int MOD = 1e9 + 7;
int n, k, have[MAXN];
multiset<int> arr;
long long dp[MAXN][MAXN], com[2 * MAXN][2 * MAXN], fac[MAXN];
void inp() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
arr.insert(x);
}
return;
}
bool check(long long s) {
long double sq = sqrt(s);
return int(sq) == sq;
}
void build() {
while (arr.size()) {
have[++k] = 1;
auto it = arr.begin();
int local = *it;
set<int> delet;
delet.insert(local);
while (++it != arr.end()) {
if (check((long long)(*it) * local)) {
delet.insert(*it);
have[k]++;
}
}
for (auto i : delet) {
arr.erase(i);
}
}
return;
}
void comb_fac() {
for (int i = 0; i < 2 * MAXN; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i) {
com[j][i] = 1;
} else {
com[j][i] = (com[j][i - 1] + com[j - 1][i - 1]) % MOD;
}
}
}
fac[0] = 1;
for (int i = 1; i < MAXN; i++) {
fac[i] = (fac[i - 1] * i) % MOD;
}
return;
}
void dp_upt() {
int sig = 0;
for (int ind = 1; ind < k; ind++) {
sig += have[ind];
for (int now = 0; now < sig; now++) {
for (int i = max(0, now - have[ind + 1]); i <= now + have[ind + 1]; i++) {
for (int j = 0; j <= min(now, have[ind + 1]); j++) {
int remain = now - j;
remain = i - remain;
int me = have[ind + 1] - j;
if (remain < 0) {
continue;
}
if (remain > me) {
continue;
}
me -= remain;
dp[ind + 1][i] += (((dp[ind][now] * com[me][sig + 1 - now] % MOD) *
com[j][now] % MOD) *
com[j + me - 1][remain + j + me - 1]) %
MOD;
dp[ind + 1][i] %= MOD;
}
}
}
}
}
int main() {
ios::sync_with_stdio(0);
inp();
build();
comb_fac();
dp[1][have[1] - 1] = 1;
dp_upt();
for (int i = 1; i <= k; i++) {
dp[k][0] *= fac[have[i]];
dp[k][0] %= MOD;
}
cout << dp[k][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 302;
int n, sum, a[N], parent[N];
map<int, int> first;
vector<int> cnt;
long long dp[N][3 * N], fact[3 * N], revFac[3 * N];
long long comb(int n, int k) {
if (n < k) return 0;
if (n == k or !k) return 1;
return fact[n] * revFac[n - k] % 1000000007 * revFac[k] % 1000000007;
}
long long power(long long b, long long p) {
if (p == 0) return 1;
long long sq = power(b, p / 2);
sq = sq * sq % 1000000007;
if (p & 1) sq = sq * b % 1000000007;
return sq;
}
void computeFact() {
fact[0] = fact[1] = 1;
revFac[0] = revFac[1] = 1;
for (int i = (1); i <= (int)(3 * N - 1); ++i) {
fact[i] = fact[i - 1] * i % 1000000007;
revFac[i] = power(fact[i], 1000000007 - 2);
}
}
int find(int a) { return a == parent[a] ? a : parent[a] = find(parent[a]); }
void merge(int a, int b) { parent[find(a)] = parent[find(b)]; }
bool perfectSquare(long long x) {
long long l = 1, r = 1000000000 + 2;
while (l < r) {
long long mid = (l + r) / 2;
if (mid * mid >= x)
r = mid;
else
l = mid + 1;
}
return l * l == x;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (int)(n); ++i) scanf("%d", &a[i]), parent[i] = i;
for (int i = (1); i <= (int)(n); ++i)
for (int j = (i + 1); j <= (int)(n); ++j)
if (perfectSquare(1ll * a[i] * a[j])) merge(i, j);
for (int i = (1); i <= (int)(n); ++i) ++first[find(i)];
for (pair<int, int> p : first) cnt.push_back(p.second);
n = ((int)(cnt).size());
computeFact();
dp[0][cnt[0] - 1] = 1;
for (int i = (0); i <= (int)(n - 2); ++i) {
sum += cnt[i];
for (int j = (0); j <= (int)(sum - 1); ++j)
if (dp[i][j]) {
for (int k = (1); k <= (int)(min(sum + 1, cnt[i + 1])); ++k) {
for (int l = (0); l <= (int)(min(k, j)); ++l) {
long long ways = comb(sum + 1 - j, k - l) * comb(j, l) %
1000000007 * comb(cnt[i + 1] - k + k - 1, k - 1) %
1000000007;
dp[i + 1][j - l + cnt[i + 1] - 1 - (k - 1)] =
(dp[i + 1][j - l + cnt[i + 1] - 1 - (k - 1)] +
dp[i][j] * ways % 1000000007) %
1000000007;
}
}
}
}
for (int i = (0); i <= (int)(n - 1); ++i)
dp[n - 1][0] = dp[n - 1][0] * fact[cnt[i]] % 1000000007;
cout << dp[n - 1][0];
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 773;
const long long mod = 23513892331591;
int n, ap[400], Fact[2 * N];
;
long long a[N], val[N];
int code(int x) {
int ans = 1;
for (int i = 2; i * i <= x; ++i) {
int par = 0;
while (x % i == 0) par ^= 1, x /= i;
if (par & 1) ans *= i;
}
if (x > 1) ans *= x;
return ans;
}
const int dpmod = 1e9 + 7;
int dp[N][N], Com[2 * N][2 * N];
int add(int ax, int b) {
ax += b;
if (ax >= dpmod)
ax -= dpmod;
else if (ax < 0)
ax += dpmod;
return ax;
}
int mul(int aq, int b) { return (long long)aq * b % dpmod; }
void combii() {
Com[0][0] = 1;
for (int i = 1; i < 2 * N; ++i) {
Com[i][0] = 1;
Com[i][1] = i;
Com[i][i] = 1;
for (int j = 2; j < i; ++j)
Com[i][j] = add(Com[i - 1][j], Com[i - 1][j - 1]);
}
}
void Solve() {
Fact[0] = 1;
combii();
for (int i = 1; i < 2 * N; ++i) Fact[i] = mul(i, Fact[i - 1]);
int on = n;
n = 0;
dp[1][ap[1] - 1] = 1;
for (int i = 1; i <= on; ++i) {
n += ap[i];
for (int j = 0; j < n; ++j) {
dp[i][j] %= dpmod;
for (int k = 1; k <= ap[i + 1]; ++k) {
for (int l = 0; l <= k; ++l) {
int nr = j - l + ap[i + 1] - k;
if (nr < 0) continue;
long long delta = mul(Com[j][l], Com[n - j + 1][k - l]);
delta = mul(delta, Com[ap[i + 1] - 1][k - 1]);
dp[i + 1][nr] = add(dp[i + 1][nr], mul(delta, dp[i][j]));
}
}
}
}
int valq = dp[on][0];
for (int i = 1; i <= on; ++i) valq = 1LL * valq * Fact[ap[i]] % dpmod;
cout << valq;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) val[i] = code(a[i]);
sort(val + 1, val + n + 1);
map<long long, int> aux;
for (int i = 1; i <= n; ++i) ++aux[val[i]];
vector<int> vec;
int new_n = 0;
for (auto it : aux) ap[++new_n] = it.second;
n = new_n;
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000 * 1000 * 1000 + 7;
int n, t;
int a[512];
long long fact[1024];
long long pascal[1024][1024];
map<int, int> cp;
vector<int> v;
vector<int> s;
long long memo[512][512];
long long ways(int id_coul, int nb_prob) {
if (memo[id_coul][nb_prob] != -1LL) return memo[id_coul][nb_prob];
long long ans = 0;
for (int problemes_avant = 0; problemes_avant < s[id_coul - 1];
problemes_avant++) {
long long terme = 0;
int possibilites_sans_probleme = s[id_coul - 1] + 1 - problemes_avant;
for (int p = 0; p <= min(v[id_coul], problemes_avant); p++) {
long long f = pascal[problemes_avant][p];
int problemes_restants = problemes_avant - p;
int problemes_a_creer = nb_prob - problemes_restants;
if (problemes_a_creer >= 0) {
int a_placer = v[id_coul] - p;
int nb_emplacements = a_placer - problemes_a_creer;
if ((0 <= nb_emplacements) &&
(nb_emplacements <= possibilites_sans_probleme))
f = (f * pascal[possibilites_sans_probleme][nb_emplacements]) % MOD;
else
f = 0;
int tot_emplacements = p + nb_emplacements;
int restants = v[id_coul] - tot_emplacements;
if (tot_emplacements && (restants >= 0))
f = (f * pascal[tot_emplacements + restants - 1][restants]) % MOD;
else
f = 0;
} else
f = 0;
terme = (terme + f) % MOD;
}
ans = (ans + terme * ways(id_coul - 1, problemes_avant)) % MOD;
}
return memo[id_coul][nb_prob] = ans;
}
int main() {
fact[0] = 1;
pascal[0][0] = 1;
for (long long i = 1; i < 1024; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
pascal[i][0] = pascal[i][i] = 1;
for (int j = 1; j < i; j++)
pascal[i][j] = (pascal[i - 1][j - 1] + pascal[i - 1][j]) % MOD;
}
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
int k = 1;
for (int p = 2; p * p <= a[i]; p++) {
if (a[i] % p == 0) {
int parity = 0;
while (a[i] % p == 0) {
a[i] /= p;
parity++;
}
if (parity % 2) k *= p;
}
}
k *= a[i];
cp[k]++;
}
long long ans = 1;
for (map<int, int>::iterator it = cp.begin(); it != cp.end(); it++) {
ans = (ans * fact[it->second]) % MOD;
v.push_back(it->second);
s.push_back((s.empty() ? 0 : s.back()) + v.back());
}
t = v.size();
memset(memo, -1, sizeof(memo));
for (int i = 0; i < n; i++) memo[0][i] = 0;
memo[0][v[0] - 1] = 1;
printf("%lld\n", (ans * ways(t - 1, 0)) % MOD);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void maximize(T &x, U y) {
if (x < y) x = y;
}
template <class T, class U>
void minimize(T &x, U y) {
if (x > y) x = y;
}
template <class T>
T Abs(T x) {
return (x < 0 ? -x : x);
}
template <class T>
T safe_sqrt(T x) {
return sqrt(max(x, (T)0));
}
template <class T, class U, class V>
T addmod(T x, U k, V MOD) {
return ((x + k) % MOD + MOD) % MOD;
}
template <class T, class U, class V>
T submod(T x, U k, V MOD) {
return ((x - k) % MOD + MOD) % MOD;
}
template <class T, class U, class V>
T mul(T x, U y, V MOD) {
return (long long)x * y % MOD;
}
namespace task {
const int base = 1e9 + 7;
const int maxN = 3e2;
map<int, int> group;
int c[maxN + 2][maxN + 2], dp[maxN + 2][maxN + 2], f[maxN + 2], num[maxN + 2];
int n, m = 0;
void solve() {
scanf("%d", &n);
for (int x, i = 1; i <= n; ++i) {
scanf("%d", &x);
for (int j = 2; j * j <= x; ++j) {
if (x % (j * j)) continue;
while (!(x % (j * j))) x /= (j * j);
}
++group[x];
}
for (__typeof((group).begin()) it = (group).begin(); it != (group).end();
it++)
num[++m] = it->second;
for (int i = 0; i <= maxN; ++i)
for (int j = 0; j <= i; ++j)
c[i][j] = (i == j or !j ? 1 : addmod(c[i - 1][j - 1], c[i - 1][j], base));
f[0] = 1;
for (int i = 1; i <= maxN; ++i) f[i] = mul(f[i - 1], i, base);
int all = 1;
dp[0][0] = 1;
for (int x = 1; x <= m; ++x, all += num[x - 1])
for (int ij = 0; ij <= num[x]; ++ij)
for (int y = 0; y <= all; ++y)
if (dp[x - 1][y])
for (int j = 0; j <= min(ij, y); ++j) {
int i = ij - j;
int z = all - y;
int cnt = dp[x - 1][y];
cnt = mul(cnt, c[z][i], base);
cnt = mul(cnt, c[y][j], base);
cnt = mul(cnt, c[num[x] - 1][ij - 1], base);
cnt = mul(cnt, f[num[x]], base);
dp[x][y - j + num[x] - ij] =
addmod(dp[x][y - j + num[x] - ij], cnt, base);
}
printf("%d", dp[m][0]);
}
} // namespace task
int main(void) { task::solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)5e5 + 7;
const int inf = (int)1e9 + 7;
int n;
int a[303], f[303], cnt[303], sz;
int c[303][303];
int d[303][303];
int ff[303];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
for (int j = 2; j * 1ll * j <= a[i] * 1ll; ++j) {
while (a[i] % (j * j) == 0) {
a[i] /= j * j;
}
}
}
for (int i = 0; i <= n; ++i) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; ++j) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % inf;
}
}
for (int i = 1; i <= n; ++i) {
if (!f[i]) {
f[i] = ++sz;
for (int j = i; j <= n; ++j) {
if (a[i] == a[j]) {
f[j] = f[i];
}
}
}
++cnt[f[i]];
}
ff[0] = 1;
for (int i = 1; i <= n; ++i) {
ff[i] = ff[i - 1] * 1ll * i % inf;
}
d[1][0] = 1;
int tot = 0;
for (int i = 1; i <= sz; ++i) {
for (int j = 0; j <= tot; ++j) {
if (!d[i][j]) {
continue;
}
for (int s = 1; s <= min(tot + 1, cnt[i]); ++s) {
for (int e = 0; e <= j; ++e) {
int nxt = (j - e) + (cnt[i] - s);
int ways = d[i][j] * 1ll * ff[cnt[i]] % inf;
ways = ways * 1ll * c[cnt[i] - 1][s - 1] % inf;
ways = ways * 1ll * c[j][e] % inf;
ways = ways * 1ll * c[tot + 1 - j][s - e] % inf;
(d[i + 1][nxt] += ways) %= inf;
}
}
}
tot += cnt[i];
}
printf("%d", d[sz + 1][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
const int MOD = 1e9 + 7;
int n, tot, m;
int a[N], f[N][N], fac[N], C[N][N], cnt[N];
bool vis[N];
inline void prepare() {
for (int i = (0); i <= (N - 1); i++) C[i][0] = 1;
for (int i = (1); i <= (N - 1); i++)
for (int j = (1); j <= (i); j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
fac[0] = 1;
for (int i = (1); i <= (N - 1); i++) fac[i] = 1LL * fac[i - 1] * i % MOD;
}
inline bool check(long long x) { return floor(sqrt(x)) == sqrt(x); }
int main() {
scanf("%d", &n);
prepare();
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]);
for (int i = (1); i <= (n); i++) {
if (vis[i]) continue;
vis[i] = 1;
cnt[++tot] = 1;
for (int j = (i + 1); j <= (n); j++)
if (check(1LL * a[i] * a[j])) vis[j] = 1, cnt[tot]++;
}
f[1][cnt[1] - 1] = 1;
m = cnt[1];
for (int i = (2); i <= (tot); i++) {
for (int j = (0); j <= (m - 1); j++)
for (int k = (1); k <= (cnt[i]); k++)
for (int p = (0); p <= (k); p++) {
if (p > j) break;
f[i][j + cnt[i] - k - p] += 1LL * f[i - 1][j] * C[cnt[i] - 1][k - 1] %
MOD * C[j][p] % MOD *
C[m - 1 - j + 2][k - p] % MOD;
f[i][j + cnt[i] - k - p] %= MOD;
}
m += cnt[i];
}
int ans = f[tot][0];
for (int i = (1); i <= (tot); i++) ans = 1LL * ans * fac[cnt[i]] % MOD;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool Max(T1 &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <typename T1, typename T2>
bool Min(T1 &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <int MOD>
struct ModInt {
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) : x(sig) {}
ModInt(signed long long sig) : x(sig % MOD) {}
int get() const { return (int)x; }
ModInt pow(unsigned p) {
ModInt res = 1, a = *this;
while (p) {
if (p & 1) res *= a;
a *= a;
p >>= 1;
}
return res;
}
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return (*this) *= that.power(MOD - 2); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
};
const int N = 200001;
ModInt<1000000007> f[2][300];
ModInt<1000000007> C[301][301];
ModInt<1000000007> P[301];
bool isper(long long i) {
long long l = 1, r = min(i, 1000000000LL);
while (l <= r) {
long long m = l + r >> 1;
if (m * m <= i)
l = m + 1;
else
r = m - 1;
}
return r * r == i;
}
void solve() {
int n;
long long v;
cin >> n;
C[0][0] = 1;
P[0] = 1;
for (int i = 1; i <= (n); ++i) {
C[i][0] = 1;
P[i] = P[i - 1] * i;
for (int j = 1; j <= (i); ++j) C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
vector<pair<long long, long long> > grp;
for (int i = 0; i < (n); ++i) {
cin >> v;
bool found = 0;
for (auto &e : grp) {
if (isper(e.first * v)) {
e.second++;
found = 1;
break;
}
}
if (!found) grp.emplace_back(v, 1);
}
int c = 0;
int sz = 0;
f[0][0] = 1;
for (auto &e : grp) {
c ^= 1;
int cur = e.second;
for (int i = 0; i < (sz + cur); ++i) f[c][i] = 0;
for (int sg = 1; sg <= (min(cur, sz + 1)); ++sg)
for (int bad = 0; bad <= (max(0, sz - 1)); ++bad)
for (int badsg = 0; badsg <= (min(bad, sg)); ++badsg) {
f[c][cur - sg + bad - badsg] += f[!c][bad] * P[cur] *
C[cur - 1][sg - 1] * C[bad][badsg] *
C[sz + 1 - bad][sg - badsg];
}
sz += cur;
}
cout << f[c][0].x << '\n';
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
int TC = 1;
for (int TI = 1; TI <= (TC); ++TI) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 300 + 190;
const long long mod = 1e9 + 7;
int n, N;
long long arr[maxN], num[maxN], g[maxN], c[maxN][maxN], p[maxN], f[maxN][maxN];
void io() {
ios_base::sync_with_stdio(false);
cin.tie(0);
}
bool check(long long a, long long b) {
long long tmp = sqrt(a * b);
return (a * b == tmp * tmp);
}
long long C(int k, int n1) {
if (k > n1) return 0;
if (2 * k >= n1) k = n1 - k;
if (c[k][n1]) return c[k][n1];
if (k == 0) return 1;
return (c[k][n1] = (C(k, n1 - 1) + C(k - 1, n1 - 1)) % mod);
}
int main() {
io();
cin >> n;
N = 0;
for (int i = 1; i <= n; ++i) cin >> arr[i];
for (int i = 1; i <= n; ++i) {
if (!g[i]) {
g[i] = ++N;
num[g[i]] = 1;
for (int j = i + 1; j <= n; ++j)
if (check(arr[i], arr[j])) g[j] = g[i], num[g[i]]++;
}
}
p[1] = 1;
for (int i = 2; i <= n; ++i) p[i] = (p[i - 1] * i) % mod;
f[0][0] = 1;
f[1][num[g[1]] - 1] = p[num[g[1]]];
long long total = 0;
long long sz = 0;
for (int i = 1; i < N; ++i) {
total += num[i];
sz = num[i + 1];
for (int j = 0; j < total; ++j) {
if (!f[i][j]) continue;
for (int s = 1; s <= min(sz, total + 1); ++s) {
for (int d = 0; d <= min(j, s); ++d) {
f[i + 1][j + sz - s - d] += f[i][j] * p[sz] % mod * C(s - 1, sz - 1) %
mod * C(d, j) % mod *
C(s - d, total + 1 - j) % mod;
f[i + 1][j + sz - s - d] %= mod;
}
}
}
}
cout << f[N][0] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[310][310], parent[310], arr[310], cmb[310][310], M = 1e9 + 7,
fact[310];
vector<long long> grp[310];
void pre() {
long long i, j;
fact[0] = 1;
for (i = 1; i <= 300; i++) fact[i] = fact[i - 1] * i, fact[i] %= M;
cmb[0][0] = cmb[1][0] = cmb[1][1] = 1;
for (i = 2; i <= 300; i++) {
cmb[i][0] = 1;
for (j = 1; j <= i; j++) {
cmb[i][j] = cmb[i - 1][j] + cmb[i - 1][j - 1];
cmb[i][j] %= M;
}
}
}
long long fexpo(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2) {
res *= a;
res %= M;
}
a *= a;
a %= M;
b /= 2;
}
return res;
}
int main() {
long long n, m, i, j, k, l;
ios_base::sync_with_stdio(0);
cin.tie(0);
pre();
cin >> n;
for (i = 1; i <= n; i++) cin >> arr[i];
for (i = 1; i <= n; i++) parent[i] = i;
long long K = 1;
for (i = 1; i <= n; i++) {
if (parent[i] != i) continue;
grp[K].push_back(i);
for (j = i + 1; j <= n; j++) {
long long p = sqrt(arr[i] * arr[j]);
if (p * p == arr[i] * arr[j]) parent[j] = i, grp[K].push_back(j);
}
K++;
}
dp[0][0] = 1;
for (i = 1; i <= n + 1; i++) dp[0][i] = 0;
long long sum = 0;
for (i = 1; i < K; i++) {
sort(grp[i].begin(), grp[i].end());
long long op = grp[i].size(), x, distinct = 1, res = 1;
for (j = 1; j < op; j++)
if (grp[i][j] == grp[i][j - 1])
distinct++;
else {
res = res * fact[distinct];
distinct = 1;
res %= M;
}
res = res * fact[distinct];
distinct = 1;
res %= M;
for (x = 0; x <= sum + 1; x++) {
for (j = 0; j <= min(x, op); j++) {
for (k = 0; k <= min(sum + 1 - x, op - j); k++) {
long long opp = cmb[x][j] * cmb[sum + 1 - x][k];
opp %= M;
long long opp2 = cmb[op - 1][j + k - 1] * fact[op];
opp2 %= M;
opp *= (opp2 * fexpo(res, M - 2)) % M;
opp %= M;
dp[i][x - j + op - j - k] += (dp[i - 1][x] * opp);
dp[i][x - j + op - j - k] %= M;
}
}
}
sum += op;
}
cout << dp[K - 1][0] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = (int)(1e9) + 7;
long long A[510];
long long C[510][510];
long long dp[310][500];
int n;
int seq[310];
int belong[310], a[310];
void pre() {
A[0] = A[1] = 1;
for (int i = 2; i < 500; ++i) {
A[i] = A[i - 1] * i % mod;
}
for (int i = 0; i < 500; ++i) {
C[0][i] = 1;
for (int j = 1; j <= i; ++j) {
C[j][i] = (C[j][i - 1] + C[j - 1][i - 1]) % mod;
}
}
}
int solve() {
memset(dp, 0, sizeof(dp));
dp[1][seq[1] - 1] = 1;
long long sum = seq[1];
for (int i = 2; i <= n; ++i) {
for (int j = 0; j < sum; ++j) {
for (int k = 1; k <= seq[i]; ++k) {
for (int h = 0; h <= j && h <= k; ++h) {
dp[i][j - h + seq[i] - k] += dp[i - 1][j] * C[h][j] % mod *
C[k - h][sum + 1 - j] % mod *
C[k - 1][seq[i] - 1] % mod;
dp[i][j - h + seq[i] - k] %= mod;
}
}
}
sum += seq[i];
}
long long ret = dp[n][0];
for (int i = 1; i <= n; ++i) {
ret = ret * A[seq[i]] % mod;
}
return ret;
}
bool ok(int i, int j) {
long long p = (long long)a[i] * a[j];
long long q = sqrt(p);
if (q * q == p)
return 1;
else
return 0;
}
void getseq() {
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
int nn = 0;
for (int i = 1; i <= n; ++i) {
if (belong[i] == 0) {
int num = 1;
belong[i] = ++nn;
for (int j = i + 1; j <= n; ++j)
if (ok(i, j)) {
belong[j] = nn;
num++;
}
seq[nn] = num;
}
}
n = nn;
}
int main() {
pre();
scanf("%d", &n);
getseq();
printf("%d\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const long long mod = 1e9 + 7;
long long dp[330][330];
long long c[330][330];
unordered_map<int, int> f;
void build(int x) {
for (int i = 2; i * i <= x; i++) {
while (x % (i * i) == 0) x /= (i * i);
}
f[x]++;
}
int num[330];
long long p[330];
void init() {
for (int i = 0; i < 330; i++) c[i][i] = c[i][0] = 1;
for (int i = 2; i < 330; i++) {
for (int j = 1; j < i; j++) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
p[0] = 1;
for (int i = 1; i < 330; i++) p[i] = p[i - 1] * i % mod;
}
long long C(int m, int n) {
if (n > m) return 0;
return c[m][n];
}
int main() {
init();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
build(x);
}
int cnt = 1;
for (auto elem : f) {
num[cnt++] = elem.second;
}
memset(dp, 0, sizeof(dp));
dp[1][num[1] - 1] = 1;
int tot = num[1];
for (int i = 2; i < cnt; i++) {
for (int j = 0; j < tot; j++) {
if (dp[i - 1][j] == 0) continue;
for (int k = 1; k <= num[i]; k++) {
for (int l = 0; l <= j; l++) {
long long &ans = dp[i][j - l + num[i] - k];
ans += dp[i - 1][j] * C(num[i] - 1, k - 1) % mod * C(j, l) % mod *
C(tot - j + 1, k - l) % mod;
ans %= mod;
}
}
}
tot += num[i];
}
for (int i = 1; i < cnt; i++) {
dp[cnt - 1][0] *= p[num[i]];
dp[cnt - 1][0] %= mod;
}
cout << dp[cnt - 1][0] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << '{';
for (int i = (0), __i = (((int)(vec).size())); i < __i; i++) {
os << vec[i];
if (i + 1 != ((int)(vec).size())) os << ',';
}
os << '}';
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &par) {
os << '(' << par.first << ',' << par.second << ')';
return os;
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
template <class T>
T sqr(T x) {
return x * x;
}
const long long MOD = 1e9 + 7;
long long bin_pow(long long base, long long p) {
if (p == 1) return base;
if (p % 2 == 0) {
long long t = bin_pow(base, p / 2);
return t * t % MOD;
} else
return bin_pow(base, p - 1) * base % MOD;
}
long long inverse_element(long long x) { return bin_pow(x, MOD - 2); }
long long divide(long long a, long long b) {
return a * inverse_element(b) % MOD;
}
long long mult(long long a, long long b) { return (a * b) % MOD; }
long long dp[333][333];
long long fact[333];
long long comb[333][333];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
fact[0] = 1;
for (int i = (1), __i = (333); i < __i; i++) fact[i] = mult(fact[i - 1], i);
for (int i = (0), __i = (333); i < __i; i++) {
for (int j = (0), __j = (i + 1); j < __j; j++) {
comb[i][j] = divide(fact[i], mult(fact[j], fact[i - j]));
}
}
int n;
cin >> n;
vector<vector<long long>> v;
for (int i = (0), __i = (n); i < __i; i++) {
long long a;
cin >> a;
bool found = false;
for (int j = (0), __j = (((int)(v).size())); j < __j; j++) {
long long t = sqrt(v[j][0] * a);
if (v[j][0] * a == t * t) {
v[j].push_back(a);
found = true;
break;
}
}
if (!found) v.push_back(vector<long long>({a}));
}
dp[0][0] = 1;
long long spaces = 1;
for (int x = (0), __x = (((int)(v).size())); x < __x; x++) {
for (int ij = (1), __ij = (((int)(v[x]).size()) + 1); ij < __ij; ij++) {
for (int y = (0), __y = (spaces + 1); y < __y; y++) {
if (dp[x][y] > 0)
for (int j = (0), __j = (min(ij, y) + 1); j < __j; j++) {
int i = ij - j;
int z = spaces - y;
dp[x + 1][(y - j) + (((int)(v[x]).size()) - ij)] +=
mult(dp[x][y], mult(comb[y][j], comb[z][i])) *
mult(comb[((int)(v[x]).size()) - 1][ij - 1],
fact[((int)(v[x]).size())]);
dp[x + 1][(y - j) + (((int)(v[x]).size()) - ij)] %= MOD;
}
}
}
spaces += ((int)(v[x]).size());
}
cout << dp[((int)(v).size())][0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9 + 1e8;
const int maxn = 305;
const int mod = 1e9 + 7;
int n, gcnt;
int arr[maxn], gto[maxn], gsiz[maxn], fact[maxn];
int dp[maxn][maxn];
int c[maxn][maxn];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
fact[0] = c[0][0] = 1;
for (int i = 1; i <= n + 1; ++i) {
fact[i] = (1LL * fact[i - 1] * i) % mod;
c[i][0] = 1;
for (int j = 1; j <= i; ++j) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
for (int i = 1; i <= n; ++i) cin >> arr[i];
for (int i = 1; i <= n; ++i)
if (gto[i] == 0) {
gto[i] = ++gcnt;
gsiz[gcnt] = 1;
for (int j = i + 1; j <= n; ++j) {
if (gto[j] == 0) {
long long kv = 1LL * arr[i] * arr[j];
long long t = sqrt((long double)kv);
if ((t - 1) * (t - 1) == kv || t * t == kv || (t + 1) * (t + 1) == kv)
gto[j] = gcnt, gsiz[gcnt] += 1;
;
}
}
}
dp[0][0] = 1;
int len = 0;
for (int i = 1; i <= gcnt; ++i) {
for (int j = 0; j <= max(0, len - 1); ++j) {
for (int a = 1; a <= min(gsiz[i], len + 1); ++a) {
for (int b = max(0, a + j - len - 1); b <= min(a, j); ++b) {
int cnt = (1LL * fact[gsiz[i]] * c[gsiz[i] - 1][a - 1]) % mod;
cnt = (1LL * cnt * c[j][b]) % mod;
cnt = (1LL * cnt * c[len + 1 - j][a - b]) % mod;
dp[i][j - b + gsiz[i] - a] =
(dp[i][j - b + gsiz[i] - a] + 1LL * cnt * dp[i - 1][j]) % mod;
}
}
}
len += gsiz[i];
}
cout << dp[gcnt][0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int N, a[400], b[400], sum[400];
int C[400][400], Fac[400], dp[400][400];
inline bool is_sqr(long long x) {
if (x < 9) return x == 1 || x == 4;
long long L = 2, R = mod;
while (L + 1 < R) {
register long long mid = (L + R) >> 1, test = mid * mid - x;
if (!test) return true;
test < 0 ? L = mid : R = mid;
}
return false;
}
int main() {
for (int i = 0; i <= 300; i++) C[i][0] = 1;
for (int i = 1; i <= 300; i++)
for (int j = 1; j <= 300; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
Fac[0] = 1;
for (int i = 1; i <= 300; i++) Fac[i] = 1ll * Fac[i - 1] * i % mod;
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", a + i);
int tot = 0;
for (int i = 1; i <= N; i++)
if (a[i]) {
int cnt = 1;
for (int j = i + 1; j <= N; j++)
if (a[j] && is_sqr(1ll * a[i] * a[j])) cnt++, a[j] = 0;
b[++tot] = cnt;
}
N = tot;
for (int i = 1; i <= N; i++) sum[i] = sum[i - 1] + b[i];
dp[1][b[1] - 1] = 1;
for (int i = 1; i < N; i++)
for (int j = 0; j < sum[i]; j++)
if (dp[i][j]) {
for (int x = 0; x <= sum[i] + 1 - j; x++)
for (int y = 0; y <= j; y++)
if (x + y > 0 && x + y <= b[i + 1])
(dp[i + 1][b[i + 1] + j - x - (y << 1)] +=
((1ll * dp[i][j] * C[j][y] % mod) * C[sum[i] + 1 - j][x] % mod) *
C[b[i + 1] - 1][x + y - 1] % mod) %= mod;
}
int ans = dp[N][0];
for (int i = 1; i <= N; i++) ans = 1ll * ans * Fac[b[i]] % mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long comb[400][400];
long long arr[400], dp[400][400], fact[400];
bool isSquare(long long x) {
long long p = sqrt(x);
bool ok = p * p == x;
return ok;
}
long long ele[400], id[400];
void pre() {
fact[0] = 1;
for (int i = 0; i < 400; i++) comb[0][i] = 0;
for (int i = 0; i < 400; i++) comb[i][0] = 1;
for (int i = 1; i < 400; i++) {
fact[i] = (i * fact[i - 1]) % 1000000007ll;
for (int j = 1; j < 400; j++) {
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % 1000000007ll;
}
}
}
int main() {
pre();
int t;
t = 1;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ele[i];
id[i] = i;
}
map<int, int> gg;
for (int i = 1; i <= n; i++) {
if (id[i] == i)
for (int j = i + 1; j <= n; j++)
if (isSquare(ele[i] * ele[j])) id[j] = i;
gg[id[i]]++;
}
for (int i = 0; i < 400; i++)
for (int j = 0; j < 400; j++) dp[i][j] = 0;
dp[0][0] = 1;
long long totalSpaces = 1;
int i = 1;
for (auto it : gg) {
arr[i] = it.second;
for (int y = 0; y <= totalSpaces; y++) {
for (int taken = 1; taken <= arr[i]; taken++) {
if (dp[i - 1][y]) {
for (int bad = 0; bad <= min(taken, y); bad++) {
int good = taken - bad;
long long tmp = (dp[i - 1][y] * comb[y][bad]) % 1000000007ll;
tmp = (tmp * comb[totalSpaces - y][good]) % 1000000007ll;
tmp = (tmp * comb[arr[i] - 1][taken - 1]) % 1000000007ll;
tmp = (tmp * fact[arr[i]]) % 1000000007ll;
dp[i][y - bad + arr[i] - taken] += tmp;
dp[i][y - bad + arr[i] - taken] %= 1000000007ll;
}
}
}
}
totalSpaces += arr[i];
i++;
}
cout << dp[i - 1][0] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 310;
long long dp[N][N];
int a[N];
int c[N], visit[N];
long long com[N][N];
long long fac[N];
long long P[N][N];
long long f[N][N];
void add(long long &x, long long y) {
x += y;
if (x >= mod) x %= mod;
}
void init() {
fac[0] = fac[1] = 1;
for (int i = 2; i < N; i++) fac[i] = fac[i - 1] * i % mod;
for (int i = 0; i < N; i++) {
com[i][0] = com[i][i] = 1;
for (int j = 1; j < i; j++)
com[i][j] = (com[i - 1][j] + com[i - 1][j - 1]) % mod;
}
P[0][0] = 1;
for (int i = 1; i < N; i++) {
for (int j = 0; j <= i; j++) {
P[i][j] = com[i][j] * fac[i - j] % mod;
}
}
f[1][1] = 1;
for (int i = 2; i < N; i++) {
for (int j = 1; j <= i; j++) {
f[i][j] = (f[i - 1][j] * (i - 1 + j) + f[i - 1][j - 1]) % mod;
}
}
}
bool check(long long n) {
long long x = sqrt(n * 1.0);
while (x * x <= n) x++;
x--;
return x * x == n;
}
int main() {
int n, m = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
if (visit[i]) continue;
int cnt = 1;
visit[i] = 1;
for (int j = i + 1; j <= n; j++) {
if (visit[j]) continue;
if (check(1LL * a[i] * a[j])) cnt++, visit[j] = 1;
}
c[++m] = cnt;
}
sort(c + 1, c + m + 1);
init();
dp[1][c[1] - 1] = fac[c[1]];
int tot = c[1];
int cal = 0;
for (int i = 1; i < m; i++) {
for (int j = 0; j <= tot; j++) {
if (!dp[i][j]) continue;
for (int k = 1; k <= c[i + 1]; k++) {
int con = c[i + 1] - k;
for (int r = max(0, k - j); r <= min(tot + 1 - j, k); r++) {
add(dp[i + 1][j - (k - r) + con], dp[i][j] * com[tot + 1 - j][r] %
mod * com[j][k - r] % mod *
fac[k] % mod * f[c[i + 1]][k]);
}
}
}
tot += c[i + 1];
}
cout << dp[m][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
inline void writeln(int x) {
char buffor[21];
register int i = 0;
int neg = 0;
if (x < 0) {
neg = 1;
x = -x;
}
do {
buffor[i++] = (x % 10) + '0';
x /= 10;
} while (x);
i--;
if (neg) putchar('-');
while (i >= 0) putchar(buffor[i--]);
putchar('\n');
}
const int N = 310;
const long long base = (long long)1e9 + 7;
int n, sz[N], gr[N], num;
long long a[N];
long long gt[N];
long long f[N][N], c[N][N];
void input() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
num = 0;
for (int i = 1; i <= n; i++)
if (!gr[i]) {
num++;
gr[i] = num;
for (int j = i + 1; j <= n; j++) {
long long can = (long long)sqrt(a[i] * a[j]);
if (can * can == a[i] * a[j]) gr[j] = gr[i];
}
}
for (int i = 1; i <= n; i++) sz[gr[i]]++;
}
long long power(long long x, long long k) {
if (k == 1) return x;
long long tmp = power(x, k / 2);
if (k % 2 == 0)
return tmp * tmp % base;
else
return ((tmp * tmp) % base * x) % base;
}
long long CC(int k, int n) {
if (k > n) return 0;
return gt[n] * power(gt[k] * gt[n - k] % base, base - 2) % base;
}
long long C(int k, int n) { return c[k][n]; }
void Add(long long &a, long long b) { a = (a + b) % base; }
void solve() {
gt[0] = 1;
for (int i = 1; i <= N - 1; i++) gt[i] = gt[i - 1] * i % base;
for (int k = 0; k <= N - 1; k++)
for (int n = k; n <= N - 1; n++) c[k][n] = CC(k, n);
int total = 0;
f[0][0] = 1;
for (int i = 0; i <= num - 1; i++) {
for (int j = 0; j <= total; j++)
if (f[i][j]) {
for (int S = 1; S <= min(sz[i + 1], total + 1); S++)
for (int D = 0; D <= min(j, S); D++) {
long long T = ((C(S - 1, sz[i + 1] - 1) * C(D, j) % base) *
C(S - D, total + 1 - j) % base);
Add(f[i + 1][j - D + sz[i + 1] - S], f[i][j] * T % base);
};
}
total += sz[i + 1];
};
long long res = f[num][0];
for (int i = 1; i <= num; i++) res = res * gt[sz[i]] % base;
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
const long long N = 305;
const long long MOD = 1e9 + 7;
using namespace std;
long long n, size[N], tot = 0;
long long jie[N], f[N][N], a[N], p[N], ts[N], c[N][N];
long long chk(long long x) {
long long m = sqrt(x);
if (m * m == x) return 1;
return 0;
}
long long cmp(long long x, long long y) { return x > y; }
void pre() {
for (long long i = 0; i <= n; i++) c[i][i] = c[i][0] = 1, c[i][1] = i;
for (long long i = 3; i <= n; i++) {
for (long long j = 2; j <= i - 1; j++) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
}
}
jie[1] = 1;
for (long long i = 2; i <= n; i++) jie[i] = jie[i - 1] * i % MOD;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (long long i = 1; i <= n; i++) {
long long flag = 0;
for (long long grp = 1; grp <= tot; grp++)
if (chk(p[grp] * a[i])) {
size[grp]++;
flag = 1;
break;
}
if (flag == 0) {
tot++;
p[tot] = a[i];
size[tot] = 1;
}
}
sort(size + 1, size + tot + 1, cmp);
pre();
ts[0] = 0;
for (long long i = 1; i <= tot; i++) ts[i] = ts[i - 1] + size[i];
f[0][0] = 1;
long long m = 0;
for (long long i = 1; i <= tot; i++) {
for (long long j = 0; j < n && j <= m + 1; j++) {
if (f[i - 1][j] == 0) continue;
for (long long k = 0; k < size[i]; k++) {
long long temp = f[i - 1][j] * c[size[i] - 1][k];
temp %= MOD;
for (long long p = 0; p <= k + 1 && p <= j + size[i] - 1 - k; p++) {
long long temp1 = temp * c[j][p];
temp1 %= MOD;
f[i][j + size[i] - 1 - k - p] +=
(temp1 * c[m + 1 - j][k + 1 - p]) % MOD;
f[i][j + size[i] - 1 - k - p] %= MOD;
}
}
}
m += size[i];
}
for (long long i = 1; i <= tot; i++)
f[tot][0] = (f[tot][0] * jie[size[i]]) % MOD;
printf("%lld", f[tot][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double pi = acos(-1.0);
const int maxn = 100000 + 10;
const int mod = 1e9 + 7;
long long dp[500][500];
long long C[500][500];
long long fact[500];
int cnt[500];
int a[500];
int vis[500];
int sz;
int check(long long x) {
long long l = 1, r = 1e9;
long long now = l;
while (l <= r) {
long long mid = (l + r) >> 1;
if (mid * mid <= x)
now = mid, l = mid + 1;
else
r = mid - 1;
}
return now * now == x;
}
inline long long M(long long x) { return x % mod; }
void init() {
C[0][0] = 1;
fact[0] = 1;
for (int i = 1; i <= 300; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = M(C[i - 1][j] + C[i - 1][j - 1]);
}
}
for (int i = 1; i <= 300; i++) fact[i] = M(fact[i - 1] * i);
}
void slove() {
dp[0][cnt[0] - 1] = 1;
int lim = cnt[0];
for (int i = 1; i < sz; i++) {
for (int j = 0; j < lim; j++) {
for (int k = 0; k < cnt[i]; k++) {
for (int m = 0; m <= min(j, k + 1); m++) {
dp[i][j + cnt[i] - 1 - k - m] =
M(dp[i][j + cnt[i] - 1 - k - m] +
dp[i - 1][j] * C[cnt[i] - 1][k] % mod * C[j][m] % mod *
C[lim - 1 - j + 2][k + 1 - m]);
}
}
}
lim += cnt[i];
}
long long ans = dp[sz - 1][0];
for (int i = 0; i < sz; i++) {
ans *= fact[cnt[i]];
ans %= mod;
}
cout << ans << endl;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < n; i++) {
if (vis[i] == 0) {
for (int j = i; j < n; j++) {
if (check(1LL * a[i] * a[j])) {
cnt[sz]++;
vis[j] = 1;
}
}
sz++;
}
}
init();
slove();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const N = 200 * 1000 + 16;
int const M = 1000 * 1000 * 1000 + 7;
int n;
int a[320];
int f[616];
int ncr[616][616];
int dp[616][616];
struct dsu {
int fa[500];
dsu(int n) { iota(fa, fa + n + 10, 0); }
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void unite(int x, int y) { fa[find(x)] = find(y); }
};
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
dsu u(n);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) {
ll x = 1ll * a[i] * a[j];
ll s = sqrt(x) + 0.5;
if (s * s == x || (s + 1) * (s + 1) == x || (s - 1) * (s - 1) == x)
u.unite(i, j);
}
memset(a, 0, sizeof a);
for (int i = 0; i < n; ++i) a[u.find(i)]++;
sort(a, a + n, greater<int>());
int m = find(a, a + n, 0) - a;
for (int i = 0; i < 616; ++i) ncr[i][0] = ncr[i][i] = 1;
for (int i = 1; i < 616; ++i)
for (int j = 1; j < i; ++j)
ncr[i][j] = (ncr[i - 1][j] + ncr[i - 1][j - 1]) % M;
f[0] = 1;
for (int i = 1; i < 616; ++i) f[i] = 1ll * i * f[i - 1] % M;
dp[0][a[0] - 1] = 1;
int k = a[0];
for (int i = 1; i < m; ++i) {
int len = a[i];
for (int p = 0; p < k; ++p) {
int x = dp[i - 1][p];
if (not x) continue;
for (int g = 1; g <= len; ++g) {
for (int u = min({len, p, g}); u >= 0; --u) {
ll y = 1ll * ncr[k - p + 1][g - u] * ncr[p][u] % M;
dp[i][p - u + len - g] += x * y % M * ncr[len - 1][g - 1] % M;
dp[i][p - u + len - g] %= M;
}
}
}
k += len;
}
int ans = dp[m - 1][0];
for (int i = 0; i < m; ++i) ans = 1ll * ans * f[a[i]] % M;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long b[500], a[500];
long long A[600];
long long dp[1000][1000];
long long C[600][600];
void Init() {
for (int i = 0; i < 550; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
}
A[0] = 1;
for (int i = 1; i < 550; i++) A[i] = (A[i - 1] * i) % MOD;
}
int main() {
Init();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &b[i]);
}
for (int i = 1; i <= n; i++) {
int t = b[i];
for (int j = 2; j * j <= b[i]; j++) {
while (t % (j * j) == 0) {
t /= (j * j);
}
}
b[i] = t;
}
if (n == 1) {
printf("1\n");
return 0;
}
sort(b + 1, b + 1 + n);
int cnt = 1;
for (int i = 1; i <= n; i++) {
if (i == n) {
a[cnt]++;
} else if (b[i] == b[i + 1]) {
a[cnt]++;
} else {
a[cnt]++;
cnt++;
}
}
n = cnt;
memset(dp, 0, sizeof(dp));
dp[1][a[1] - 1] = 1;
long long sum = a[1];
for (int i = 2; i <= n; i++) {
for (int j = 0; j < sum; j++)
for (int k = 1; k <= a[i]; k++)
for (int u = 0; u <= j && u <= k; u++)
dp[i][j - u + a[i] - 1 - (k - 1)] =
(dp[i][j - u + a[i] - k] +
(((dp[i - 1][j] * C[j][u]) % MOD * C[sum + 1 - j][k - u]) % MOD *
C[a[i] - 1][k - 1]) %
MOD) %
MOD;
sum += a[i];
}
long long ans = dp[n][0];
for (int i = 1; i <= n; i++) ans = (ans * A[a[i]]) % MOD;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long jc[500], inv[500];
long long fpow(long long di, long long top) {
long long ret = 1;
while (top) {
if (top % 2) ret = ret * di % mod;
di = di * di % mod, top /= 2;
}
return ret;
}
void init() {
jc[0] = inv[0] = 1;
for (long long i = 1; i <= 400; ++i) jc[i] = jc[i - 1] * i % mod;
inv[400] = fpow(jc[400], mod - 2);
for (long long i = 399; i >= 1; --i) inv[i] = inv[i + 1] * (i + 1) % mod;
}
long long C(long long k, long long fro) {
long long ret = jc[fro] % mod * inv[fro - k] % mod;
return ret * inv[k] % mod;
}
vector<long long> sth[500];
bool vis[500];
long long siz[500], cnt, n, num[500];
long long dp[510][510];
bool iss(long long a) {
long long nw = sqrt(a);
return 1ll * nw * nw == a;
}
long long tot[500];
signed main() {
cin >> n;
init();
for (long long i = 1; i <= n; ++i) cin >> num[i];
for (long long i = 1; i <= n; ++i) {
if (!vis[i]) {
sth[++cnt].push_back(num[i]), vis[i] = 1;
for (long long j = 1; j <= n; ++j) {
if (!vis[j] && iss(1ll * num[j] * num[i])) {
sth[cnt].push_back(num[j]), vis[j] = 1;
}
}
}
}
for (long long i = 1; i <= cnt; ++i) siz[i] = sth[i].size();
dp[0][0] = 1;
long long tot = 0;
for (long long i = 1; i <= cnt; ++i) {
for (long long j = 0; j <= tot; ++j) {
dp[i - 1][j] %= mod;
if (dp[i - 1][j] == 0) continue;
for (long long k = 1; k <= min(siz[i], tot + 1); ++k) {
for (long long t = 0; t <= min(k, j); ++t) {
long long ndel = 1ll * dp[i - 1][j] * C(t, j) % mod;
ndel = ndel * C(k - 1, siz[i] - 1) % mod;
ndel = ndel * C(k - t, tot + 1 - j) % mod;
dp[i][j - t + siz[i] - k] += ndel % mod;
}
}
}
tot += siz[i];
}
long long ans = dp[cnt][0] % mod;
for (long long i = 1; i <= cnt; ++i) ans = ans * jc[siz[i]] % mod;
if (ans < 0) cout << dp[cnt][0];
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
struct Union_Find {
vector<int> data;
Union_Find(int size) : data(size, -1) {}
bool Union(int x, int y) {
x = Find(x);
y = Find(y);
bool is_union = (x != y);
if (is_union) {
if (data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
return is_union;
}
int Find(int x) {
if (data[x] < 0) {
return x;
} else {
data[x] = Find(data[x]);
return data[x];
}
}
bool same(int x, int y) { return Find(x) == Find(y); }
int size(int x) { return -data[Find(x)]; }
};
bool square(ll x) {
ll ok = 0, ng = 1000000001;
while (ng - ok > 1) {
ll mid = (ng + ok) / 2;
if (mid * mid <= x)
ok = mid;
else
ng = mid;
}
return ok * ok == x;
}
ll dp[305][305][305];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> a(n);
map<ll, ll> cnt;
for (int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
Union_Find uf(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (square(a[i] * a[j])) {
uf.Union(i, j);
}
}
}
map<ll, vector<ll> > memo;
for (int i = 0; i < n; i++) {
memo[uf.Find(i)].push_back(a[i]);
}
int used = 0;
dp[0][0][0] = 1;
for (auto p : memo) {
for (int i = 0; i < p.second.size(); i++) {
for (int k = 0; k <= i * 2; k++) {
for (int j = 0; j <= used - 2 * i + k + 1; j++) {
(dp[used + 1][j][k + 1] += dp[used][j][k] * (2 * i - k)) %= MOD;
if (j > 0) (dp[used + 1][j - 1][k] += dp[used][j][k] * j) %= MOD;
int rest = used - 2 * i + k - j + 1;
if (rest > 0) (dp[used + 1][j][k] += dp[used][j][k] * rest) %= MOD;
}
}
used++;
}
for (int j = 0; j <= 300; j++) {
for (int k = 1; k <= 300; k++) {
(dp[used][j + k][0] += dp[used][j][k]) %= MOD;
dp[used][j][k] = 0;
}
}
}
cout << dp[n][0][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void amax(X& x, const Y& y) {
if (x < y) x = y;
}
template <class X, class Y>
void amin(X& x, const Y& y) {
if (x > y) x = y;
}
const int INF = 1e9 + 10;
const long long INFL = 1e18 + 10;
const int MAX = 310;
const int BASE = 1e9 + 7;
int n, ng;
int a[MAX], g[MAX], cg[MAX], fact[MAX];
int f[MAX][MAX], c[MAX][MAX];
long long mul(long long a, long long b) { return (a * b) % BASE; }
bool is_sqr(long long x) {
long long sx = (long long)sqrt(x);
for (int i = -2; i <= 2; i++)
if (sx + i > 0 && ((sx + i) * (sx + i)) == x) return true;
return false;
}
void process() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++)
if (g[i] == 0) {
g[i] = ++ng;
cg[ng] = 1;
for (int j = i + 1; j <= n; j++)
if (is_sqr((long long)a[i] * a[j])) {
g[j] = ng;
cg[ng]++;
}
}
for (int i = 0; i <= n; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % BASE;
}
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = mul(fact[i - 1], i);
memset(f, 255, sizeof(f));
f[0][0] = 1;
int total = 0;
for (int i = 0; i < ng; i++) {
total += cg[i];
for (int j = 0; j < n; j++)
if (f[i][j] != -1) {
for (int k = 1; k <= min(total + 1, cg[i + 1]); k++)
for (int l = 0; l <= min(j, k); l++) {
int newj = j - l + cg[i + 1] - k;
if (f[i + 1][newj] == -1) f[i + 1][newj] = 0;
long long T = mul(mul(mul(c[cg[i + 1] - 1][k - 1], c[j][l]),
c[total + 1 - j][k - l]),
fact[cg[i + 1]]);
f[i + 1][newj] = (T * f[i][j] + f[i + 1][newj]) % BASE;
}
}
}
if (f[ng][0] == -1) f[ng][0] = 0;
cout << f[ng][0];
}
int main() {
ios_base::sync_with_stdio(false);
process();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 310, mod = 1e9 + 7;
int N, M, i, j, k, l, arr[MN], sm[MN], a[MN], dp[MN][MN], fac[2 * MN],
inv[2 * MN];
map<int, int> mp;
int qpow(int b, int exp) {
if (exp <= 0)
return 1;
else if (exp & 1)
return 1LL * b * qpow(b, exp - 1) % mod;
else {
int r = qpow(b, exp >> 1);
return 1LL * r * r % mod;
}
}
inline int C(int n, int k) {
if (k > n)
return 0;
else
return 1LL * fac[n] * inv[k] % mod * inv[n - k] % mod;
}
int main() {
scanf("%d", &N);
for (i = 1; i <= N; i++) {
scanf("%d", &arr[i]);
int rem = arr[i];
for (j = 2; j * j <= arr[i]; j++) {
while (rem % (j * j) == 0) {
rem /= (j * j);
}
}
mp[rem]++;
}
for (auto v : mp) a[++M] = v.second;
fac[0] = inv[0] = 1;
for (i = 1; i <= 2 * N; i++) {
fac[i] = 1LL * i * fac[i - 1] % mod;
inv[i] = qpow(fac[i], mod - 2);
}
dp[0][0] = 1;
for (i = 1; i <= M; i++) {
sm[i] = sm[i - 1] + a[i];
for (j = 1; j <= a[i]; j++) {
int ways = 1LL * C(a[i] - 1, j - 1) * fac[a[i]] % mod;
int delta = a[i] - j;
for (k = 0; k <= sm[i - 1] + 1; k++) {
if (!dp[i - 1][k]) continue;
for (l = 0; l <= min(j, k); l++) {
int ww = 1LL * C(k, l) * C(sm[i - 1] + 1 - k, j - l) % mod;
dp[i][k - l + delta] = (1LL * dp[i][k - l + delta] +
1LL * dp[i - 1][k] * ways % mod * ww) %
mod;
}
}
}
}
printf("%d\n", dp[M][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long base, long long p, long long mod = (1000000007LL)) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long n;
long long a[310], c[310], csum[310], dp[310][310], comb[505][505], na[310],
fact[310], ifact[310], ways[310], old[310];
long long isPrime[100005];
vector<long long> primes;
pair<long long, long long> all[310];
long long modular_inverse(long long n, long long mod) {
return pwr(n, mod - 2);
}
void cal() {
for (long long i = 2; i < 100005; i++) isPrime[i] = 1;
for (long long i = 2; i < 100005; i++) {
if (isPrime[i]) {
for (long long j = 2 * i; j < 100005; j += i) isPrime[j] = 0;
primes.push_back(i);
}
}
comb[0][0] = 1;
for (long long i = 1; i < 505; i++) {
comb[i][0] = 1;
for (long long j = 1; j <= i; j++)
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % (1000000007LL);
}
fact[0] = 1;
for (long long i = 1; i < 305; i++)
fact[i] = (fact[i - 1] * i) % (1000000007LL);
ifact[0] = 1;
for (long long i = 1; i < 305; i++)
ifact[i] =
(ifact[i - 1] * modular_inverse(i, (1000000007LL))) % (1000000007LL);
}
int main() {
scanf("%lld", &n);
for (long long i = 0; i < n; i++) scanf("%lld", &a[i]);
cal();
for (long long i = 0; i < n; i++) {
na[i] = 1;
old[i] = a[i];
for (long long j = 0; j < primes.size(); j++) {
long long cnt = 0;
while (a[i] % primes[j] == 0) {
a[i] = a[i] / primes[j];
cnt++;
}
if (cnt % 2 != 0) na[i] = na[i] * primes[j];
}
na[i] = na[i] * a[i];
}
for (long long i = 0; i < n; i++) {
all[i].first = na[i];
all[i].second = old[i];
}
sort(all, all + n);
long long gp = 1;
long long cnt = 1;
long long prev = -1;
for (long long i = 1; i < n; i++) {
if (all[i].first != all[i - 1].first) {
ways[gp] = fact[i - prev - 1];
c[gp] = i - prev - 1;
gp++;
prev = i - 1;
}
}
ways[gp] = fact[n - prev - 1];
c[gp] = n - prev - 1;
gp++;
prev = n;
csum[0] = c[0];
for (long long i = 1; i < gp; i++) csum[i] = csum[i - 1] + c[i];
dp[0][0] = 1;
ways[0] = 1;
for (long long i = 1; i < gp; i++) {
for (long long usedgaps = 1; usedgaps <= min(csum[i - 1] + 1, c[i]);
usedgaps++) {
for (long long prevbadgaps = 0; prevbadgaps <= csum[i - 1] + 1;
prevbadgaps++) {
if (dp[i - 1][prevbadgaps] > 0) {
for (long long badgaps = 0; badgaps <= min(usedgaps, prevbadgaps);
badgaps++) {
long long goodgaps = usedgaps - badgaps;
long long prevgoodgaps = csum[i - 1] + 1 - prevbadgaps;
dp[i][c[i] - usedgaps + prevbadgaps - badgaps] =
(dp[i][c[i] - usedgaps + prevbadgaps - badgaps] +
((((dp[i - 1][prevbadgaps] * comb[prevbadgaps][badgaps]) %
(1000000007LL) * comb[prevgoodgaps][goodgaps]) %
(1000000007LL) * comb[c[i] - 1][usedgaps - 1]) %
(1000000007LL)) *
ways[i]) %
(1000000007LL);
}
}
}
}
}
printf("%lld\n", dp[gp - 1][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = (1e9) + 7;
const int maxN = 310;
long long f[maxN];
long long c[maxN][maxN];
long long dp[maxN][maxN];
map<int, int> mp;
vector<int> cnt;
void add(long long &a, long long b) { a = (a + b) % mod; }
int main() {
int n, i, j;
scanf("%d", &n);
for (i = 0; i <= n; i++) {
c[i][0] = c[i][i] = 1;
for (j = 1; j < i; j++) c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
for (f[0] = i = 1; i <= n; i++) f[i] = (i * f[i - 1]) % mod;
for (i = 0; i < n; i++) {
int a;
scanf("%d", &a);
for (j = 2; j * j <= a; j++)
while (a % (j * j) == 0) a /= (j * j);
mp[a]++;
}
for (auto &it : mp) cnt.push_back(it.second);
int xy, x, y;
int m = cnt.size();
int place = cnt[0] + 1;
dp[0][cnt[0] - 1] = 1;
for (i = 1; i < m; place += cnt[i++]) {
for (j = 0; j < place - 1; j++) {
if (dp[i - 1][j] == 0) continue;
for (xy = 1; xy <= cnt[i]; xy++) {
for (x = 0; x <= min(j, xy); x++) {
y = xy - x;
add(dp[i][j - x + cnt[i] - xy], dp[i - 1][j] * c[j][x] % mod *
c[place - j][y] % mod *
c[cnt[i] - 1][xy - 1] % mod);
}
}
}
}
long long ans = dp[m - 1][0];
for (i = 0; i < m; i++) ans = (ans * f[cnt[i]]) % mod;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
long long c[300 + 1][300 + 1];
long long C(int x, int y) {
if (x >= y)
return c[x][y];
else
return 0;
}
int main() {
int n, a[300];
long long dp[2][300], fact[300 + 1];
scanf("%d", &n);
fact[0] = 1;
for (int i = 1; i <= n; ++i) fact[i] = (fact[i - 1] * (long long)i) % M;
c[0][0] = 1;
for (int i = 0; i < n; ++i) {
c[i + 1][0] = 1;
c[i + 1][i + 1] = 1;
for (int j = 1; j <= i; ++j) c[i + 1][j] = (c[i][j - 1] + c[i][j]) % M;
}
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
vector<int> v;
bool f[300];
fill(f, f + n, false);
for (int i = 0; i < n; ++i)
if (!f[i]) {
f[i] = true;
v.push_back(1);
for (int j = i + 1; j < n; ++j)
if (((long long)sqrt((long long)a[i] * (long long)a[j])) *
((long long)sqrt((long long)a[i] * (long long)a[j])) ==
(long long)a[i] * (long long)a[j]) {
f[j] = true;
++*(v.rbegin());
}
}
int s = v[0];
for (int j = 0; j < s - 1; ++j) dp[0][j] = 0;
dp[0][s - 1] = fact[s];
for (int i = 0; i < v.size() - 1; ++i) {
fill(dp[(i + 1) % 2], dp[(i + 1) % 2] + (s + v[i + 1]), 0);
for (int j = 0; j < s - i; ++j) {
if (dp[i % 2][j] == 0) continue;
for (int g = 1; g <= min(v[i + 1], s + 1); ++g)
for (int d = 0; d <= min(j, g); ++d) {
dp[(i + 1) % 2][j - d + v[i + 1] - g] +=
((((((((dp[i % 2][j] * fact[v[i + 1]]) % M) * c[j][d]) % M) *
C(s + 1 - j, g - d)) %
M) *
c[v[i + 1] - 1][g - 1]) %
M);
dp[(i + 1) % 2][j - d + v[i + 1] - g] %= M;
}
}
s += v[i + 1];
}
cout << dp[(v.size() - 1) % 2][0] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 3e2 + 10;
const long long Mod = 1e9 + 7;
long long dp[MAXN][MAXN];
long long a[MAXN];
long long e[MAXN];
long long z[MAXN];
long long rev[MAXN];
long long fact[MAXN];
long long pw(long long x, long long n) {
if (n == 0) {
return 1;
}
long long w = pw(x, n / 2);
w *= w;
w %= Mod;
if (n & 1) {
w *= x;
w %= Mod;
}
return w;
}
long long c(long long n, long long k) {
if (k > n || k < 0 || n < 0) {
return 0;
}
return fact[n] * ((rev[k] * rev[n - k]) % Mod) % Mod;
}
bool issq(long long x) {
long long sq = sqrt(x);
for (long long i = sq; i < sq + 4; i++) {
if (i * i == x) {
return true;
}
}
for (long long i = sq; i > sq - 4; i--) {
if (i * i == x) {
return true;
}
}
return false;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
long long n, t = 1, total = 0;
cin >> n;
fact[0] = 1;
rev[0] = 1;
for (long long i = 1; i < MAXN; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= Mod;
rev[i] = pw(fact[i], Mod - 2);
}
for (long long i = 1; i <= n; i++) {
cin >> a[i];
bool flag = false;
for (long long j = 1; j < i; j++) {
if (issq(a[i] * a[j])) {
e[z[j]]++;
flag = true;
break;
}
}
if (!flag) {
z[i] = t;
e[t]++;
t++;
}
}
dp[0][0] = 1;
for (long long i = 1; i < t; i++) {
for (long long j = 0; j <= total + e[i]; j++) {
for (long long u = 0; u <= total; u++) {
for (long long w = 0; w <= min(e[i], u); w++) {
long long s = dp[i - 1][u];
s *= c(u, w);
s %= Mod;
s *= c(total - u + 1, u + e[i] - 2 * w - j);
s %= Mod;
s *= c(e[i] - 1, u + e[i] - w - j - 1);
s %= Mod;
s *= fact[e[i]];
s %= Mod;
dp[i][j] += s;
dp[i][j] %= Mod;
}
}
}
total += e[i];
}
cout << dp[t - 1][0];
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 310;
const int mod = 1e9 + 7;
int factor[MAXN];
int inv[MAXN];
int n;
int power(int base, int n) {
int ret = 1;
int cur = base;
while (n) {
if (n & 1) ret = 1LL * ret * cur % mod;
cur = 1LL * cur * cur % mod;
n >>= 1;
}
return ret;
}
void init() {
factor[0] = 1;
for (int i = 1; i <= n; i++) {
factor[i] = 1LL * factor[i - 1] * i % mod;
}
for (int i = 0; i <= n; i++) {
inv[i] = power(factor[i], mod - 2);
}
}
int combine(int n, int k) {
if (n == 0 || k == 0) return 1;
int ret = 1LL * factor[n] * inv[k] % mod;
ret = 1LL * ret * inv[n - k] % mod;
return ret;
}
long long solve(vector<int>& group) {
init();
vector<long long> dp(group[0], 0);
dp[group[0] - 1] = 1;
for (int i = 1; i < group.size(); i++) {
vector<long long> cur(dp.size() + group[i], 0);
for (int j = 0; j < dp.size(); j++) {
if (dp[j] == 0) continue;
for (int k = 1; k <= min(group[i], (int)dp.size() + 1); k++) {
for (int t = 0; t <= min(j, k); t++) {
int not_bad = (int)dp.size() - j + 1;
if (not_bad < k - t) continue;
int state = j - t + (group[i] - k);
long long tmp = 1LL * combine(not_bad, k - t) * combine(j, t) % mod;
tmp = 1LL * tmp * combine(group[i] - 1, k - 1) % mod;
cur[state] = (cur[state] + tmp * dp[j]) % mod;
}
}
}
cur.swap(dp);
}
return dp[0];
}
int main() {
scanf("%d", &n);
map<int, int> table;
int tmp;
for (int i = 1; i <= n; i++) {
scanf("%d", &tmp);
for (int i = 2; i * i <= tmp; i++) {
while (tmp % (i * i) == 0) {
tmp /= (i * i);
}
}
table[tmp]++;
}
vector<int> group;
for (auto& item : table) {
group.push_back(item.second);
}
long long ret = solve(group);
for (int num : group) {
ret = ret * factor[num] % mod;
}
cout << ret << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[305], n, cnt, k[305], num;
long long f[305][305];
long long C[305][305];
long long stp[305];
bool vis[305];
int main() {
for (int i = 0; i <= 300; i++) C[i][0] = 1, C[i][i] = 1;
for (int i = 2; i <= 300; i++)
for (int j = 1; j < i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 1000000007;
stp[0] = 1;
for (int i = 1; i <= 300; i++) stp[i] = stp[i - 1] * i % 1000000007;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (vis[i] == 1) continue;
k[++cnt]++;
for (int j = i + 1; j <= n; j++) {
long long p = sqrt(a[i] * a[j]);
if (p * p == a[i] * a[j]) vis[j] = 1, k[cnt]++;
}
}
f[0][0] = 1;
for (int i = 0; i < cnt; i++) {
num += k[i];
for (int j = 0; j <= n; j++)
if (f[i][j] != 0) {
for (int p = 1; p <= k[i + 1]; p++)
for (int q = 0; q <= min(p, j); q++)
f[i + 1][j - q + k[i + 1] - p] =
(f[i + 1][j - q + k[i + 1] - p] +
f[i][j] * stp[k[i + 1]] % 1000000007 * C[k[i + 1] - 1][p - 1] %
1000000007 * C[j][q] % 1000000007 *
C[num + 1 - j][p - q]) %
1000000007;
}
}
cout << f[cnt][0] % 1000000007;
}
|
#include <bits/stdc++.h>
using namespace std;
int num[305];
int cnt[305], len = 0;
long long dp[305][305], a[305], c[305][305];
int main() {
int n, x, y;
scanf("%d", &n);
a[0] = 1;
c[0][0] = 1;
for (int i = 0; i < n; i++) {
c[i + 1][0] = 1;
for (int j = 1; j <= i + 1; j++)
c[i + 1][j] = (c[i][j - 1] + c[i][j]) % 1000000007;
a[i + 1] = (a[i] * (i + 1)) % 1000000007;
scanf("%d", &x);
num[i] = 1;
for (int j = 2; j * j <= x; j++) {
y = 0;
while (x % j == 0) {
x /= j;
y++;
}
if (y % 2) num[i] *= j;
}
if (x > 1) num[i] *= x;
}
sort(num, num + n);
x = 1;
for (int i = 1; i < n; i++) {
if (num[i] != num[i - 1]) {
cnt[len++] = x;
x = 1;
} else
x++;
}
cnt[len++] = x;
dp[0][cnt[0] - 1] = 1;
x = cnt[0];
for (int i = 1; i < len; i++) {
for (int j = 0; j <= n; j++) {
if (dp[i - 1][j]) {
for (int k = 1; k <= cnt[i]; k++)
for (int l = 0; l <= k && l <= j; l++)
dp[i][j - l + cnt[i] - k] =
(dp[i][j - l + cnt[i] - k] +
(((((dp[i - 1][j] * c[cnt[i] - 1][k - 1]) % 1000000007) *
c[j][l]) %
1000000007) *
c[x + 1 - j][k - l]) %
1000000007) %
1000000007;
}
}
x += cnt[i];
}
for (int i = 0; i < len; i++)
dp[len - 1][0] = (dp[len - 1][0] * a[cnt[i]]) % 1000000007;
printf("%lld\n", dp[len - 1][0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double pi = acos(-1.0);
const int maxn = 100000 + 10;
const int mod = 1e9 + 7;
long long dp[500][500];
long long C[500][500];
long long fact[500];
int cnt[500];
int a[500];
int vis[500];
int sz;
int check(long long x) {
long long l = 1, r = 1e9;
long long now = l;
while (l <= r) {
long long mid = (l + r) >> 1;
if (mid * mid <= x)
now = mid, l = mid + 1;
else
r = mid - 1;
}
return now * now == x;
}
inline long long M(long long x) { return x % mod; }
void init() {
C[0][0] = 1;
fact[0] = 1;
for (int i = 1; i <= 300; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = M(C[i - 1][j] + C[i - 1][j - 1]);
}
}
for (int i = 1; i <= 300; i++) fact[i] = M(fact[i - 1] * i);
}
void slove() {
dp[0][cnt[0] - 1] = 1;
int lim = cnt[0];
for (int i = 1; i < sz; i++) {
for (int j = 0; j < lim; j++) {
for (int k = 0; k < cnt[i]; k++) {
for (int m = 0; m <= min(j, k + 1); m++) {
dp[i][j + cnt[i] - 1 - k - m] =
M(dp[i][j + cnt[i] - 1 - k - m] +
dp[i - 1][j] * C[cnt[i] - 1][k] % mod * C[j][m] % mod *
C[lim - 1 - j + 2][k + 1 - m]);
}
}
}
lim += cnt[i];
}
long long ans = dp[sz - 1][0];
for (int i = 0; i < sz; i++) {
ans *= fact[cnt[i]];
ans %= mod;
}
cout << ans << endl;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < n; i++) {
if (vis[i] == 0) {
for (int j = i; j < n; j++) {
if (check(1LL * a[i] * a[j])) {
cnt[sz]++;
vis[j] = 1;
}
}
sz++;
}
}
init();
slove();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 0.000000000000001;
int n, A[310];
int corr(int &x) {
int i, y = 1;
for (i = 2; i * i <= x; i++) {
if (x % i == 0) {
int c = 0;
while (x % i == 0) {
c ^= 1;
x /= i;
}
if (c > 0) {
y *= i;
}
}
}
if (x > 1) {
y *= x;
}
return x = y;
}
int p = -1;
int siz[310], fac[310], tot[310];
long long dp[310][310], ncr[410][410];
void prencr() {
int i, j;
for (i = 0; i <= 400; i++) {
for (j = 0; j <= i; j++) {
if (j == 0)
ncr[i][j] = 1;
else if (i == j)
ncr[i][j] = 1;
else
ncr[i][j] = (ncr[i - 1][j - 1] + ncr[i - 1][j]) % 1000000007;
}
}
}
int main() {
prencr();
scanf("%d", &n);
int i, j;
for (i = 0; i < n; i++) {
scanf("%d", &A[i]);
corr(A[i]);
}
sort(A, A + n);
fac[0] = 1;
int lst = -1;
for (i = 0; i < n; i++) {
if (A[i] == lst) {
siz[p]++;
} else {
lst = A[i];
p++;
siz[p] = 1;
}
fac[i + 1] = (1LL * (i + 1) * fac[i]) % 1000000007;
}
p++;
tot[0] = siz[0];
for (i = 1; i < p; i++) {
tot[i] = siz[i] + tot[i - 1];
}
dp[0][siz[0] - 1] = 1;
for (i = 1; i < p; i++) {
for (j = 0; j < n; j++) {
if (dp[i - 1][j] == 0) {
continue;
}
int k, placed = tot[i - 1], limp = min(siz[i], placed + 1);
for (int slots = 1; slots <= limp; slots++) {
for (int rejc = 0; rejc <= min(j, slots); rejc++) {
dp[i][j + siz[i] - slots - rejc] +=
(((((1LL * dp[i - 1][j] * ncr[siz[i] - 1][slots - 1]) %
1000000007) *
ncr[j][rejc]) %
1000000007) *
ncr[placed + 1 - j][slots - rejc]) %
1000000007;
dp[i][j + siz[i] - slots - rejc] %= 1000000007;
}
}
}
}
long long ans = dp[p - 1][0];
for (i = 0; i < p; i++) {
ans = (ans * fac[siz[i]]) % 1000000007;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int cnt, n, vis[305], a[305], C[305][305], sum[305];
map<int, int> m;
vector<int> v[305];
int num[305], top;
long long jie[305], ans, f[305][305];
void pre() {
jie[0] = 1;
for (int i = 1; i <= 300; i++) jie[i] = jie[i - 1] * i % mod;
C[0][0] = 1;
for (int i = 1; i <= 300; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
}
bool check(long long a) {
long long temp = (long long)sqrt(a);
return temp * temp == a;
}
void dfs(int a) {
cnt++;
vis[a] = 1;
for (auto to : v[a]) {
if (vis[to] == 0) dfs(to);
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
pre();
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (check((long long)a[i] * a[j])) v[i].push_back(j);
}
}
for (int i = 1; i <= n; i++) {
cnt = 0;
if (vis[i] == 0) {
dfs(i);
num[++top] = cnt;
}
}
for (int i = 1; i <= top; i++) {
sum[i] = sum[i - 1] + num[i];
}
f[0][0] = 1;
for (int i = 1; i <= top; i++) {
for (int j = 0; j <= 1 + sum[i - 1]; j++) {
for (int k = 1; k <= num[i]; k++) {
for (int p = 0; p <= min(k, j); p++) {
f[i][j + num[i] - k - p] =
(f[i][j + num[i] - k - p] +
f[i - 1][j] * C[j][p] % mod * C[num[i] - 1][k - 1] % mod *
C[1 + sum[i - 1] - j][k - p] % mod) %
mod;
}
}
}
}
ans = f[top][0];
for (int i = 1; i <= top; i++) {
ans = ans * jie[num[i]] % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)307;
const int infint = (long long)1e9;
const long long inf = (long long)1e18;
long long n, a[MAXN], type[MAXN], sm[MAXN], C[MAXN][MAXN], dp[MAXN][MAXN],
fact[MAXN];
unordered_map<int, int> M, hsh;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 4 * 10000; j >= 2; j--)
if (a[i] % (j * j) == 0) a[i] /= j * j;
M[a[i]]++;
}
int t = 0;
for (auto u : M) hsh[u.first] = t++;
for (int i = 0; i < n; i++) a[i] = hsh[a[i]];
for (int i = 0; i < n; i++) type[a[i]]++;
for (int i = 0; i < t; i++) {
sm[i] = type[i];
if (i != 0) sm[i] += sm[i - 1];
}
fact[0] = 1;
for (int i = 1; i < MAXN; i++) fact[i] = fact[i - 1] * i % MOD;
C[0][0] = 1;
for (int i = 1; i < MAXN; i++)
for (int j = 0; j <= i; j++)
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
dp[0][type[0] - 1] = 1;
for (int i = 0; i < t - 1; i++)
for (int j = 0; j < sm[i]; j++)
for (int p = 1; p <= min(sm[i] + 1, type[i + 1]); p++)
for (int k = 0; k <= min(p, j); k++) {
int nw = j + (type[i + 1] - p) - k;
dp[i + 1][nw] += C[j][k] * C[sm[i] + 1 - j][p - k] % MOD *
C[type[i + 1] - 1][p - 1] % MOD * dp[i][j] % MOD,
dp[i + 1][nw] %= MOD;
}
long long ans = dp[t - 1][0];
for (int i = 0; i < t; i++) ans = ans * fact[type[i]] % MOD;
cout << ans;
}
|
#include <bits/stdc++.h>
const long long int MODULO = 1000000007;
int main() {
int n;
std::cin >> n;
std::vector<long long int> a(n);
for (int i = 0; i < n; ++i) {
std::cin >> a[i];
}
std::vector<bool> is_used(n, false);
std::vector<int> same_class_sizes;
for (int i = 0; i < n; ++i) {
if (!is_used[i]) {
int class_size = 1;
for (int j = i + 1; j < n; ++j) {
if (a[i] * a[j] == static_cast<long long int>(sqrt(a[i] * a[j])) *
static_cast<long long int>(sqrt(a[i] * a[j]))) {
++class_size;
is_used[j] = true;
}
}
same_class_sizes.push_back(class_size);
}
}
std::vector<std::vector<int>> binom(n + 2);
for (int i = 0; i < n + 2; ++i) {
binom[i].resize(n + 2, 0);
binom[i][0] = (i == 0 ? 1 : 0);
}
for (int i = 1; i < n + 2; ++i) {
for (int j = 0; j < n + 2; ++j) {
if (j >= 1) {
binom[j][i] = binom[j][i - 1] + binom[j - 1][i - 1];
} else {
binom[j][i] = binom[j][i - 1];
}
binom[j][i] %= MODULO;
}
}
std::vector<int> prev_perm_counts(1, 1);
std::vector<int> perm_counts;
int total_numbers_count = 0;
int prev_total_numbers_count = 0;
for (size_t i = 0; i < same_class_sizes.size(); ++i) {
total_numbers_count += same_class_sizes[i];
perm_counts.resize(total_numbers_count + 1, 0);
for (int errors_count = 0; errors_count < total_numbers_count;
++errors_count) {
for (int dropped_errors = 0; dropped_errors < same_class_sizes[i] + 1;
++dropped_errors) {
for (int rest_places = 0;
rest_places < std::min(prev_total_numbers_count + 2,
same_class_sizes[i] - dropped_errors + 1);
++rest_places) {
int new_errors = same_class_sizes[i] - dropped_errors - rest_places;
int old_errors_count = errors_count + dropped_errors - new_errors;
if (old_errors_count >= 0 &&
old_errors_count < prev_total_numbers_count + 1 &&
new_errors >= 0 && new_errors < total_numbers_count + 1 &&
dropped_errors + rest_places >= 1) {
long long int addon = prev_perm_counts[old_errors_count];
addon *= binom[dropped_errors][old_errors_count];
addon %= MODULO;
addon *= binom[rest_places]
[prev_total_numbers_count + 1 - old_errors_count];
addon %= MODULO;
addon *= binom[dropped_errors + rest_places - 1]
[same_class_sizes[i] - 1];
addon %= MODULO;
perm_counts[errors_count] += addon;
perm_counts[errors_count] %= MODULO;
}
}
}
}
prev_total_numbers_count = total_numbers_count;
prev_perm_counts = std::move(perm_counts);
}
std::vector<long long int> factorial(n + 1);
factorial[0] = 1;
for (int i = 1; i < n + 1; ++i) {
factorial[i] = i * factorial[i - 1];
factorial[i] %= MODULO;
}
long long int result;
if (prev_perm_counts.size() == 0) {
result = 1;
} else {
result = prev_perm_counts[0];
}
for (auto& size : same_class_sizes) {
result *= factorial[size];
result %= MODULO;
}
std::cout << result << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 310, MOD = 1000000007;
long long num[N], c[N][N];
long long dp[N][N], a[N];
int tmp, n, tot, example[N];
bool key;
bool ask(int x, int y) {
long long re = 1;
re *= x;
re *= y;
long long f = sqrt(re);
if (f * f == re) return 1;
return 0;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> tmp;
key = 1;
for (int j = 1; j <= tot; j++) {
if (ask(tmp, example[j])) {
num[j]++;
key = 0;
break;
}
}
if (key) {
num[++tot] = 1;
example[tot] = tmp;
}
}
for (int i = 0; i <= n; i++) c[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
c[i][j] %= MOD;
}
int m = 0;
a[1] = 1;
for (int i = 2; i <= n; i++) {
a[i] = a[i - 1] * i;
a[i] %= MOD;
}
dp[0][0] = 1;
long long temp, temp1;
for (int i = 1; i <= tot; i++) {
for (int j = 0; j < n && j <= m + 1; j++) {
if (dp[i - 1][j] == 0) continue;
for (int k = 0; k < num[i]; k++) {
temp = dp[i - 1][j] * c[num[i] - 1][k];
temp %= MOD;
for (int p = 0; p <= k + 1 && p <= j + num[i] - 1 - k; p++) {
temp1 = temp * c[j][p];
temp1 %= MOD;
dp[i][j + num[i] - 1 - k - p] +=
(temp1 * c[m + 1 - j][k + 1 - p]) % MOD;
dp[i][j + num[i] - 1 - k - p] %= MOD;
}
}
}
m += num[i];
}
for (int i = 1; i <= tot; i++) {
dp[tot][0] *= a[num[i]];
dp[tot][0] %= MOD;
}
cout << dp[tot][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[300];
bool isMain[300];
int available[300];
int numClasses;
vector<int> classes;
long long dp[300 + 1][300];
long long C[300 + 1][300 + 1];
long long fact[300 + 1];
bool solvedC[300 + 1][300 + 1];
bool solvedF[300 + 1];
long long choose(int i, int j) {
if (i < 0 || j < 0 || j > i) return 0;
if (solvedC[i][j]) return C[i][j];
if (solvedC[i][i - j]) {
C[i][j] = C[i][i - j];
} else if (i == 0) {
C[i][j] = 1;
} else {
C[i][j] = (choose(i - 1, j) + choose(i - 1, j - 1)) % 1000000007;
}
solvedC[i][j] = true;
return C[i][j];
}
long long factorial(int i) {
if (solvedF[i]) return fact[i];
if (i == 0)
fact[i] = 1;
else
fact[i] = (i * factorial(i - 1)) % 1000000007;
solvedF[i] = true;
return fact[i];
}
bool isSquare(long long s) {
long long sq = (long long)round(sqrt(s));
return (sq) * (sq) == s;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < (n); i++) {
cin >> a[i];
isMain[i] = true;
available[i] = 1;
for (int j = 0; j < (i); j++) {
if (isSquare(a[j] * a[i])) {
isMain[i] = false;
available[j]++;
break;
}
}
}
for (int i = 0; i < (n); i++) {
if (isMain[i]) {
numClasses++;
classes.push_back(available[i]);
}
}
int numSoFar = classes[0];
dp[0][classes[0] - 1] = factorial(classes[0]);
for (int i = (1); i < (numClasses); i++) {
int nextSoFar = numSoFar + classes[i];
for (int j = 0; j < (nextSoFar); j++) {
for (int k = 0; k < (numSoFar); k++) {
for (int numKeep = 0; numKeep < (min(j + 1, k + 1)); numKeep++) {
int numSpent = k - numKeep;
int stillHave = classes[i] - numSpent;
int numNew = j - numKeep;
if (numNew > stillHave) continue;
int canFill = numSoFar + 1 - k;
dp[i][j] += ((((((dp[i - 1][k] * choose(k, numSpent)) % 1000000007) *
choose(canFill, stillHave - numNew)) %
1000000007) *
choose(classes[i] - 1, classes[i] - numNew - 1)) %
1000000007 * factorial(classes[i])) %
1000000007;
dp[i][j] %= 1000000007;
}
}
}
numSoFar = nextSoFar;
}
cout << dp[numClasses - 1][0] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[305];
long long dp[305][305], ncr[305][305], fact[305];
map<int, int> m;
long long nCr(int n, int r) {
if (r == n || r == 0) return 1;
if (r == 1) return n;
if (ncr[n][r] != -1) return ncr[n][r];
return (ncr[n][r] = (nCr(n - 1, r) + nCr(n - 1, r - 1)) % 1000000007);
}
int num(int n) {
while (n % 4 == 0) n /= 4;
for (int i = 3; i * i <= n; i += 2) {
while (n % (i * i) == 0) n /= (i * i);
}
return n;
}
long long solve(int n) {
if (n == 1 && a[0] == 1) return 1;
if (n == 1) return 0;
int i, j, k, sum = 0, t;
long long temp;
memset(ncr, -1, sizeof(ncr));
dp[0][a[0] - 1] = 1;
sum = a[0] + 1;
for (i = 1; i < n; i++) {
for (j = 0; j < sum; j++) {
if (dp[i - 1][j] == 0) continue;
for (k = 1; k <= a[i]; k++) {
for (t = max(0, k - sum + j); t <= min(j, k); t++) {
temp = (dp[i - 1][j] * nCr(sum - j, k - t)) % 1000000007;
temp = (temp * nCr(j, t)) % 1000000007;
temp = (temp * nCr(a[i] - 1, k - 1)) % 1000000007;
dp[i][j - t + a[i] - k] =
(dp[i][j - t + a[i] - k] + temp) % 1000000007;
}
}
}
sum += a[i];
}
return dp[n - 1][0];
}
int main() {
int n, i, j, k, sz;
scanf("%d", &n);
sz = 0;
for (i = 0; i < n; i++) {
scanf("%d", &j);
k = num(j);
if (m.find(k) == m.end()) m[k] = sz++;
a[m[k]]++;
}
sort(a, a + sz, greater<int>());
long long ans = solve(sz);
fact[0] = 1;
for (i = 1; i <= n; i++) fact[i] = (fact[i - 1] * i) % 1000000007;
for (i = 0; i < sz; i++) {
ans = (ans * fact[a[i]]) % 1000000007;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const long long maxn = 320;
const long long mod = 1e9 + 7;
long long dp[maxn][maxn];
long long fuc[maxn];
long long qqq[maxn][maxn][maxn];
long long a[maxn];
long long b[maxn];
long long d[maxn];
bool morab(long long a) {
long long b = sqrt(a) - 7;
for (long long i = 0; i < 14; i++) {
if (b * b == a) {
return 1;
}
b++;
}
return 0;
}
int main() {
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
fuc[0] = 1;
for (long long i = 1; i < maxn; i++) {
fuc[i] = (fuc[i - 1] * i) % mod;
}
long long k = 1;
b[0] = 0;
d[0] = 1;
for (long long i = 1; i < n; i++) {
bool p = 1;
for (long long j = 0; j < i; j++) {
if (morab(a[i] * a[j])) {
b[i] = b[j];
d[b[i]]++;
p = 0;
break;
}
}
if (p) {
b[i] = k;
d[k]++;
k++;
}
}
long long ans = 1;
for (long long i = 0; i < k; i++) {
b[i] = d[i];
}
for (long long i = 0; i < k; i++) {
ans *= fuc[b[i]];
ans %= mod;
}
sort(b, b + k);
{
qqq[0][0][0] = 1;
for (long long u = 1; u < maxn; u++) {
qqq[u][0][u] = 1;
}
for (long long c = 1; c < 2 * maxn; c++) {
for (long long a = 1; a < c && a < maxn; a++) {
long long b = c - a;
if (b < maxn && b > 0) {
for (long long u = 1; u < maxn; u++) {
qqq[a][b][u] = (qqq[b][a - 1][u - 1] + qqq[a - 1][b][u - 1] +
qqq[b][a - 1][u]) %
mod;
}
}
}
}
}
dp[0][b[0]] = 2;
dp[0][b[0] + 1] = 1;
dp[0][b[0] - 1] = 1;
for (long long i = 1; i < k; i++) {
for (long long j = 0; j < maxn; j++) {
for (long long u = b[i] + j; u >= 1; u--) {
dp[i][j] += ((qqq[j][b[i]][u] + qqq[b[i]][j][u]) * dp[i - 1][u]) % mod;
dp[i][j] %= mod;
}
}
}
cout << (dp[k - 1][0] * ans) % mod;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXLEN = 100000;
const int MAXN = 100000;
const int MAXQ = 100000;
const int MAXTN = MAXLEN + 1;
const int MAXLG = 16;
const int MAXSN = 4 * (MAXN - 1);
const int MAXZN = 4 * MAXN;
typedef struct TN {
int d;
int nxt[26];
int par[MAXLG + 1];
} TN;
typedef struct SN {
int best;
vector<int> preidx, sufidx;
} SN;
int n, nq;
char s[MAXLEN + 1];
TN tn[MAXTN];
int ntn, troot;
int tpos[MAXN];
int qkind[MAXQ], ql[MAXQ], qr[MAXQ], qidx[MAXQ], qlen[MAXQ], qtpos[MAXQ];
int gettn(int par) {
int ret = ntn++;
tn[ret].d = par == -1 ? 0 : tn[par].d + 1;
for (int i = (0); i < (26); ++i) tn[ret].nxt[i] = -1;
tn[ret].par[0] = par == -1 ? ret : par;
for (int i = (1); i <= (MAXLG); ++i)
tn[ret].par[i] = tn[tn[ret].par[i - 1]].par[i - 1];
return ret;
}
int tinsert() {
int at = troot;
for (int i = 0; s[i] != '\0'; ++i) {
int x = s[i] - 'a';
if (tn[at].nxt[x] == -1) tn[at].nxt[x] = gettn(at);
at = tn[at].nxt[x];
}
return at;
}
int getlca(int a, int b) {
if (tn[a].d < tn[b].d) swap(a, b);
for (int k = MAXLG; k >= 0; --k)
if (tn[a].d - (1 << k) >= tn[b].d) a = tn[a].par[k];
for (int k = MAXLG; k >= 0; --k)
if (tn[a].par[k] != tn[b].par[k]) a = tn[a].par[k], b = tn[b].par[k];
return a == b ? a : tn[a].par[0];
}
int lcp[MAXN - 1];
SN sn[MAXSN];
void print(const SN &a) {
printf("[");
for (int i = (0); i < (((int)(a.preidx).size())); ++i) {
if (i != 0) printf(",");
printf("%d", a.preidx[i]);
}
printf("][");
for (int i = (0); i < (((int)(a.sufidx).size())); ++i) {
if (i != 0) printf(",");
printf("%d", a.sufidx[i]);
}
printf("]->%d", a.best);
}
int calc(int l, int r, int mn) { return (r - l + 2) * mn; }
SN makesn(int idx) {
SN ret;
ret.best = calc(idx, idx, lcp[idx]);
ret.preidx.push_back(idx);
ret.sufidx.push_back(idx);
return ret;
}
SN combine(const SN &a, const SN &b) {
SN ret;
ret.best = max(a.best, b.best);
int ai = ((int)(a.sufidx).size()) - 1, bi = ((int)(b.preidx).size()) - 1;
while (true) {
if (lcp[a.sufidx[ai]] >= lcp[b.preidx[bi]]) {
if (ai == 0) {
for (int i = (0); i <= (bi); ++i) ret.preidx.push_back(b.preidx[i]);
for (int i = (0); i < (((int)(a.preidx).size())); ++i)
if (lcp[a.preidx[i]] == lcp[ret.preidx.back()])
ret.preidx[((int)(ret.preidx).size()) - 1] = a.preidx[i];
else
ret.preidx.push_back(a.preidx[i]);
ret.sufidx = b.sufidx;
break;
} else {
int cur =
calc(a.sufidx[ai - 1] + 1, b.preidx[bi] - 1, lcp[a.sufidx[ai]]);
if (cur > ret.best) ret.best = cur;
--ai;
}
} else {
if (bi == 0) {
ret.preidx = a.preidx;
for (int i = (0); i <= (ai); ++i) ret.sufidx.push_back(a.sufidx[i]);
for (int i = (0); i < (((int)(b.sufidx).size())); ++i)
if (lcp[b.sufidx[i]] == lcp[ret.sufidx.back()])
ret.sufidx[((int)(ret.sufidx).size()) - 1] = b.sufidx[i];
else
ret.sufidx.push_back(b.sufidx[i]);
break;
} else {
int cur =
calc(a.sufidx[ai] + 1, b.preidx[bi - 1] - 1, lcp[b.preidx[bi]]);
if (cur > ret.best) ret.best = cur;
--bi;
}
}
}
int l = ret.preidx.back(), r = ret.sufidx.back();
ret.best = max(ret.best, calc(l, r, lcp[ret.preidx[0]]));
for (int i = (1); i < (((int)(ret.preidx).size())); ++i)
ret.best =
max(ret.best, calc(l, ret.preidx[i - 1] - 1, lcp[ret.preidx[i]]));
for (int i = (1); i < (((int)(ret.sufidx).size())); ++i)
ret.best =
max(ret.best, calc(ret.sufidx[i - 1] + 1, r, lcp[ret.sufidx[i]]));
return ret;
}
void sinit(int x, int l, int r) {
if (l == r) {
sn[x] = makesn(l);
} else {
int m = l + (r - l) / 2;
sinit(2 * x + 1, l, m);
sinit(2 * x + 2, m + 1, r);
sn[x] = combine(sn[2 * x + 1], sn[2 * x + 2]);
}
}
void sset(int x, int l, int r, int IDX) {
if (l == r) {
sn[x] = makesn(l);
} else {
int m = l + (r - l) / 2;
if (IDX <= m)
sset(2 * x + 1, l, m, IDX);
else
sset(2 * x + 2, m + 1, r, IDX);
sn[x] = combine(sn[2 * x + 1], sn[2 * x + 2]);
}
}
SN sget(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return sn[x];
int m = l + (r - l) / 2;
if (R <= m) return sget(2 * x + 1, l, m, L, R);
if (m + 1 <= L) return sget(2 * x + 2, m + 1, r, L, R);
return combine(sget(2 * x + 1, l, m, L, R), sget(2 * x + 2, m + 1, r, L, R));
}
int len[MAXN];
int zn[MAXZN];
void zinit(int x, int l, int r) {
if (l == r) {
zn[x] = len[l];
} else {
int m = l + (r - l) / 2;
zinit(2 * x + 1, l, m);
zinit(2 * x + 2, m + 1, r);
zn[x] = max(zn[2 * x + 1], zn[2 * x + 2]);
}
}
void zset(int x, int l, int r, int IDX) {
if (l == r) {
zn[x] = len[l];
} else {
int m = l + (r - l) / 2;
if (IDX <= m)
zset(2 * x + 1, l, m, IDX);
else
zset(2 * x + 2, m + 1, r, IDX);
zn[x] = max(zn[2 * x + 1], zn[2 * x + 2]);
}
}
int zget(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return zn[x];
int m = l + (r - l) / 2;
if (R <= m) return zget(2 * x + 1, l, m, L, R);
if (m + 1 <= L) return zget(2 * x + 2, m + 1, r, L, R);
return max(zget(2 * x + 1, l, m, L, R), zget(2 * x + 2, m + 1, r, L, R));
}
int ans[MAXQ];
void solve() {
for (int i = (0); i < (n - 1); ++i)
lcp[i] = tn[getlca(tpos[i], tpos[i + 1])].d;
if (n >= 2) sinit(0, 0, n - 2);
zinit(0, 0, n - 1);
for (int i = (0); i < (nq); ++i) {
if (qkind[i] == 1) {
ans[i] = zget(0, 0, n - 1, ql[i], qr[i]);
if (ql[i] != qr[i]) {
SN cur = sget(0, 0, n - 2, ql[i], qr[i] - 1);
if (cur.best > ans[i]) ans[i] = cur.best;
}
}
if (qkind[i] == 2) {
int idx = qidx[i];
tpos[idx] = qtpos[i];
len[idx] = qlen[i];
zset(0, 0, n - 1, idx);
if (idx >= 1) {
lcp[idx - 1] = tn[getlca(tpos[idx - 1], tpos[idx])].d;
sset(0, 0, n - 2, idx - 1);
}
if (idx + 1 < n) {
lcp[idx] = tn[getlca(tpos[idx], tpos[idx + 1])].d;
sset(0, 0, n - 2, idx);
}
}
}
}
void run() {
ntn = 0;
troot = gettn(-1);
scanf("%d%d", &n, &nq);
for (int i = (0); i < (n); ++i) {
scanf("%s", s);
len[i] = strlen(s), tpos[i] = tinsert();
}
for (int i = (0); i < (nq); ++i) {
scanf("%d", &qkind[i]);
if (qkind[i] == 1) {
scanf("%d%d", &ql[i], &qr[i]);
--ql[i], --qr[i];
}
if (qkind[i] == 2) {
scanf("%d%s", &qidx[i], s);
--qidx[i], qlen[i] = strlen(s), qtpos[i] = tinsert();
}
}
solve();
for (int i = (0); i < (nq); ++i)
if (qkind[i] == 1) printf("%d\n", ans[i]);
}
string ss[MAXN];
string os[MAXN];
string qs[MAXQ];
int chk[MAXQ];
int bflcp(const string &a, const string &b) {
int ret = 0;
while (ret < ((int)(a).size()) && ret < ((int)(b).size()) && a[ret] == b[ret])
++ret;
return ret;
}
int bf(int l, int r) {
int ret = 0;
vector<pair<int, int> > stck;
for (int i = (l); i <= (r); ++i) {
ret = max(ret, ((int)(ss[i]).size()));
if (i != l) {
int lcp = bflcp(ss[i - 1], ss[i]);
while (((int)(stck).size()) > 0 && lcp <= stck.back().first) {
int cur = calc(((int)(stck).size()) == 1
? l
: stck[((int)(stck).size()) - 2].second + 1,
i - 2, stck.back().first);
if (cur > ret) ret = cur;
stck.pop_back();
}
stck.push_back(make_pair(lcp, i - 1));
}
}
while (((int)(stck).size()) > 0) {
int cur = calc(((int)(stck).size()) == 1
? l
: stck[((int)(stck).size()) - 2].second + 1,
r - 1, stck.back().first);
if (cur > ret) ret = cur;
stck.pop_back();
}
return ret;
}
void stress() {
for (int rep = (0); rep < (10000); ++rep) {
ntn = 0;
troot = gettn(-1);
n = 100;
nq = 100;
int slen = 5;
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (slen); ++j) s[j] = 'a' + rand() % 2;
s[slen] = '\0';
os[i] = ss[i] = string(s);
len[i] = strlen(s), tpos[i] = tinsert();
}
for (int i = (0); i < (nq); ++i) {
qkind[i] = 1 + rand() % 2;
if (qkind[i] == 1) {
ql[i] = rand() % n, qr[i] = rand() % n;
if (ql[i] > qr[i]) swap(ql[i], qr[i]);
chk[i] = bf(ql[i], qr[i]);
}
if (qkind[i] == 2) {
qidx[i] = rand() % n;
for (int j = (0); j < (slen); ++j) s[j] = 'a' + rand() % 2;
s[slen] = '\0';
qs[i] = ss[qidx[i]] = string(s);
qlen[i] = strlen(s), qtpos[i] = tinsert();
}
}
solve();
bool ok = true;
for (int i = (0); i < (nq); ++i)
if (qkind[i] == 1 && chk[i] != ans[i]) {
printf("it%d: err in q%d: expected %d but got %d\n", rep, i, chk[i],
ans[i]);
printf("%d %d\n", n, nq);
for (int j = (0); j < (n); ++j) {
if (j != 0) printf(" ");
printf("%s", os[j].c_str());
}
puts("");
for (int j = (0); j < (nq); ++j) {
if (qkind[j] == 1) printf("1 %d %d\n", ql[j] + 1, qr[j] + 1);
if (qkind[j] == 2) printf("2 %d %s\n", qidx[j] + 1, qs[j].c_str());
}
ok = false;
break;
}
if (ok) printf(".");
}
}
void stresstime() {
ntn = 0;
troot = gettn(-1);
n = MAXN;
nq = MAXQ;
int slen = 1;
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (slen); ++j) s[j] = 'a' + rand() % 2;
s[slen] = '\0';
len[i] = strlen(s), tpos[i] = tinsert();
}
for (int i = (0); i < (nq); ++i) {
qkind[i] = 1;
if (qkind[i] == 1) {
ql[i] = rand() % n, qr[i] = rand() % n;
if (ql[i] > qr[i]) swap(ql[i], qr[i]);
chk[i] = bf(ql[i], qr[i]);
}
if (qkind[i] == 2) {
qidx[i] = rand() % n;
for (int j = (0); j < (slen); ++j) s[j] = 'a' + rand() % 2;
s[slen] = '\0';
qs[i] = ss[qidx[i]] = string(s);
qlen[i] = strlen(s), qtpos[i] = tinsert();
}
}
solve();
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
inline void writeln(int x) {
char buffor[21];
register int i = 0;
int neg = 0;
if (x < 0) {
neg = 1;
x = -x;
}
do {
buffor[i++] = (x % 10) + '0';
x /= 10;
} while (x);
i--;
if (neg) putchar('-');
while (i >= 0) putchar(buffor[i--]);
putchar('\n');
}
const int N = (int)1e5 + 10;
int n, q;
int lcp[N];
string str[N];
struct node {
vector<pair<int, int> > Left, Right;
int res;
};
int low[4 * N], high[4 * N];
node it[4 * N];
void input() {
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> str[i];
}
void cal(node a, node b, node &c, int lcp_ab) {
if (a.res == -1) {
c = b;
return;
} else if (b.res == -1) {
c = a;
return;
};
c.Left.clear();
for (auto it : a.Left) c.Left.push_back(it);
if (lcp_ab < c.Left.back().first) c.Left.push_back(pair<int, int>(lcp_ab, 0));
for (auto it : b.Left)
if (it.first >= c.Left.back().first)
c.Left.back().second += it.second;
else
c.Left.push_back(pair<int, int>(it.first, it.second));
c.Right.clear();
for (auto it : b.Right) c.Right.push_back(it);
if (lcp_ab < c.Right.back().first)
c.Right.push_back(pair<int, int>(lcp_ab, 0));
for (auto it : a.Right)
if (it.first >= c.Right.back().first)
c.Right.back().second += it.second;
else
c.Right.push_back(pair<int, int>(it.first, it.second));
c.res = max(a.res, b.res);
int i, j, sza, szb, sum = 0, len = lcp_ab;
i = 0;
j = 0;
sza = a.Right.size();
szb = b.Left.size();
while (i < sza or j < szb) {
if (j == szb) {
sum += a.Right[i].second;
if (a.Right[i].first < len) len = a.Right[i].first;
i++;
} else if (i == sza) {
sum += b.Left[j].second;
if (b.Left[j].first < len) len = b.Left[j].first;
j++;
} else {
if (a.Right[i].first >= b.Left[j].first) {
sum += a.Right[i].second;
if (a.Right[i].first < len) len = a.Right[i].first;
i++;
} else {
sum += b.Left[j].second;
if (b.Left[j].first < len) len = b.Left[j].first;
j++;
}
}
c.res = max(c.res, len * sum);
}
}
void build(int x, int l, int r) {
low[x] = l;
high[x] = r;
if (l == r) {
int sz = str[l].size();
it[x].Left.push_back(pair<int, int>(sz, 1));
it[x].Right.push_back(pair<int, int>(sz, 1));
it[x].res = sz;
return;
};
int m = (l + r) / 2;
build(2 * x, l, m);
build(2 * x + 1, m + 1, r);
cal(it[2 * x], it[2 * x + 1], it[x], lcp[m]);
}
void update(int x, int pos, int sz) {
if (low[x] == high[x]) {
it[x].Left.back().first = sz;
it[x].Right.back().first = sz;
it[x].res = sz;
return;
}
if (pos <= high[2 * x])
update(2 * x, pos, sz);
else
update(2 * x + 1, pos, sz);
cal(it[2 * x], it[2 * x + 1], it[x], lcp[high[2 * x]]);
}
node query(int x, int l, int r) {
if (low[x] > r or high[x] < l) {
node trash;
trash.res = -1;
return trash;
}
if (low[x] >= l and high[x] <= r) return it[x];
node ans;
cal(query(2 * x, l, r), query(2 * x + 1, l, r), ans, lcp[high[2 * x]]);
return ans;
}
void init() {
for (int i = 1; i <= n - 1; i++) {
int sz = min(str[i].size(), str[i + 1].size());
lcp[i] = 0;
for (int p = 0; p <= sz - 1; p++)
if (str[i][p] == str[i + 1][p])
lcp[i] = p + 1;
else
break;
}
build(1, 1, n);
}
void solve() {
init();
for (int i = 1; i <= q; i++) {
int typ;
cin >> typ;
if (typ == 1) {
int a, b;
cin >> a >> b;
cout << query(1, a, b).res << '\n';
} else {
int x;
cin >> x;
cin >> str[x];
int sz = str[x].size();
if (x != 1) {
lcp[x - 1] = 0;
for (int p = 0; p <= sz - 1; p++)
if (str[x - 1][p] == str[x][p])
lcp[x - 1] = p + 1;
else
break;
};
if (x != n) {
lcp[x] = 0;
for (int p = 0; p <= sz - 1; p++)
if (str[x][p] == str[x + 1][p])
lcp[x] = p + 1;
else
break;
};
update(1, x, sz);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
template <class Val>
struct SetSingleSegmentTree {
vector<Val> V;
size_t n;
function<Val(Val, Val)> combine;
void init(const vector<Val> &A,
function<Val(Val, Val)> combine = plus<Val>()) {
n = 1;
while (n < A.size()) n <<= 1;
V.assign(n, Val());
V.insert(V.end(), A.begin(), A.end());
V.resize(n << 1, Val());
this->combine = combine;
for (int i = n - 1; i > 0; i--)
V[i] = this->combine(V[i << 1], V[i << 1 | 1]);
}
void setVal(int p, Val value) {
for (V[p += n] = value; p > 1; p >>= 1)
V[p >> 1] = p & 1 ? combine(V[p ^ 1], V[p]) : combine(V[p], V[p ^ 1]);
}
Val getRange(int l, int r) {
Val left = Val();
Val right = Val();
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) left = combine(left, V[l++]);
if (r & 1) right = combine(V[--r], right);
}
return combine(left, right);
}
};
struct Node {
int ans = 0, left = 0, right = 0, length = 1;
};
Node combine(const Node &a, const Node &b) {
Node ret;
ret.ans = max(a.ans, b.ans);
ret.ans = max(ret.ans, a.right + b.left);
ret.left = a.left;
ret.right = b.right;
if (a.left == a.length) ret.left += b.left;
if (b.right == b.length) ret.right += a.right;
ret.length = a.length + b.length;
return ret;
}
const int N = 1e5 + 5;
const int M = 50;
SetSingleSegmentTree<Node> stS[M + 5];
SetSingleSegmentTree<int> st;
string sS[N];
int D[N];
set<PII> S;
vector<int> L;
int dist(const string &s, const string &t) {
int ret = 0;
while (ret < s.length() && ret < t.length()) {
if (s[ret] != t[ret]) return ret;
ret++;
}
return ret;
}
void alter(int p, int oldV, int newV) {
if (oldV > M) S.erase(make_pair(p, oldV));
if (newV > M) S.insert(make_pair(p, newV));
for (int i = (1); i <= (M); i++) {
Node x;
if (newV >= i) x.left = x.right = x.ans = 1;
stS[i].setVal(p, x);
}
D[p] = newV;
}
LL solve(const vector<int> &V) {
vector<int> L(V.size()), R(V.size());
stack<int> K;
for (int i = (0); i <= (int((V).size()) - 1); i++) {
while (!K.empty() && V[K.top()] >= V[i]) K.pop();
if (K.empty())
L[i] = 0;
else
L[i] = K.top() + 1;
K.push(i);
}
while (!K.empty()) K.pop();
for (int i = (int((V).size()) - 1); i >= (0); i--) {
while (!K.empty() && V[K.top()] >= V[i]) K.pop();
if (K.empty())
R[i] = int((V).size()) - 1;
else
R[i] = K.top() - 1;
K.push(i);
}
LL ret = 0;
for (int i = (0); i <= (int((V).size()) - 1); i++) {
ret = max(ret, 1LL * (R[i] - L[i] + 2) * V[i]);
}
return ret;
}
int main() {
int n, q;
scanf("%d%d", &n, &q);
for (int i = (1); i <= (n); i++) cin >> sS[i];
L.push_back(0);
for (int i = (1); i <= (n); i++) L.push_back(sS[i].length());
for (int i = (1); i <= (n - 1); i++) {
D[i] = dist(sS[i], sS[i + 1]);
if (D[i] > M) {
S.insert(make_pair(i, D[i]));
}
}
st.init(L, [](int x, int y) { return max(x, y); });
for (int i = (1); i <= (M); i++) {
vector<Node> V;
V.push_back(Node());
for (int j = (1); j <= (n - 1); j++) {
if (D[j] >= i) {
auto x = Node();
x.ans = x.left = x.right = x.length = 1;
V.push_back(x);
} else {
auto x = Node();
x.length = 1;
V.push_back(x);
}
}
stS[i].init(V, combine);
}
while (q--) {
int type;
scanf("%d", &type);
if (type == 1) {
int a, b;
scanf("%d%d", &a, &b);
LL ans = st.getRange(a, b + 1);
for (int i = (1); i <= (M); i++) {
int length = stS[i].getRange(a, b).ans;
if (length) {
ans = max(ans, 1LL * i * (length + 1));
}
}
auto left = S.lower_bound(make_pair(a, 0));
auto right = S.upper_bound(make_pair(b, 0));
auto pos = left;
vector<int> V;
int pre = -1;
while (pos != right) {
if (V.empty() || pre + 1 == pos->first) {
V.push_back(pos->second);
pre = pos->first;
} else {
V.push_back(0);
V.push_back(pos->second);
pre = pos->first;
}
pos++;
}
ans = max(ans, solve(V));
printf("%lld\n", ans);
} else {
int p;
string s;
scanf("%d", &p);
cin >> s;
sS[p] = s;
st.setVal(p, sS[p].length());
if (p > 1) {
alter(p - 1, D[p - 1], dist(sS[p - 1], sS[p]));
}
if (p < n) {
alter(p, D[p], dist(sS[p], sS[p + 1]));
}
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,fast-math")
using namespace std;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
const int maxn = 131072;
const long long inf = 9223372036854775807;
const long long mod = 1e8 + 7;
const int sq = 250;
int type[maxn], ql[maxn], qr[maxn], n, q, lcp[maxn], seg[maxn * 4],
pr[maxn * 4], sf[maxn * 4], ans[maxn], sz = 1, lc, rc, seg2[4 * maxn];
string s[maxn], qs[maxn], ts[maxn];
vector<int> comp;
pair<pair<int, int>, pair<int, int> > res;
void build2(const int &x = 1, const int &lx = 0, const int &rx = n) {
if (rx - lx == 1) {
seg2[x] = ts[lx].size();
return;
}
int mid = lx + rx >> 1;
build2(x << 1, lx, mid);
build2(x << 1 | 1, mid, rx);
seg2[x] = max(seg2[x << 1], seg2[x << 1 | 1]);
}
void upd2(const int &p, const int &x = 1, const int &lx = 0,
const int &rx = n) {
if (rx - lx == 1) {
seg2[x] = ts[lx].size();
return;
}
int mid = lx + rx >> 1;
if (p < mid)
upd2(p, x << 1, lx, mid);
else
upd2(p, x << 1 | 1, mid, rx);
seg2[x] = max(seg2[x << 1], seg2[x << 1 | 1]);
}
int get2(const int &l, const int &r, const int &x = 1, const int &lx = 0,
const int &rx = n) {
if (lx >= r || rx <= l) return 0;
if (lx >= l && rx <= r) {
return seg2[x];
}
int mid = lx + rx >> 1;
return max(get2(l, r, x << 1, lx, mid), get2(l, r, x << 1 | 1, mid, rx));
}
void merge(const int &x, const int &lx, const int &rx, const int &mid) {
lc = x << 1;
rc = x << 1 | 1;
seg[x] = max(seg[lc], seg[rc]);
seg[x] = max(seg[x], sf[lc] + pr[rc]);
if (seg[lc] == mid - lx) {
pr[x] = mid - lx + pr[rc];
} else
pr[x] = pr[lc];
if (seg[rc] == rx - mid) {
sf[x] = rx - mid + sf[lc];
} else
sf[x] = sf[rc];
}
pair<pair<int, int>, pair<int, int> > merge(
const pair<pair<int, int>, pair<int, int> > &p1,
const pair<pair<int, int>, pair<int, int> > &p2) {
res = {{0, 0}, {0, 0}};
res.first.second = p1.first.second + p2.first.second;
res.first.first = max(p1.first.first, p2.first.first);
res.first.first = max(res.first.first, p1.second.second + p2.second.first);
if (p1.first.first == p1.first.second)
res.second.first = p1.first.first + p2.second.first;
else
res.second.first = p1.second.first;
if (p2.first.first == p2.first.second)
res.second.second = p2.first.first + p1.second.second;
else
res.second.second = p2.second.second;
return res;
}
void build(const int &i, const int &x = 1, const int &lx = 1,
const int &rx = n) {
if (rx - lx == 1) {
if (lcp[lx] >= i) {
seg[x] = 1;
sf[x] = 1;
pr[x] = 1;
} else {
seg[x] = sf[x] = pr[x] = 0;
}
return;
}
int mid = lx + rx >> 1;
build(i, x << 1, lx, mid);
build(i, x << 1 | 1, mid, rx);
merge(x, lx, rx, mid);
}
void upd(const int &p, const int &v, const int &x = 1, const int &lx = 1,
const int &rx = n) {
if (rx - lx == 1) {
seg[x] = sf[x] = pr[x] = v;
return;
}
int mid = lx + rx >> 1;
if (p < mid)
upd(p, v, x << 1, lx, mid);
else
upd(p, v, x << 1 | 1, mid, rx);
merge(x, lx, rx, mid);
}
pair<pair<int, int>, pair<int, int> > get(const int &l, const int &r,
const int &x = 1, const int &lx = 1,
const int &rx = n) {
if (r <= l) return {{-1, 0}, {0, 0}};
if (lx >= r || rx <= l) return {{-1, 0}, {0, 0}};
if (lx >= l && rx <= r) {
return {{seg[x], rx - lx}, {pr[x], sf[x]}};
}
int mid = lx + rx >> 1;
return merge(get(l, r, x << 1, lx, mid), get(l, r, x << 1 | 1, mid, rx));
}
inline void reset() {
for (int i = 0; i < n; i++) {
ts[i] = s[i];
lcp[i] = 0;
if (i != 0) {
for (int j = 0; j < s[i].size() && j < s[i - 1].size(); j++) {
if (s[i][j] != s[i - 1][j]) break;
lcp[i]++;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> s[i];
ts[i] = s[i];
if (i != 0) {
for (int j = 0; j < s[i].size() && j < s[i - 1].size(); j++) {
if (s[i][j] != s[i - 1][j]) break;
lcp[i]++;
}
}
comp.push_back(lcp[i]);
}
if (n == 1) {
for (int i = 1; i <= q; i++) {
cin >> type[i];
if (type[i] == 1) {
cin >> ql[i] >> qr[i];
cout << s[0].size() << endl;
} else
cin >> ql[i] >> s[0];
}
return 0;
}
build2();
for (int i = 1; i <= q; i++) {
cin >> type[i];
if (type[i] == 1) {
cin >> ql[i] >> qr[i];
ql[i]--;
ans[i] = max(ans[i], get2(ql[i], qr[i]));
} else {
cin >> ql[i] >> qs[i];
ql[i]--;
ts[ql[i]] = qs[i];
upd2(ql[i]);
if (ql[i] > 0) {
lcp[ql[i]] = 0;
for (int j = 0; j < ts[ql[i]].size() && j < ts[ql[i] - 1].size(); j++) {
if (ts[ql[i]][j] != ts[ql[i] - 1][j]) break;
lcp[ql[i]]++;
}
}
if (ql[i] < n - 1) {
lcp[ql[i] + 1] = 0;
for (int j = 0; j < ts[ql[i]].size() && j < ts[ql[i] + 1].size(); j++) {
if (ts[ql[i]][j] != ts[ql[i] + 1][j]) break;
lcp[ql[i] + 1]++;
}
}
comp.push_back(lcp[ql[i]]);
comp.push_back(lcp[ql[i] + 1]);
}
}
comp.push_back(0);
comp.push_back(1);
sort((comp).begin(), (comp).end());
comp.resize(unique((comp).begin(), (comp).end()) - comp.begin());
int LC, o;
for (int h = 1; h < comp.size(); h++) {
LC = comp[h];
reset();
build(LC);
for (int i = 1; i <= q; i++) {
if (type[i] == 1) {
o = get(ql[i] + 1, qr[i]).first.first;
if (o > 0) ans[i] = max(ans[i], (o + 1) * LC);
continue;
}
ts[ql[i]] = qs[i];
if (ql[i] > 0) {
lcp[ql[i]] = 0;
for (int j = 0; j < ts[ql[i]].size() && j < ts[ql[i] - 1].size(); j++) {
if (ts[ql[i]][j] != ts[ql[i] - 1][j]) break;
lcp[ql[i]]++;
}
}
if (ql[i] < n - 1) {
lcp[ql[i] + 1] = 0;
for (int j = 0; j < ts[ql[i]].size() && j < ts[ql[i] + 1].size(); j++) {
if (ts[ql[i]][j] != ts[ql[i] + 1][j]) break;
lcp[ql[i] + 1]++;
}
}
if (lcp[ql[i]] >= LC && ql[i] > 0) {
upd(ql[i], 1);
} else if (ql[i] > 0) {
upd(ql[i], 0);
}
if (lcp[ql[i] + 1] >= LC && ql[i] + 1 < n) {
upd(ql[i] + 1, 1);
} else if (ql[i] + 1 < n) {
upd(ql[i] + 1, 0);
}
}
}
for (int i = 1; i <= q; i++) {
if (qr[i]) {
cout << ans[i] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, B = 50;
int lcp[N];
struct event {
int l, r;
string s;
event() {}
event(int l, int r) : l(l), r(r), s("") {}
event(int x, string s) : l(x), r(x), s(s) {}
};
void make_lcp(int &j, string &a, string &b) {
for (j = 0; j < (int)min(a.length(), b.length()) && a[j] == b[j]; ++j)
;
}
struct node {
int l, r, res, len;
};
node tree[N * 4];
node operator+(const node &a, const node &b) {
return (node){a.l == a.len ? a.l + b.l : a.l, b.r == b.len ? b.r + a.r : b.r,
max(max(a.res, b.res), a.r + b.l), a.len + b.len};
}
int LIM, ans[N], T[4 * N], len[N];
void update(int x, int l, int r, int p) {
if (l == r) {
int v = lcp[l] >= ::LIM;
tree[x] = (node){v, v, v, 1};
T[x] = len[l];
return;
}
int mid = (l + r) / 2;
if (p <= mid)
update(x + x, l, mid, p);
else
update(x + x + 1, mid + 1, r, p);
tree[x] = tree[x + x] + tree[x + x + 1];
T[x] = max(T[x + x], T[x + x + 1]);
}
node query(int x, int l, int r, int ql, int qr) {
if (l >= ql && r <= qr) return tree[x];
int mid = (l + r) / 2;
if (qr <= mid) return query(x + x, l, mid, ql, qr);
if (ql > mid) return query(x + x + 1, mid + 1, r, ql, qr);
return query(x + x, l, mid, ql, qr) + query(x + x + 1, mid + 1, r, ql, qr);
}
int query_len(int x, int l, int r, int ql, int qr) {
if (l > qr || r < ql) return 0;
if (l >= ql && r <= qr) return T[x];
int mid = (l + r) / 2;
return max(query_len(x + x, l, mid, ql, qr),
query_len(x + x + 1, mid + 1, r, ql, qr));
}
void build(int x, int l, int r) {
if (l == r) {
int v = lcp[l] >= ::LIM;
tree[x] = (node){v, v, v, 1};
T[x] = len[l];
return;
}
int mid = (l + r) / 2;
build(x + x, l, mid);
build(x + x + 1, mid + 1, r);
tree[x] = tree[x + x] + tree[x + x + 1];
T[x] = max(T[x + x], T[x + x + 1]);
}
void work(int len, vector<string> S, vector<event> &Q) {
::LIM = len;
int n = (int)S.size();
for (int i = 0; i < n; ++i) ::len[i] = (int)S[i].length();
for (int i = 1; i < n; ++i) make_lcp(lcp[i], S[i], S[i - 1]);
build(1, 0, n - 1);
int cnt = 0;
for (event e : Q) {
if (e.s.empty()) {
int l = e.l, r = e.r;
--l, --r;
int res = (l == r ? 0 : query(1, 0, n - 1, l + 1, r).res);
if (res) ans[cnt] = max(ans[cnt], len * (res + 1));
ans[cnt] = max(ans[cnt], query_len(1, 0, n - 1, l, r));
cnt++;
} else {
int i = e.l;
--i;
S[i] = e.s;
if (i) make_lcp(lcp[i], S[i], S[i - 1]);
if (i < n - 1) make_lcp(lcp[i + 1], S[i + 1], S[i]);
::len[i] = (int)S[i].length();
update(1, 0, n - 1, i);
if (i < n - 1) update(1, 0, n - 1, i + 1);
}
}
}
int solve(const vector<int> &a) {
vector<pair<int, int>> q;
q.push_back({0, -1});
int res = 0;
for (int i = 0; i < (int)a.size(); ++i) {
while (q.back().first >= a[i]) {
res = max(res, q.back().first * (i - q[(int)q.size() - 2].second));
q.pop_back();
}
q.push_back({a[i], i});
}
while (q.back().first > 0) {
res = max(res,
q.back().first * ((int)a.size() - q[(int)q.size() - 2].second));
q.pop_back();
}
return res;
}
int debug = 0;
int main() {
ios::sync_with_stdio(false);
int n, m;
if (debug)
n = m = 100000;
else
cin >> n >> m;
vector<string> ss;
for (int i = 1; i <= n; ++i) {
string s;
if (debug)
s = rand() % 26 + 'a';
else
cin >> s;
ss.push_back(s);
}
vector<event> all;
for (int i = 0; i < m; ++i) {
int type;
if (debug)
type = 1;
else
cin >> type;
if (type == 2) {
int x;
string s;
cin >> x >> s;
all.push_back(event(x, s));
} else {
int l, r;
if (debug) {
l = rand() % n + 1, r = rand() % n + 1;
if (l > r) swap(l, r);
} else
cin >> l >> r;
all.push_back(event(l, r));
}
}
for (int len = 1; len < B; ++len) work(len, ss, all);
set<pair<int, int>> big;
for (int i = 1; i < n; ++i) make_lcp(lcp[i], ss[i], ss[i - 1]);
for (int i = 1; i < n; ++i)
if (lcp[i] >= B) big.insert({i, lcp[i]});
int cnt = 0;
for (event e : all) {
if (e.s.empty()) {
int l = e.l, r = e.r;
--l, --r;
vector<int> tmp;
int las = -3;
for (auto it = big.lower_bound({l + 1, 0});
it != big.end() && it->first <= r; ++it) {
auto x = *it;
if (x.first > l && x.first <= r) {
if (tmp.empty() || las + 1 == x.first) {
tmp.push_back(x.second);
} else {
ans[cnt] = max(ans[cnt], solve(tmp));
tmp.clear();
tmp.push_back(x.second);
}
las = x.first;
}
}
if (!tmp.empty()) ans[cnt] = max(ans[cnt], solve(tmp));
cnt++;
} else {
int i = e.l;
--i;
ss[i] = e.s;
int ol = lcp[i], ol2 = lcp[i + 1];
if (i) make_lcp(lcp[i], ss[i], ss[i - 1]);
if (i < n - 1) make_lcp(lcp[i + 1], ss[i + 1], ss[i]);
int ne = lcp[i], ne2 = lcp[i + 1];
if (i) {
if (ol >= B) big.erase({i, ol});
if (ne >= B) big.insert({i, ne});
}
if (i < n - 1) {
if (ol2 >= B) big.erase({i + 1, ol2});
if (ne2 >= B) big.insert({i + 1, ne2});
}
}
}
if (!debug)
for (int i = 0; i < cnt; ++i) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 101 * 1001, SQ = 55;
string s[MAXN];
int a[MAXN], b[MAXN];
int ans[MAXN], Ans[MAXN];
bool mark[MAXN];
struct query {
int id, l, r;
} qu[3 * MAXN];
inline int lcp(int i) {
int j = i + 1;
int x = min(s[i].size(), s[j].size());
int ans = 0;
while (ans < x && s[i][ans] == s[j][ans]) ans++;
return ans;
}
set<pair<int, int>> ss;
int prv[MAXN], nxt[MAXN];
int solve(int s, int e) {
vector<int> st;
st.push_back(s - 1);
for (int i = s; i < e; i++) {
while (st.size() > 1 && b[st.back()] >= b[i]) st.pop_back();
prv[i] = st.back();
st.push_back(i);
}
st.clear();
st.push_back(e);
int ans = 0;
for (int i = e - 1; i >= s; i--) {
while (st.size() > 1 && b[st.back()] >= b[i]) st.pop_back();
nxt[i] = st.back();
st.push_back(i);
ans = max(ans, b[i] * (nxt[i] - prv[i]));
}
return ans;
}
pair<int, int> get(int i) {
int s = i, e = i;
while (s > -1 && mark[s]) s--;
while (mark[e]) e++;
return {s + 1, e};
}
void dlt(int i) {
if (i < 0 || b[i] < SQ || !mark[i]) return;
ss.erase(get(i));
mark[i] = 0;
if (i && mark[i - 1]) ss.insert(get(i - 1));
if (mark[i + 1]) ss.insert(get(i + 1));
}
void ins(int i) {
if (i < 0 || b[i] < SQ) return;
if (i && mark[i - 1]) ss.erase(get(i - 1));
if (mark[i + 1]) ss.erase(get(i + 1));
mark[i] = 1;
ss.insert(get(i));
}
int mx[4 * MAXN];
void Upd(int i, int val, int s = 0, int e = MAXN, int ind = 1) {
if (e - s == 1) {
mx[ind] = val;
return;
}
int mid = (s + e) / 2;
if (i < mid)
Upd(i, val, s, mid, 2 * ind);
else
Upd(i, val, mid, e, 2 * ind + 1);
mx[ind] = max(mx[2 * ind], mx[2 * ind + 1]);
}
int Get(int l, int r, int s = 0, int e = MAXN, int ind = 1) {
if (l <= s && e <= r) return mx[ind];
if (r <= s || e <= l) return 0;
int mid = (s + e) / 2;
return max(Get(l, r, s, mid, 2 * ind), Get(l, r, mid, e, 2 * ind + 1));
}
struct node {
int ans, pre, suf, len;
} seg[4 * MAXN];
node bb;
node mrg(node a, node b) {
node ans;
ans.ans = max({a.ans, b.ans, a.suf + b.pre});
ans.pre = (a.pre == a.len ? a.pre + b.pre : a.pre);
ans.suf = (b.suf == b.len ? b.suf + a.suf : b.suf);
ans.len = a.len + b.len;
return ans;
}
void build(int s = 0, int e = MAXN, int ind = 1) {
if (e - s == 1) {
seg[ind] = {0, 0, 0, 1};
return;
}
int mid = (s + e) / 2;
build(s, mid, 2 * ind);
build(mid, e, 2 * ind + 1);
seg[ind] = mrg(seg[2 * ind], seg[2 * ind + 1]);
}
void upd(int i, int x, int s = 0, int e = MAXN, int ind = 1) {
if (e - s == 1) {
seg[ind] = {x, x, x, 1};
return;
}
int mid = (s + e) / 2;
if (i < mid)
upd(i, x, s, mid, 2 * ind);
else
upd(i, x, mid, e, 2 * ind + 1);
seg[ind] = mrg(seg[2 * ind], seg[2 * ind + 1]);
}
node get(int l, int r, int s = 0, int e = MAXN, int ind = 1) {
if (l <= s && e <= r) return seg[ind];
if (r <= s || e <= l) return bb;
int mid = (s + e) / 2;
return mrg(get(l, r, s, mid, 2 * ind), get(l, r, mid, e, 2 * ind + 1));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
bb = {0, 0, 0, 0};
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n - 1; i++) b[i] = a[i] = lcp(i), ins(i);
b[n - 1] = -100;
int m = 0;
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) Upd(i, s[i].size());
for (int i = 0; i < q; i++) {
int t;
cin >> t;
if (t == 1) {
int l, r;
cin >> l >> r;
l--;
qu[m++] = {-i - 1, l, r};
r--;
for (auto u : ss) {
int s = u.first, e = u.second;
if (r <= s || e <= l) continue;
ans[i] = max(ans[i], solve(max(s, l), min(r, e)));
}
r++;
ans[i] = max(ans[i], Get(l, r));
}
if (t == 2) {
ans[i] = -1;
string t;
int x, v;
cin >> x >> t;
x--;
s[x] = t;
Upd(x, s[x].size());
dlt(x), dlt(x - 1);
if (x) b[x - 1] = lcp(x - 1), qu[m++] = {i, x - 1, b[x - 1]};
if (x < n - 1) b[x] = lcp(x), qu[m++] = {i, x, b[x]};
ins(x), ins(x - 1);
}
}
for (int _ = 1; _ <= SQ; _++) {
build();
for (int i = 0; i < n - 1; i++) {
upd(i, a[i] >= _);
b[i] = a[i];
}
for (int i = 0; i < m; i++) {
if (qu[i].id < 0) {
int id = -(qu[i].id + 1);
int l = qu[i].l, r = qu[i].r - 1;
int val = get(l, r).ans;
if (val > 0) val++;
ans[id] = max(ans[id], val * _);
} else {
int id = qu[i].l;
int v = qu[i].r;
upd(id, b[id] >= _);
b[id] = v;
upd(id, b[id] >= _);
}
}
}
for (int i = 0; i < q; i++)
if (ans[i] > -1) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int sz, l, r, best;
node() {
sz = -1;
l = r = -1;
best = -1;
}
node(int a) { *this = node(1, 0, 0, 0); }
node(int a, int b, int c, int d) {
sz = a;
l = b;
r = c;
best = d;
}
};
node operator+(node a, node b) {
if (a.sz == -1) return b;
if (b.sz == -1) return a;
node ans;
if (a.l == a.sz && b.r == b.sz)
ans = node(a.sz + b.sz, a.sz + b.sz, a.sz + b.sz, a.sz + b.sz);
else if (a.l == a.sz) {
ans = node(a.sz + b.sz, a.sz + b.l, b.r, max({a.best, b.best, a.sz + b.l}));
} else if (b.r == b.sz) {
ans = node(a.sz + b.sz, a.l, a.r + b.sz, max({a.best, b.best, a.r + b.sz}));
} else {
ans = node(a.sz + b.sz, a.l, b.r, max({a.best, b.best, a.r + b.l}));
}
return ans;
}
template <typename T>
class segment_tree {
private:
static const int default_size = 100001;
int my_size;
vector<T> tree;
void build(vector<T>& data, int id, int l, int r) {
if (l == r)
tree[id] = data[l];
else {
int mid = (l + r) >> 1;
build(data, id << id, l, mid);
build(data, id << 1 | 1, mid + 1, r);
tree[id] = tree[id << 1] + tree[id << 1 | 1];
}
}
void update(int id, int l, int r, int pos, T v) {
if (l == r)
tree[id] = v;
else {
int mid = (l + r) >> 1;
if (pos <= mid)
update(id << 1, l, mid, pos, v);
else
update(id << 1 | 1, mid + 1, r, pos, v);
tree[id] = tree[id << 1] + tree[id << 1 | 1];
}
}
T query(int id, int l, int r, int x, int y) {
if (l > y || r < x) return T();
if (x <= l && r <= y) return tree[id];
int mid = (l + r) >> 1;
return query(id << 1, l, mid, x, y) + query(id << 1 | 1, mid + 1, r, x, y);
}
public:
segment_tree() {}
segment_tree(int size) {
my_size = size;
clear();
}
void clear() { tree.assign(my_size << 2, T(0)); }
void build(vector<T>& data) {
data.resize(my_size);
build(data, 1, 0, my_size - 1);
}
void setPos(int pos, T value) { update(1, 0, my_size - 1, pos, value); }
void update(int pos, T value) { setPos(pos, value); }
T getPos(int pos) { return query(1, 0, my_size - 1, pos, pos); }
void addToPos(int pos, T value) { setPos(pos, getPos(pos) + value); }
T getInterval(int l, int r) { return query(1, 0, my_size - 1, l, r); }
T query(int l, int r) { return getInterval(l, r); }
};
struct histogram_solver {
vector<int> dp;
vector<int> he;
static long long solve(vector<int> values) {
stack<int> s;
int i = 0;
long long ans = 0;
while (i < values.size()) {
if (s.empty() || values[s.top()] <= values[i])
s.push(i++);
else {
int tp = s.top();
s.pop();
long long area = 1ll * values[tp] * (s.empty() ? i + 1 : i - s.top());
ans = max(ans, area);
}
}
while (!s.empty()) {
int tp = s.top();
s.pop();
long long area = 1ll * values[tp] * (s.empty() ? i + 1 : i - s.top());
ans = max(ans, area);
}
return ans;
}
};
const int maxn = 100100;
const int magic = 50;
segment_tree<node> trees[magic];
struct max_t {
long long value;
max_t() { value = -(1ll << 50); }
max_t(long long v) { value = v; }
max_t operator+(const max_t& other) { return max_t(max(value, other.value)); }
};
segment_tree<max_t> library;
string arr[maxn];
char str[maxn];
int lcp[maxn];
int solve(set<int>& B, int l, int r) {
int last = -1;
vector<int> to_apply;
for (int v : B) {
if (v >= l && v < r) {
if (last != -1 && last + 1 != v) to_apply.push_back(0);
to_apply.push_back(lcp[v]);
last = v;
}
}
histogram_solver lol;
return lol.solve(to_apply);
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int e = 0; e < n; e++) {
scanf("%s", str);
arr[e] = str;
}
for (int e = 0; e < n - 1; e++) {
while (lcp[e] < arr[e].size() && lcp[e] < arr[e + 1].size() &&
arr[e][lcp[e]] == arr[e + 1][lcp[e]])
lcp[e]++;
}
for (int e = 0; e < magic; e++) trees[e] = segment_tree<node>(n);
library = segment_tree<max_t>(n);
set<int> big;
for (int e = 0; e < n - 1; e++) {
for (int f = 0; f <= min(lcp[e], magic - 1); f++)
trees[f].update(e, node(1, 1, 1, 1));
if (lcp[e] >= magic) big.insert(e);
}
for (int e = 0; e < n; e++) library.update(e, arr[e].size());
cerr << "build " << clock() << " ms" << endl;
for (int e = 0; e < q; e++) {
int type;
scanf("%d", &type);
if (type == 1) {
int l, r;
scanf("%d %d", &l, &r);
l--;
r--;
int ans = library.query(l, r).value;
if (l < r) {
for (int f = 0; f < magic; f++) {
int sz = trees[f].query(l, r - 1).best;
if (sz == 0) sz--;
ans = max(ans, (sz + 1) * f);
}
ans = max(ans, solve(big, l, r));
}
printf("%d\n", ans);
} else {
int l;
scanf("%d %s", &l, str);
l--;
arr[l] = str;
library.update(l, arr[l].size());
if (l) {
if (lcp[l - 1] >= magic) big.erase(l - 1);
for (int f = 0; f <= min(magic - 1, lcp[l - 1]); f++)
trees[f].update(l - 1, node(0));
lcp[l - 1] = 0;
while (lcp[l - 1] < arr[l - 1].size() && lcp[l - 1] < arr[l].size() &&
arr[l - 1][lcp[l - 1]] == arr[l][lcp[l - 1]])
lcp[l - 1]++;
for (int f = 0; f <= min(magic - 1, lcp[l - 1]); f++)
trees[f].update(l - 1, node(1, 1, 1, 1));
if (lcp[l - 1] >= magic) big.insert(l - 1);
}
if (l < n - 1) {
if (lcp[l] >= magic) big.erase(l);
for (int f = 0; f <= min(magic - 1, lcp[l]); f++)
trees[f].update(l, node(0));
lcp[l] = 0;
while (lcp[l] < arr[l].size() && lcp[l] < arr[l + 1].size() &&
arr[l][lcp[l]] == arr[l + 1][lcp[l]])
lcp[l]++;
for (int f = 0; f <= min(magic - 1, lcp[l]); f++)
trees[f].update(l, node(1, 1, 1, 1));
if (lcp[l] >= magic) big.insert(l);
}
}
}
cerr << "over " << clock() << " ms" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class segtree {
private:
using T = array<int, 4>;
int b;
vector<T> tr;
T merge(const T& x, const T& y) {
T ret = {};
ret[0] = max({x[0], y[0], x[2] + y[1]});
ret[1] = (x[1] == x[3] ? x[3] + y[1] : x[1]);
ret[2] = (y[2] == y[3] ? x[2] + y[3] : y[2]);
ret[3] = x[3] + y[3];
return ret;
}
T single(int x = -1) {
T ret = {};
for (int j = 0; j < 3; j++) {
ret[j] = (x >= LB);
}
ret[3] = 1;
return ret;
}
public:
int LB;
segtree() {}
segtree(int lowerBound, const vector<int>& a) {
LB = lowerBound;
b = 1;
while (b < (int)a.size()) {
b <<= 1;
}
tr.assign(2 * b, single());
for (int i = 0; i < (int)a.size(); i++) {
tr[i + b] = single(a[i]);
}
for (int i = b - 1; i > 0; i--) {
tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
}
}
void asign(int lowerBound, const vector<int>& a) {
LB = lowerBound;
for (int i = 0; i < b; i++) {
tr[i + b] = single(i < (int)a.size() ? a[i] : -1);
}
for (int i = b - 1; i > 0; i--) {
tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
}
}
void upd(int i, int v) {
tr[i += b] = single(v);
for (i >>= 1; i > 0; i >>= 1) {
tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
}
}
int qry(int l, int r) {
T ansr = {}, ansl = {};
for (l += b, r += b; l <= r; l >>= 1, r >>= 1) {
if (l & 1) ansl = merge(ansl, tr[l++]);
if (!(r & 1)) ansr = merge(tr[r--], ansr);
}
return merge(ansl, ansr)[0];
}
};
class M_segtree {
private:
using T = int;
int b;
vector<T> tr;
T merge(const T& x, const T& y) { return max(x, y); }
T single(int x = 0) { return x; }
public:
M_segtree() {}
M_segtree(const vector<int>& a) {
b = 1;
while (b < (int)a.size()) {
b <<= 1;
}
tr.assign(2 * b, single());
for (int i = 0; i < (int)a.size(); i++) {
tr[i + b] = single(a[i]);
}
for (int i = b - 1; i > 0; i--) {
tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
}
}
void upd(int i, int v) {
tr[i += b] = single(v);
for (i >>= 1; i > 0; i >>= 1) {
tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
}
}
int qry(int l, int r) {
int ans = 0;
for (l += b, r += b; l <= r; l >>= 1, r >>= 1) {
if (l & 1) ans = max(ans, tr[l++]);
if (!(r & 1)) ans = max(ans, tr[r--]);
}
return ans;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<string> s(n);
vector<int> LN(n, 0);
set<int> Vals;
for (int i = 0; i < n; i++) {
cin >> s[i];
LN[i] = s[i].length();
Vals.insert(LN[i]);
}
auto LCP = [](const string& ss, const string& t) {
for (int i = 0; i < (int)min(ss.length(), t.length()); i++) {
if (ss[i] != t[i]) {
return i;
}
}
return (int)min(ss.length(), t.length());
};
vector<int> OP(q), L(q), R(q), res(q, 0), Lcp(n - 1, 0);
vector<vector<pair<int, int>>> qc(q);
for (int i = 1; i < n; i++) {
Lcp[i - 1] = LCP(s[i - 1], s[i]);
Vals.insert(Lcp[i - 1]);
}
vector<int> lcp = Lcp;
for (int tt = 0; tt < q; tt++) {
cin >> OP[tt];
if (OP[tt] == 1) {
cin >> L[tt] >> R[tt];
--L[tt];
--R[tt];
} else {
string t;
cin >> L[tt] >> t;
--L[tt];
R[tt] = t.length();
Vals.insert(R[tt]);
s[L[tt]] = t;
if (L[tt] > 0) {
lcp[L[tt] - 1] = LCP(s[L[tt] - 1], s[L[tt]]);
qc[tt].emplace_back(L[tt] - 1, lcp[L[tt] - 1]);
Vals.insert(lcp[L[tt] - 1]);
}
if (L[tt] + 1 < n) {
lcp[L[tt]] = LCP(s[L[tt]], s[L[tt] + 1]);
qc[tt].emplace_back(L[tt], lcp[L[tt]]);
Vals.insert(lcp[L[tt]]);
}
}
}
segtree st(INT_MAX, Lcp);
for (int mn : Vals) {
st.asign(mn, Lcp);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
int a = L[tt], b = R[tt];
int& ans = res[tt];
if (a < b) {
int z = st.qry(a, b - 1);
ans = max(ans, mn * (z + (z > 0)));
}
} else {
for (const auto& p : qc[tt]) {
st.upd(p.first, p.second);
}
}
}
}
M_segtree lns(LN);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
cout << max(res[tt], lns.qry(L[tt], R[tt])) << '\n';
} else {
lns.upd(L[tt], R[tt]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wunused-result"
using namespace std;
template <class T>
inline bool chkmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
template <class T, class F = less<T>>
void sort_uniq(vector<T> &v, F f = F()) {
sort(begin(v), end(v), f);
v.resize(unique(begin(v), end(v)) - begin(v));
}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
struct SegTreeRangeAsk {
int n;
vector<T> dat;
template <typename F>
void init(int id, int l, int r, F f) {
if (l == r) {
dat[id] = f(l);
return;
}
int m = (l + r) / 2;
init(id * 2, l, m, f);
init(id * 2 + 1, m + 1, r, f);
dat[id] = dat[id * 2] + dat[id * 2 + 1];
}
template <typename F>
void init(int _n, F f) {
n = _n;
dat.resize(4 * (n + 1));
init(1, 1, n, f);
}
void init(int _n, T *a) {
init(_n, [a](int i) { return a[i]; });
}
void init(int _n, T val) {
init(_n, [val](int) { return val; });
}
T ask(int id, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return dat[id];
int m = (l + r) / 2;
if (qr <= m) return ask(id * 2, l, m, ql, qr);
if (ql > m) return ask(id * 2 + 1, m + 1, r, ql, qr);
T tl = ask(id * 2, l, m, ql, qr);
T tr = ask(id * 2 + 1, m + 1, r, ql, qr);
return tl + tr;
}
T ask(int l, int r) {
assert(l <= r);
return ask(1, 1, n, l, r);
}
void chg(int id, int l, int r, int qx, T qv) {
if (l == r) {
dat[id] = qv;
return;
}
int m = (l + r) / 2;
if (qx <= m)
chg(id * 2, l, m, qx, qv);
else
chg(id * 2 + 1, m + 1, r, qx, qv);
dat[id] = dat[id * 2] + dat[id * 2 + 1];
}
void chg(int qx, T qv) {
assert(1 <= qx && qx <= n);
chg(1, 1, n, qx, qv);
}
};
int lcp(const string &a, const string &b) {
int l = 0;
while (l < ((int)(a).size()) && l < ((int)(b).size()) && a[l] == b[l]) l++;
return l;
}
struct Max {
int x;
Max operator+(const Max &other) { return {max(x, other.x)}; }
};
SegTreeRangeAsk<Max> seg_len;
const int L = 64;
struct Lcp {
int l, r, cl[L], cm[L], cr[L];
int len() const { return r - l + 1; }
int eval() const {
int mx = 0;
for (int i = 0; i < int(L); i++)
if (cm[i]) chkmax(mx, (i + 1) * (cm[i] + 1));
return mx;
}
};
Lcp operator+(const Lcp &a, const Lcp &b) {
Lcp c;
c.l = a.l;
c.r = b.r;
int na = a.len(), nb = b.len();
for (int i = 0; i < int(L); i++) {
c.cl[i] = (a.cl[i] < na ? a.cl[i] : na + b.cl[i]);
c.cr[i] = (b.cr[i] < nb ? b.cr[i] : nb + a.cr[i]);
c.cm[i] = max({a.cm[i], b.cm[i], a.cr[i] + b.cl[i]});
}
return c;
}
SegTreeRangeAsk<Lcp> seg_lcp;
const int N = 1e5 + 10;
int n, m, h[N];
string s[N];
Max gen_max(int i) { return Max{((int)(s[i]).size())}; }
Lcp gen_lcp(int p) {
Lcp x;
x.l = x.r = p;
for (int i = 0; i < int(L); i++) x.cl[i] = x.cm[i] = x.cr[i] = (i < h[p]);
return x;
}
set<int> ls;
int solve_ls(int l, int r) {
vector<int> v;
auto it = ls.lower_bound(l);
while (it != ls.end() && *it <= r) v.push_back(*it++);
vector<int> a;
for (int i = 0; i < int(((int)(v).size())); i++) {
if (i > 0 && v[i] != v[i - 1] + 1) a.push_back(0);
a.push_back(h[v[i]]);
}
a.push_back(0);
int ans = 0;
vector<int> stk;
for (int i = 0; i < int(((int)(a).size())); i++) {
while (!stk.empty() && a[stk.back()] >= a[i]) {
int x = stk.back();
stk.pop_back();
int lb = stk.empty() ? 0 : stk.back() + 1;
int rb = i - 1;
int now = a[x] * (rb - lb + 2);
chkmax(ans, now);
}
stk.push_back(i);
}
return ans;
}
void solve_1() {
while (m--) {
int op;
cin >> op;
if (op == 1) {
int l, r;
cin >> l >> r;
cout << ((int)(s[1]).size()) << '\n';
} else if (op == 2) {
int x;
cin >> x;
cin >> s[x];
} else
assert(0);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = (1); i <= int(n); i++) cin >> s[i];
if (n == 1) {
solve_1();
return 0;
}
for (int i = (1); i <= int(n - 1); i++) h[i] = lcp(s[i], s[i + 1]);
seg_len.init(n, gen_max);
seg_lcp.init(n - 1, gen_lcp);
for (int i = (1); i <= int(n - 1); i++)
if (h[i] > L) ls.insert(i);
while (m--) {
int op;
cin >> op;
if (op == 1) {
int l, r;
cin >> l >> r;
int ans = 0;
auto qlen = seg_len.ask(l, r);
chkmax(ans, qlen.x);
;
if (l < r) {
auto qlcp = seg_lcp.ask(l, r - 1);
chkmax(ans, qlcp.eval());
auto qls = solve_ls(l, r - 1);
chkmax(ans, qls);
;
}
cout << ans << '\n';
} else if (op == 2) {
int x;
cin >> x;
cin >> s[x];
seg_len.chg(x, gen_max(x));
if (x - 1 >= 1) {
h[x - 1] = lcp(s[x - 1], s[x]);
seg_lcp.chg(x - 1, gen_lcp(x - 1));
if (h[x - 1] <= L)
ls.erase(x - 1);
else
ls.insert(x - 1);
}
if (x + 1 <= n) {
h[x] = lcp(s[x], s[x + 1]);
seg_lcp.chg(x, gen_lcp(x));
if (h[x] <= L)
ls.erase(x);
else
ls.insert(x);
}
} else
assert(0);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int B = 30;
char s[maxn];
string a[maxn];
int lcp[maxn];
set<int> st;
int n, q;
int tmp_mx, tmp_suf[B + 1];
struct SegmentTree {
int pre[B + 1][maxn * 2 + 1], suf[B + 1][maxn * 2 + 1];
int mx[maxn * 2 + 1];
inline int getID(int l, int r) { return (l < r) | (l + r); }
inline void update(int t, int l, int r) {
int mid = (l + r) >> 1, lt = getID(l, mid), rt = getID(mid + 1, r);
mx[t] = max(mx[lt], mx[rt]);
for (int i = 1; i <= B; ++i) {
pre[i][t] = pre[i][lt] + (pre[i][lt] == mid - l + 1 ? pre[i][rt] : 0);
suf[i][t] = suf[i][rt] + (suf[i][rt] == r - mid ? suf[i][lt] : 0);
if (suf[i][lt] && pre[i][rt])
mx[t] = max(mx[t], (suf[i][lt] + pre[i][rt] + 1) * i);
}
}
void build(int l, int r) {
int t = getID(l, r);
if (l == r) {
for (int i = 1; i <= B; ++i) pre[i][t] = suf[i][t] = lcp[l] >= i;
mx[t] = max(lcp[l] * 2, (int)a[l].size());
return;
}
int mid = (l + r) >> 1;
build(l, mid), build(mid + 1, r);
update(t, l, r);
}
void modify(int l, int r, int x) {
int t = getID(l, r);
if (l == r) {
for (int i = 1; i <= B; ++i) pre[i][t] = suf[i][t] = lcp[l] >= i;
mx[t] = max(lcp[l] * 2, (int)a[l].size());
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
modify(l, mid, x);
else
modify(mid + 1, r, x);
update(t, l, r);
}
void ask(int l, int r, int x, int y) {
int t = getID(l, r);
if (x <= l && y >= r) {
for (int i = 1; i <= B; ++i) {
if (tmp_suf[i] || pre[i][t])
tmp_mx = max(tmp_mx, (tmp_suf[i] + pre[i][t] + 1) * i);
tmp_suf[i] = suf[i][t] + (suf[i][t] == r - l + 1 ? tmp_suf[i] : 0);
}
tmp_mx = max(tmp_mx, mx[t]);
return;
}
int mid = (l + r) >> 1;
if (x <= mid) ask(l, mid, x, y);
if (y > mid) ask(mid + 1, r, x, y);
}
} tree;
inline int strlcp(string &a, string &b) {
int tmp = 0;
while (tmp < a.size() && tmp < b.size() && a[tmp] == b[tmp]) ++tmp;
return tmp;
}
int work(vector<int> &v) {
int m = v.size();
stack<int> sta;
vector<int> L(m);
for (int i = 0; i < m; ++i) {
while (!sta.empty() && v[i] <= v[sta.top()]) sta.pop();
L[i] = sta.empty() ? -1 : sta.top();
sta.push(i);
}
while (!sta.empty()) sta.pop();
int mx = 0;
for (int i = m - 1; i >= 0; --i) {
while (!sta.empty() && v[i] <= v[sta.top()]) sta.pop();
int R = sta.empty() ? m : sta.top();
mx = max(mx, (R - L[i]) * v[i]);
sta.push(i);
}
return mx;
}
int work(int l, int r) {
auto lt = st.lower_bound(l), rt = st.upper_bound(r);
if (lt == rt) return 0;
vector<int> v;
v.push_back(lcp[*lt]);
int last = *lt, res = 0;
++lt;
while (lt != rt) {
if (*lt != last + 1) res = max(res, work(v)), v.clear();
last = *lt;
v.push_back(lcp[*lt]);
++lt;
}
return max(res, work(v));
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
a[i] = s;
}
for (int i = 1; i <= n - 1; ++i) {
lcp[i] = strlcp(a[i], a[i + 1]);
if (lcp[i] > B) st.insert(i);
}
if (n > 1) tree.build(1, n - 1);
while (q--) {
static int ty, l, r, x;
scanf("%d", &ty);
if (ty == 1) {
scanf("%d%d", &l, &r);
tmp_mx = 0;
memset(tmp_suf, 0, sizeof(tmp_suf));
if (l < r) tree.ask(1, n - 1, l, r - 1);
int ans = max((int)a[r].size(), tmp_mx);
ans = max(ans, work(l, r - 1));
printf("%d\n", ans);
} else {
scanf("%d%s", &x, s);
a[x] = s;
if (x > 1) {
if (lcp[x - 1] > B) st.erase(x - 1);
lcp[x - 1] = strlcp(a[x - 1], a[x]);
tree.modify(1, n - 1, x - 1);
if (lcp[x - 1] > B) st.insert(x - 1);
}
if (x < n) {
if (lcp[x] > B) st.erase(x);
lcp[x] = strlcp(a[x], a[x + 1]);
tree.modify(1, n - 1, x);
if (lcp[x] > B) st.insert(x);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> values;
int get_lcp(const string& a, const string& b) {
int answer = 0;
for (int i = 0; i < (int)min(a.length(), b.length()); i++) {
if (a[i] == b[i]) {
answer++;
} else {
break;
}
}
values.insert(answer);
return answer;
}
int main() {
int n, q;
cin >> n >> q;
vector<pair<int, int>> query(q);
vector<vector<pair<int, int>>> updates(q);
vector<int> answer(q, -1);
vector<string> s(n);
vector<int> lcp(n - 1, -1);
for (int i = 0; i < n; ++i) {
cin >> s[i];
if (i >= 1) {
lcp[i - 1] = get_lcp(s[i - 1], s[i]);
}
}
vector<int> initial_lcp = lcp;
int base = 1;
while (base < n) {
base *= 2;
}
vector<int> big(2 * base);
for (int i = 0; i < n; ++i) {
big[base + i] = s[i].length();
}
for (int i = base - 1; i >= 1; --i) {
big[i] = max(big[2 * i], big[2 * i + 1]);
}
for (int id = 0; id < q; id++) {
int type;
cin >> type;
if (type == 1) {
int a, b;
cin >> a >> b;
a--;
b--;
query[id] = {a, b};
a += base;
b += base;
answer[id] = max({answer[id], big[a], big[b]});
while (a + 1 < b) {
if (a % 2 == 0) {
answer[id] = max(answer[id], big[a + 1]);
}
if (b % 2 == 1) {
answer[id] = max(answer[id], big[b - 1]);
}
a /= 2;
b /= 2;
}
} else {
query[id] = {-1, -1};
assert(type == 2);
int pos;
string y;
cin >> pos >> y;
pos--;
s[pos] = y;
big[base + pos] = y.length();
for (int i = (base + pos) / 2; i >= 1; i /= 2) {
big[i] = max(big[2 * i], big[2 * i + 1]);
}
if (pos >= 1) {
lcp[pos - 1] = get_lcp(s[pos - 1], s[pos]);
updates[id].emplace_back(pos - 1, lcp[pos - 1]);
}
if (pos != n - 1) {
lcp[pos] = get_lcp(s[pos], s[pos + 1]);
updates[id].emplace_back(pos, lcp[pos]);
}
}
}
for (int x : values) {
lcp = initial_lcp;
vector<bool> is_bad(n - 1);
set<int> bad_positions{-1, n - 1};
vector<int> dist(n, 0);
for (int i = 0; i < n - 1; i++) {
is_bad[i] = (lcp[i] < x);
if (is_bad[i]) {
bad_positions.insert(i);
}
}
int prv = n + 5;
for (int i = n - 2; i >= 0; --i) {
if (is_bad[i]) {
dist[i] = prv - i - 1;
prv = i;
}
}
vector<int> tree(2 * base);
for (int i = 0; i < n - 1; ++i) {
tree[base + i] = dist[i];
}
for (int i = base - 1; i >= 1; --i) {
tree[i] = max(tree[2 * i], tree[2 * i + 1]);
}
auto tree_update = [&](int i, int new_value) {
tree[base + i] = new_value;
for (int j = (base + i) / 2; j >= 1; j /= 2) {
tree[j] = max(tree[2 * j], tree[2 * j + 1]);
}
};
for (int id = 0; id < q; id++) {
if (query[id].first != -1) {
int a = query[id].first;
int b = query[id].second;
int first = *bad_positions.lower_bound(a);
int last = *prev(bad_positions.lower_bound(b));
if (0) cerr << "x = " << x << endl;
if (0) cerr << "bad: ";
if (0) cerr << endl;
if (0) cerr << a << " " << b << " " << first << " " << last << endl;
if (0) cerr << first - a << endl;
if (0) cerr << b - 1 - last << endl;
int longest = min(b - a, max({0, first - a, b - 1 - last}));
last--;
if (first <= last) {
first += base;
last += base;
longest = max({longest, tree[first], tree[last]});
while (first + 1 < last) {
if (first % 2 == 0) {
longest = max(longest, tree[first + 1]);
}
if (last % 2 == 1) {
longest = max(longest, tree[last - 1]);
}
first /= 2;
last /= 2;
}
}
if (longest != 0) {
if (0) cerr << "l = " << longest << endl;
answer[id] = max(answer[id], (longest + 1) * x);
}
} else {
for (pair<int, int> upd : updates[id]) {
int pos = upd.first;
int new_value = upd.second;
if ((lcp[pos] < x) != (new_value < x)) {
is_bad[pos] = !is_bad[pos];
if (is_bad[pos]) {
auto it = bad_positions.insert(pos).first;
tree_update(pos, *next(it) - pos - 1);
int left = *prev(it);
if (left != -1) {
tree_update(left, pos - left - 1);
}
} else {
auto it = bad_positions.find(pos);
assert(it != bad_positions.end());
int left = *prev(it);
if (left != -1) {
tree_update(left, *next(it) - left - 1);
}
tree_update(pos, 0);
bad_positions.erase(it);
}
}
lcp[pos] = new_value;
}
}
}
}
for (int id = 0; id < q; ++id) {
if (answer[id] != -1) {
cout << answer[id] << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N], l[N], r[N], t[N], id[N], mark[N], mx[N << 2], n, q, x;
long long ans[N];
string s[N], S[N], que[N];
vector<int> vec;
void SET(int l, int r, int val, int L = 0, int R = n, int id = 1) {
if (r <= L || R <= l) return;
if (l <= L && R <= r) {
mx[id] = val;
return;
}
SET(l, r, val, L, (L + R) >> 1, id << 1);
SET(l, r, val, (L + R) >> 1, R, id << 1 | 1);
mx[id] = max(mx[id << 1], mx[id << 1 | 1]);
return;
}
int GET(int l, int r, int L = 0, int R = n, int id = 1) {
if (r <= L || R <= l) return 0;
if (l <= L && R <= r) return mx[id];
int x1 = GET(l, r, L, (L + R) >> 1, id << 1);
int x2 = GET(l, r, (L + R) >> 1, R, id << 1 | 1);
return max(x1, x2);
}
struct Node {
int Max = 0, pref = 0, suff = 0, full = 0;
} seg[N << 2], Null;
Node Merge(Node &x, Node &y) {
Node res;
res.pref = x.pref + (x.full ? y.pref : 0);
res.suff = y.suff + (y.full ? x.suff : 0);
res.full = x.full && y.full;
res.Max = max(x.suff + y.pref, max(x.Max, y.Max));
return res;
}
void Set(int l, int r, int val, int L = 0, int R = n - 1, int id = 1) {
if (r <= L || R <= l) return;
if (l <= L && R <= r) {
seg[id].Max = seg[id].pref = seg[id].suff = seg[id].full = val;
return;
}
Set(l, r, val, L, (L + R) >> 1, id << 1);
Set(l, r, val, (L + R) >> 1, R, id << 1 | 1);
seg[id] = Merge(seg[id << 1], seg[id << 1 | 1]);
return;
}
Node Get(int l, int r, int L = 0, int R = n - 1, int id = 1) {
if (r <= L || R <= l) return Null;
if (l <= L && R <= r) return seg[id];
Node x1 = Get(l, r, L, (L + R) >> 1, id << 1);
Node x2 = Get(l, r, (L + R) >> 1, R, id << 1 | 1);
return Merge(x1, x2);
}
int LCP(string &s, string &t) {
int res = 0;
while (res < s.size() && res < t.size() && s[res] == t[res]) res++;
return res;
}
void Init() {
for (int i = 0; i < n; i++) s[i] = S[i];
for (int i = 0; i < n - 1; i++) {
a[i] = LCP(s[i], s[i + 1]);
if (a[i] >= x)
Set(i, i + 1, 1);
else
Set(i, i + 1, 0);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> q;
for (int i = 0; i < n; i++)
cin >> S[i], s[i] = S[i], SET(i, i + 1, S[i].size());
for (int i = 0; i < n - 1; i++) {
a[i] = LCP(s[i], s[i + 1]);
if (!mark[a[i]]) {
vec.push_back(a[i]);
mark[a[i]] = 1;
}
}
for (int i = 0; i < q; i++) {
cin >> t[i];
if (t[i] == 1) {
cin >> l[i] >> r[i];
l[i]--;
ans[i] = GET(l[i], r[i]);
r[i]--;
}
if (t[i] == 2) {
cin >> id[i] >> que[i], id[i]--;
s[id[i]] = que[i];
SET(id[i], id[i] + 1, que[i].size());
if (id[i] - 1 >= 0) {
a[id[i] - 1] = LCP(s[id[i] - 1], s[id[i]]);
if (!mark[a[id[i] - 1]]) {
mark[a[id[i] - 1]] = 1;
vec.push_back(a[id[i] - 1]);
}
}
if (id[i] + 1 < n) {
a[id[i]] = LCP(s[id[i]], s[id[i] + 1]);
if (!mark[a[id[i]]]) {
mark[a[id[i]]] = 1;
vec.push_back(a[id[i]]);
}
}
}
}
for (int _ = 0; _ < vec.size(); _++) {
x = vec[_];
Init();
for (int i = 0; i < q; i++) {
if (t[i] == 1) {
int A = Get(l[i], r[i]).Max;
if (A != 0) ans[i] = max(ans[i], (A + 1ll) * (x + 0ll));
}
if (t[i] == 2) {
s[id[i]] = que[i];
if (id[i] - 1 >= 0) {
a[id[i] - 1] = LCP(s[id[i] - 1], s[id[i]]);
if (a[id[i] - 1] >= x)
Set(id[i] - 1, id[i], 1);
else
Set(id[i] - 1, id[i], 0);
}
if (id[i] + 1 < n) {
a[id[i]] = LCP(s[id[i]], s[id[i] + 1]);
if (a[id[i]] >= x)
Set(id[i], id[i] + 1, 1);
else
Set(id[i], id[i] + 1, 0);
}
}
}
}
for (int i = 0; i < q; i++)
if (t[i] == 1) cout << ans[i] << " ";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int B = 80;
char s[maxn];
string a[maxn];
int lcp[maxn];
set<int> st;
int n, q;
int tmp_mx, tmp_suf[B + 1];
struct SegmentTree {
int pre[B + 1][maxn * 2 + 1], suf[B + 1][maxn * 2 + 1];
int mx[maxn * 2 + 1];
inline int getID(int l, int r) { return (l < r) | (l + r); }
inline void update(int t, int l, int r) {
int mid = (l + r) >> 1, lt = getID(l, mid), rt = getID(mid + 1, r);
mx[t] = max(mx[lt], mx[rt]);
for (int i = 1; i <= B; ++i) {
pre[i][t] = pre[i][lt] + (pre[i][lt] == mid - l + 1 ? pre[i][rt] : 0);
suf[i][t] = suf[i][rt] + (suf[i][rt] == r - mid ? suf[i][lt] : 0);
if (suf[i][lt] && pre[i][rt])
mx[t] = max(mx[t], (suf[i][lt] + pre[i][rt] + 1) * i);
}
}
void build(int l, int r) {
int t = getID(l, r);
if (l == r) {
for (int i = 1; i <= B; ++i) pre[i][t] = suf[i][t] = lcp[l] >= i;
mx[t] = max(lcp[l] * 2, (int)a[l].size());
return;
}
int mid = (l + r) >> 1;
build(l, mid), build(mid + 1, r);
update(t, l, r);
}
void modify(int l, int r, int x) {
int t = getID(l, r);
if (l == r) {
for (int i = 1; i <= B; ++i) pre[i][t] = suf[i][t] = lcp[l] >= i;
mx[t] = max(lcp[l] * 2, (int)a[l].size());
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
modify(l, mid, x);
else
modify(mid + 1, r, x);
update(t, l, r);
}
void ask(int l, int r, int x, int y) {
int t = getID(l, r);
if (x <= l && y >= r) {
for (int i = 1; i <= B; ++i) {
if (tmp_suf[i] || pre[i][t])
tmp_mx = max(tmp_mx, (tmp_suf[i] + pre[i][t] + 1) * i);
tmp_suf[i] = suf[i][t] + (suf[i][t] == r - l + 1 ? tmp_suf[i] : 0);
}
tmp_mx = max(tmp_mx, mx[t]);
return;
}
int mid = (l + r) >> 1;
if (x <= mid) ask(l, mid, x, y);
if (y > mid) ask(mid + 1, r, x, y);
}
} tree;
inline int strlcp(string &a, string &b) {
int tmp = 0;
while (tmp < a.size() && tmp < b.size() && a[tmp] == b[tmp]) ++tmp;
return tmp;
}
int work(vector<int> &v) {
int m = v.size();
stack<int> sta;
vector<int> L(m);
for (int i = 0; i < m; ++i) {
while (!sta.empty() && v[i] <= v[sta.top()]) sta.pop();
L[i] = sta.empty() ? -1 : sta.top();
sta.push(i);
}
while (!sta.empty()) sta.pop();
int mx = 0;
for (int i = m - 1; i >= 0; --i) {
while (!sta.empty() && v[i] <= v[sta.top()]) sta.pop();
int R = sta.empty() ? m : sta.top();
mx = max(mx, (R - L[i]) * v[i]);
sta.push(i);
}
return mx;
}
int work(int l, int r) {
auto lt = st.lower_bound(l), rt = st.upper_bound(r);
if (lt == rt) return 0;
vector<int> v;
v.push_back(lcp[*lt]);
int last = *lt, res = 0;
++lt;
while (lt != rt) {
if (*lt != last + 1) res = max(res, work(v)), v.clear();
last = *lt;
v.push_back(lcp[*lt]);
++lt;
}
return max(res, work(v));
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
a[i] = s;
}
for (int i = 1; i <= n - 1; ++i) {
lcp[i] = strlcp(a[i], a[i + 1]);
if (lcp[i] > B) st.insert(i);
}
if (n > 1) tree.build(1, n - 1);
while (q--) {
static int ty, l, r, x;
scanf("%d", &ty);
if (ty == 1) {
scanf("%d%d", &l, &r);
tmp_mx = 0;
memset(tmp_suf, 0, sizeof(tmp_suf));
if (l < r) tree.ask(1, n - 1, l, r - 1);
int ans = max((int)a[r].size(), tmp_mx);
ans = max(ans, work(l, r - 1));
printf("%d\n", ans);
} else {
scanf("%d%s", &x, s);
a[x] = s;
if (x > 1) {
if (lcp[x - 1] > B) st.erase(x - 1);
lcp[x - 1] = strlcp(a[x - 1], a[x]);
tree.modify(1, n - 1, x - 1);
if (lcp[x - 1] > B) st.insert(x - 1);
}
if (x < n) {
if (lcp[x] > B) st.erase(x);
lcp[x] = strlcp(a[x], a[x + 1]);
tree.modify(1, n - 1, x);
if (lcp[x] > B) st.insert(x);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const int MAXN = 100005;
struct tree1 {
private:
int mx;
int l;
int r;
tree1 *lson;
tree1 *rson;
public:
tree1() {
mx = 0;
lson = rson = NULL;
}
void build(int L, int R) {
l = L;
r = R;
if (l == r) return;
lson = new tree1;
rson = new tree1;
int mid = (l + r) / 2;
lson->build(l, mid);
rson->build(mid + 1, r);
}
void modify(int id, int k) {
if (l == r) {
mx = k;
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
mx = max(lson->mx, rson->mx);
}
int query(int L, int R) {
if (l >= L && r <= R) return mx;
int mid = (l + r) / 2;
if (R <= mid) return lson->query(L, R);
if (L > mid) return rson->query(L, R);
return max(lson->query(L, R), rson->query(L, R));
}
};
struct line {
int k;
int b;
line(int K = 0, int B = 0) {
k = K;
b = B;
}
int calc(int x) { return k * x + b; }
double cross(line t) { return (double)(t.b - b) / (k - t.k); }
};
struct tree {
bool tag;
int l;
int r;
line *L;
int cnt;
line *R;
int rcnt;
int mx;
tree *lson;
tree *rson;
tree() {
tag = false;
L = R = NULL;
cnt = rcnt = mx = 0;
lson = rson = NULL;
}
void fixup() {
static line tmp[MAXN];
l = lson->l;
r = rson->r;
if (L) delete L;
L = new line[lson->cnt + rson->cnt];
cnt = lson->cnt;
for (int i = 0; i < cnt; i++) L[i] = lson->L[i];
for (int i = 0; i < rson->cnt; i++) {
if (rson->L[i].k >= L[cnt - 1].k)
L[cnt - 1].b = (lson->r - lson->l + 1) + rson->L[i].b;
else {
L[cnt++] = rson->L[i];
L[cnt - 1].b += (lson->r - lson->l + 1);
}
}
if (R) delete R;
R = new line[lson->rcnt + rson->rcnt];
rcnt = rson->rcnt;
for (int i = 0; i < rcnt; i++) R[i] = rson->R[i];
for (int i = 0; i < lson->rcnt; i++) {
if (lson->R[i].k >= R[rcnt - 1].k)
R[rcnt - 1].b = (rson->r - rson->l + 1) + lson->R[i].b;
else {
R[rcnt++] = lson->R[i];
R[rcnt - 1].b += (rson->r - rson->l + 1);
}
}
mx = max(lson->mx, rson->mx);
int cur = 0, p = 0, s = 0;
memset(tmp, 0, sizeof(line) * rson->cnt);
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
for (int i = 0; i < lson->rcnt; i++) {
while (cur < rson->cnt && rson->L[cur].k < lson->R[i].k) {
line t = rson->L[cur++];
t.b = (t.b + 1) * t.k;
while (s > 1 && tmp[s - 2].cross(t) < tmp[s - 2].cross(tmp[s - 1])) s--;
if (p >= s) p = max(s - 1, 0);
tmp[s++] = t;
}
while (p < s - 1 &&
tmp[p].calc(lson->R[i].b) < tmp[p + 1].calc(lson->R[i].b))
p++;
while (p && tmp[p].calc(lson->R[i].b) < tmp[p - 1].calc(lson->R[i].b))
p--;
if (cur < rson->cnt)
mx = max(mx, (lson->R[i].b + rson->L[cur].b + 1) * lson->R[i].k);
mx = max(mx, tmp[p].calc(lson->R[i].b));
}
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
}
void build(int rL, int rR, int *a) {
tag = true;
l = rL;
r = rR;
if (l == r) {
mx = a[l] * 2;
L = new line[1];
R = new line[1];
cnt = rcnt = 1;
L[0] = R[0] = line(a[l], 1);
return;
}
int mid = (l + r) / 2;
lson = new tree;
rson = new tree;
lson->build(l, mid, a);
rson->build(mid + 1, r, a);
fixup();
}
void modify(int id, int k) {
if (l == r) {
mx = k * 2;
L[0] = R[0] = line(k, 1);
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
fixup();
}
tree *query(int rL, int rR) {
if (l >= rL && r <= rR) return this;
int mid = (l + r) / 2;
if (rR <= mid) return lson->query(rL, rR);
if (rL > mid) return rson->query(rL, rR);
tree *temp = new tree;
temp->lson = lson->query(rL, rR);
temp->rson = rson->query(rL, rR);
temp->fixup();
return temp;
}
void query_clear() {
if (tag) return;
lson->query_clear();
rson->query_clear();
if (L) delete L;
if (R) delete R;
}
};
void print(int *a, int n) {
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
int N, q;
tree1 T1;
tree T;
char *s[MAXN], str[MAXN];
int len[MAXN], lcp[MAXN];
void init() {
scanf("%d %d", &N, &q);
T1.build(1, N);
for (int i = 1; i <= N; i++) {
scanf("%s", str);
len[i] = strlen(str);
s[i] = new char[len[i]];
memcpy(s[i], str, sizeof(char) * len[i]);
T1.modify(i, len[i]);
}
for (int i = 1; i < N; i++) {
int t = 0;
while (t < len[i] && t < len[i + 1] && s[i][t] == s[i + 1][t]) t++;
lcp[i] = t;
}
if (N > 1) T.build(1, N - 1, lcp);
}
int main() {
int ty, x, y;
init();
for (int i = 0; i < q; i++) {
scanf("%d %d", &ty, &x);
if (ty == 1) {
scanf("%d", &y);
int ans = T1.query(x, y);
if (x == y) {
printf("%d\n", ans);
continue;
}
tree *p = T.query(x, y - 1);
ans = max(ans, p->mx);
p->query_clear();
if (!p->l && !p->r) delete p;
std::cout << ans << std::endl;
} else {
scanf("%s", str);
len[x] = strlen(str);
s[x] = new char[len[x]];
memcpy(s[x], str, sizeof(char) * len[x]);
T1.modify(x, len[x]);
int t = 0;
if (x > 1) {
for (t = 0; t < len[x - 1] && t < len[x] && s[x - 1][t] == s[x][t]; t++)
;
lcp[x - 1] = t;
T.modify(x - 1, t);
}
if (x < N) {
for (t = 0; t < len[x] && t < len[x + 1] && s[x][t] == s[x + 1][t]; t++)
;
lcp[x] = t;
T.modify(x, t);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T = int>
struct Max {
T val;
const T nut = numeric_limits<T>::min();
Max() { val = nut; }
Max(const T& _val) { val = _val; }
void operator=(const Max& o) { val = o.val; }
Max operator+(const Max& o) const { return val > o.val ? val : o.val; }
};
template <typename T = long long>
struct subl {
T mx, ml, ps, pl, ss, sl, sm, ln;
subl() {
mx = 0;
ml = 0;
ps = 0;
pl = 0;
ss = 0;
sl = 0;
sm = 0;
ln = 0;
}
subl(const T& v) {
mx = v;
ml = 1;
ps = v;
pl = 1;
ss = v;
sl = 1;
sm = v;
ln = 1;
}
subl(T _mx, T _ml, T _ps, T _pl, T _ss, T _sl, T _sm, T _ln) {
mx = _mx;
ml = _ml;
ps = _ps;
pl = _pl;
ss = _ss;
sl = _sl;
sm = _sm;
ln = _ln;
}
void operator=(const subl& o) {
mx = o.mx;
ml = o.ml;
ps = o.ps;
pl = o.pl;
ss = o.ss;
sl = o.sl;
sm = o.sm;
ln = o.ln;
}
subl operator+(const subl& o) const {
return subl(
max({mx, o.mx, ss + o.ps}),
max({pair<T, T>(ss + o.ps, sl + o.pl), pair<T, T>(mx, ml),
pair<T, T>(o.mx, o.ml)})
.second,
max(ps, sm + o.ps),
max(pair<T, T>(ps, pl), pair<T, T>(sm + o.ps, ln + o.pl)).second,
max(ss + o.sm, o.ss),
max(pair<T, T>(o.ss, o.sl), pair<T, T>(ss + o.sm, sl + o.ln)).second,
sm + o.sm, ln + o.ln);
}
};
template <typename T, typename T2 = int>
class segtree {
private:
int b;
vector<T> tr;
public:
segtree() {}
segtree(int n) {
b = 1;
while (b < n) {
b <<= 1;
}
tr.assign(2 * b, T());
}
segtree(const vector<T2>& arr) {
b = 1;
while (b < (int)arr.size()) {
b <<= 1;
}
tr.assign(2 * b, T());
for (int i = 0; i < (int)arr.size(); i++) {
tr[i + b] = T(arr[i]);
}
for (int i = b - 1; i > 0; i--) {
tr[i] = tr[i << 1] + tr[i << 1 | 1];
}
}
void upd(int i, const T2& val) {
tr[i += b] = T(val);
for (i >>= 1; i > 0; i >>= 1) {
tr[i] = tr[i << 1] + tr[i << 1 | 1];
}
}
T qry(int l, int r) {
T ansl = T(), ansr = T();
for (l += b, r += b; l <= r; l >>= 1, r >>= 1) {
if (l & 1) ansl = ansl + tr[l++];
if (!(r & 1)) ansr = tr[r--] + ansr;
}
return ansl + ansr;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<string> s(n);
vector<int> LN(n, 0);
set<int> Vals;
for (int i = 0; i < n; i++) {
cin >> s[i];
LN[i] = s[i].length();
}
auto LCP = [&](const string& ss, const string& t) {
int ans = 0;
for (int i = 0; i < (int)min(ss.length(), t.length()); i++) {
if (ss[i] == t[i]) {
ans++;
} else {
break;
}
}
Vals.insert(ans);
return ans;
};
vector<int> OP(q), L(q), R(q), res(q, 0), Lcp(n - 1, 0);
vector<vector<pair<int, int>>> qc(q);
for (int i = 1; i < n; i++) {
Lcp[i - 1] = LCP(s[i - 1], s[i]);
}
for (int tt = 0; tt < q; tt++) {
cin >> OP[tt];
if (OP[tt] == 1) {
cin >> L[tt] >> R[tt];
--L[tt];
--R[tt];
} else {
cin >> L[tt];
--L[tt];
cin >> s[L[tt]];
R[tt] = s[L[tt]].length();
if (L[tt] > 0) {
qc[tt].emplace_back(L[tt] - 1, LCP(s[L[tt] - 1], s[L[tt]]));
}
if (L[tt] + 1 < n) {
qc[tt].emplace_back(L[tt], LCP(s[L[tt]], s[L[tt] + 1]));
}
}
}
const int inf = 1e9;
for (int mn : Vals) {
vector<int> bad(n - 1);
for (int i = 0; i < n - 1; i++) {
bad[i] = (Lcp[i] >= mn ? 1 : -inf);
}
segtree<subl<long long>, int> st(bad);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
int a = L[tt], b = R[tt];
int& ans = res[tt];
if (a < b) {
int z = st.qry(a, b - 1).ml;
ans = max(ans, mn * (z + (z > 0)));
}
} else {
for (const auto& p : qc[tt]) {
st.upd(p.first, p.second >= mn ? 1 : -inf);
}
}
}
}
segtree<Max<int>, int> lns(LN);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
cout << max(res[tt], lns.qry(L[tt], R[tt]).val) << '\n';
} else {
lns.upd(L[tt], R[tt]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
string s[maxn];
int lca[maxn];
struct node {
int ans;
vector<pair<int, int> > L, R;
} nodes[maxn << 2];
node merge(const node &L, const node &R, int m) {
node res;
res.ans = max(L.ans, R.ans);
for (auto i = L.R.end() - 1, j = R.L.end() - 1; i >= L.R.begin(); i--) {
while (j > R.L.begin() && j->first < i->first) j--;
if (j->first < i->first) break;
res.ans = max(res.ans, (j->second - i->second + 1) * min(lca[m], i->first));
if (i == L.R.begin()) break;
}
for (auto i = R.L.end() - 1, j = L.R.end() - 1; i >= R.L.begin(); i--) {
while (j > L.R.begin() && j->first < i->first) j--;
if (j->first < i->first) break;
res.ans = max(res.ans, (i->second - j->second + 1) * min(lca[m], i->first));
if (i == R.L.begin()) break;
}
res.L = L.L;
for (auto i : R.L) {
i.first = min(lca[m], i.first);
if (i.first >= res.L.back().first)
res.L.back().second = i.second;
else
res.L.push_back(i);
}
res.R = R.R;
for (auto i : L.R) {
i.first = min(lca[m], i.first);
if (i.first >= res.R.back().first)
res.R.back().second = i.second;
else
res.R.push_back(i);
}
return res;
}
void build(int p, int l, int r) {
if (l == r) {
nodes[p].ans = s[l].size();
nodes[p].L = nodes[p].R = {{s[l].size(), l}};
return;
}
int mid = l + r >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
nodes[p] = merge(nodes[p << 1], nodes[p << 1 | 1], mid);
}
void update(int p, int l, int r, int c) {
if (l == r) {
nodes[p].ans = s[c].size();
nodes[p].L = nodes[p].R = {{s[c].size(), c}};
return;
}
int mid = l + r >> 1;
if (c <= mid)
update(p << 1, l, mid, c);
else
update(p << 1 | 1, mid + 1, r, c);
nodes[p] = merge(nodes[p << 1], nodes[p << 1 | 1], mid);
}
node G(int p, int L, int R, int l, int r) {
if (L <= l && r <= R) return nodes[p];
int mid = l + r >> 1;
if (R <= mid)
return G(p << 1, L, R, l, mid);
else if (L > mid)
return G(p << 1 | 1, L, R, mid + 1, r);
else
return merge(G(p << 1, L, mid, l, mid),
G(p << 1 | 1, mid + 1, R, mid + 1, r), mid);
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i < n; i++)
while (lca[i] < s[i].size() && s[i][lca[i]] == s[i + 1][lca[i]]) lca[i]++;
build(1, 1, n);
int c;
for (int i = 1; i <= q; i++) {
scanf("%d", &c);
if (c == 1) {
int a, b;
scanf("%d%d", &a, &b);
printf("%d\n", G(1, a, b, 1, n).ans);
} else {
int x;
string y;
scanf("%d", &x);
cin >> y;
s[x] = y;
if (x > 1) {
lca[x - 1] = 0;
while (lca[x - 1] < s[x - 1].size() &&
s[x - 1][lca[x - 1]] == s[x][lca[x - 1]])
lca[x - 1]++;
update(1, 1, n, x - 1);
}
if (x < n) {
lca[x] = 0;
while (lca[x] < s[x].size() && s[x][lca[x]] == s[x + 1][lca[x]])
lca[x]++;
update(1, 1, n, x);
}
update(1, 1, n, x);
}
}
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const int MAXN = 100005;
const int B = 100;
struct tree1 {
private:
int mx;
int l;
int r;
tree1 *lson;
tree1 *rson;
public:
tree1() {
mx = 0;
lson = rson = NULL;
}
void build(int L, int R) {
l = L;
r = R;
if (l == r) return;
lson = new tree1;
rson = new tree1;
int mid = (l + r) / 2;
lson->build(l, mid);
rson->build(mid + 1, r);
}
void modify(int id, int k) {
if (l == r) {
mx = k;
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
mx = max(lson->mx, rson->mx);
}
int query(int L, int R) {
if (l >= L && r <= R) return mx;
int mid = (l + r) / 2;
if (R <= mid) return lson->query(L, R);
if (L > mid) return rson->query(L, R);
return max(lson->query(L, R), rson->query(L, R));
}
};
struct line {
int k;
int b;
line(int K = 0, int B = 0) {
k = K;
b = B;
}
int calc(int x) { return k * x + b; }
double cross(line t) { return (double)(t.b - b) / (k - t.k); }
};
struct tree {
bool tag;
int l;
int r;
line *L;
int cnt;
line *R;
int rcnt;
int mx;
tree *lson;
tree *rson;
tree() {
tag = false;
L = R = NULL;
cnt = rcnt = mx = 0;
lson = rson = NULL;
}
void fixup() {
static line tmp[MAXN];
l = lson->l;
r = rson->r;
if (L) delete L;
L = new line[lson->cnt + rson->cnt];
cnt = lson->cnt;
for (int i = 0; i < cnt; i++) L[i] = lson->L[i];
for (int i = 0; i < rson->cnt; i++) {
if (rson->L[i].k >= L[cnt - 1].k)
L[cnt - 1].b = (lson->r - lson->l + 1) + rson->L[i].b;
else {
L[cnt++] = rson->L[i];
L[cnt - 1].b += (lson->r - lson->l + 1);
}
}
if (R) delete R;
R = new line[lson->rcnt + rson->rcnt];
rcnt = rson->rcnt;
for (int i = 0; i < rcnt; i++) R[i] = rson->R[i];
for (int i = 0; i < lson->rcnt; i++) {
if (lson->R[i].k >= R[rcnt - 1].k)
R[rcnt - 1].b = (rson->r - rson->l + 1) + lson->R[i].b;
else {
R[rcnt++] = lson->R[i];
R[rcnt - 1].b += (rson->r - rson->l + 1);
}
}
mx = max(lson->mx, rson->mx);
int cur = 0, p = 0, s = 0;
memset(tmp, 0, sizeof(line) * rson->cnt);
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
for (int i = 0; i < lson->rcnt; i++) {
while (cur < rson->cnt && rson->L[cur].k < lson->R[i].k) {
line t = rson->L[cur++];
t.b = (t.b + 1) * t.k;
while (s > 1 && tmp[s - 2].cross(t) < tmp[s - 2].cross(tmp[s - 1])) s--;
if (p >= s) p = max(s - 1, 0);
tmp[s++] = t;
}
while (p < s - 1 &&
tmp[p].calc(lson->R[i].b) < tmp[p + 1].calc(lson->R[i].b))
p++;
if (cur < rson->cnt)
mx = max(mx, (lson->R[i].b + rson->L[cur].b + 1) * lson->R[i].k);
mx = max(mx, tmp[p].calc(lson->R[i].b));
}
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
}
void build(int rL, int rR, int *a) {
tag = true;
l = rL;
r = rR;
if (l == r) {
mx = a[l] * 2;
L = new line[1];
R = new line[1];
cnt = rcnt = 1;
L[0] = R[0] = line(a[l], 1);
return;
}
int mid = (l + r) / 2;
lson = new tree;
rson = new tree;
lson->build(l, mid, a);
rson->build(mid + 1, r, a);
fixup();
}
void modify(int id, int k) {
if (l == r) {
mx = k * 2;
L[0] = R[0] = line(k, 1);
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
fixup();
}
tree *query(int rL, int rR) {
if (l >= rL && r <= rR) return this;
int mid = (l + r) / 2;
if (rR <= mid) return lson->query(rL, rR);
if (rL > mid) return rson->query(rL, rR);
tree *temp = new tree;
temp->lson = lson->query(rL, rR);
temp->rson = rson->query(rL, rR);
temp->fixup();
return temp;
}
void query_clear() {
if (tag) return;
lson->query_clear();
rson->query_clear();
if (L) delete L;
if (R) delete R;
}
void print() {
printf("-----------------------------------------------------\n");
printf("tag: %d\n", tag);
printf("l: %d r: %d\n", l, r);
printf("mx: %d\n", mx);
printf("cnt %d :", cnt);
for (int i = 0; i < cnt; i++) printf("(%d %d) ", L[i].k, L[i].b);
printf("\n");
printf("rcnt %d :", rcnt);
for (int i = 0; i < rcnt; i++) printf("(%d %d) ", R[i].k, R[i].b);
printf("\n");
printf("-----------------------------------------------------\n");
}
};
void print(int *a, int n) {
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
int N, q;
tree1 T1;
tree T;
char *s[MAXN], str[MAXN];
int len[MAXN], lcp[MAXN];
void init() {
scanf("%d %d", &N, &q);
T1.build(1, N);
for (int i = 1; i <= N; i++) {
scanf("%s", str);
len[i] = strlen(str);
s[i] = new char[len[i]];
memcpy(s[i], str, sizeof(char) * len[i]);
T1.modify(i, len[i]);
}
for (int i = 1; i < N; i++) {
int t = 0;
while (t < len[i] && t < len[i + 1] && s[i][t] == s[i + 1][t]) t++;
lcp[i] = t;
}
if (N > 1) T.build(1, N - 1, lcp);
}
int main() {
int ty, x, y;
init();
for (int i = 0; i < q; i++) {
scanf("%d %d", &ty, &x);
if (ty == 1) {
scanf("%d", &y);
int ans = T1.query(x, y);
if (x == y) {
printf("%d\n", ans);
continue;
}
tree *p = T.query(x, y - 1);
ans = max(ans, p->mx);
p->query_clear();
if (!p->l && !p->r) delete p;
std::cout << ans << std::endl;
} else {
scanf("%s", str);
len[x] = strlen(str);
s[x] = new char[len[x]];
memcpy(s[x], str, sizeof(char) * len[x]);
T1.modify(x, len[x]);
int t = 0;
if (x > 1) {
for (t = 0; t < len[x - 1] && t < len[x] && s[x - 1][t] == s[x][t]; t++)
;
lcp[x - 1] = t;
T.modify(x - 1, t);
}
if (x < N) {
for (t = 0; t < len[x] && t < len[x + 1] && s[x][t] == s[x + 1][t]; t++)
;
lcp[x] = t;
T.modify(x, t);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[700000];
int Max[700000], L[700000], R[700000], ls[700000], rs[700000], root[700000],
tot = 0, lcp[700000], n, last[700000], a[700000], sta[700000], tmp[700000];
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
vector<int> vec[700000];
namespace Tree {
int mx[700000];
inline void update(int l, int r, int x, int p) {
if (l == r) {
mx[x] = vec[p].size();
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
update(l, mid, x << 1, p);
else
update(mid + 1, r, x << 1 | 1, p);
mx[x] = max(mx[x << 1], mx[x << 1 | 1]);
}
inline int query(int l, int r, int x, int ll, int rr) {
if (ll <= l && r <= rr) return mx[x];
int mid = (l + r) >> 1, res = 0;
if (ll <= mid) res = max(res, query(l, mid, x << 1, ll, rr));
if (rr > mid) res = max(res, query(mid + 1, r, x << 1 | 1, ll, rr));
return res;
}
}; // namespace Tree
inline int find(int x) {
int i;
for (i = 0; i < min(vec[x].size(), vec[x - 1].size()); ++i)
if (vec[x][i] != vec[x - 1][i]) return i;
return min(vec[x].size(), vec[x - 1].size());
}
inline void pushup(int x, int l, int r) {
int mid = (l + r) >> 1;
Max[x] = max(R[ls[x]] + L[rs[x]], max(Max[ls[x]], Max[rs[x]]));
L[x] = L[ls[x]], R[x] = R[rs[x]];
if (L[ls[x]] == (mid - l + 1)) L[x] += L[rs[x]];
if (R[rs[x]] == (r - mid)) R[x] += R[ls[x]];
}
inline void update(int &x, int l, int r, int p, int opt) {
if (!x) x = ++tot;
if (l == r) {
Max[x] = L[x] = R[x] = opt;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
update(ls[x], l, mid, p, opt);
else
update(rs[x], mid + 1, r, p, opt);
pushup(x, l, r);
}
inline void modify(int x, int opt) {
int i, p = 0;
if (lcp[x] <= 70) {
for (i = 1; i <= lcp[x]; ++i) update(root[i], 1, n, x, opt);
} else if (!opt) {
for (i = 1; i <= 70; ++i) update(root[i], 1, n, x, 0);
p = 0;
while (last[p] != x) p = last[p];
last[p] = last[x], last[x] = 0;
} else {
for (i = 1; i <= 70; ++i) update(root[i], 1, n, x, 1);
p = 0;
while (last[p] && last[p] < x) p = last[p];
last[x] = last[p], last[p] = x;
}
}
inline int query(int x, int l, int r, int ll, int rr) {
if (!x) return 0;
if (ll <= l && r <= rr) return Max[x];
int mid = (l + r) >> 1, res = 0;
if (ll <= mid) res = max(res, query(ls[x], l, mid, ll, rr));
if (rr > mid) res = max(res, query(rs[x], mid + 1, r, ll, rr));
if (ll <= mid && rr > mid)
res = max(res, min(R[ls[x]], mid - ll + 1) + min(L[rs[x]], rr - mid));
return res;
}
inline int solve(int l, int r) {
int p = 0, num = 0, top = 0, i, res = 0;
while (last[p]) p = last[p], a[++num] = p, num -= (p < l || p > r);
sta[0] = a[1] - 1;
for (i = 1; i <= num; ++i) {
if (top && a[i] != sta[top] + 1) top = 0, sta[0] = a[i] - 1;
while (top && lcp[a[i]] <= lcp[sta[top]]) --top;
tmp[i] = sta[top], sta[++top] = a[i];
}
top = 0, sta[0] = a[num] + 1;
for (i = num; i; --i) {
if (top && a[i] != sta[top] - 1) top = 0, sta[0] = a[i] + 1;
while (top && lcp[a[i]] <= lcp[sta[top]]) --top;
res = max(res, lcp[a[i]] * (sta[top] - tmp[i]));
sta[++top] = a[i];
}
return res;
}
int main() {
int q, lens, l, r, j, i, opt, w, ans = 0, x;
n = read(), q = read();
for (i = 1; i <= n; ++i) {
scanf("%s", str + 1), lens = strlen(str + 1);
for (j = 1; j <= lens; ++j) vec[i].push_back(str[j] - 'a');
Tree::update(1, n, 1, i);
lcp[i] = find(i);
modify(i, 1);
}
while (q--) {
opt = read();
if (opt == 1) {
l = read(), r = read();
ans = Tree::query(1, n, 1, l, r);
if (l == r) {
printf("%d\n", ans);
continue;
}
for (i = 1; i <= 70; ++i)
w = query(root[i], 1, n, l + 1, r),
ans = max(ans, i * (w > 0 ? w + 1 : 0));
ans = max(ans, solve(l + 1, r));
printf("%d\n", ans);
} else {
x = read(), scanf("%s", str + 1), lens = strlen(str + 1);
vec[x].clear();
for (i = 1; i <= lens; ++i) vec[x].push_back(str[i] - 'a');
Tree::update(1, n, 1, x);
modify(x, 0), lcp[x] = find(x), modify(x, 1);
if (x == n) continue;
modify(x + 1, 0), lcp[x + 1] = find(x + 1), modify(x + 1, 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int B = 60;
char s[maxn];
string a[maxn];
int lcp[maxn];
set<int> st;
int n, q;
int tmp_mx, tmp_suf[B + 1];
struct SegmentTree {
int pre[B + 1][maxn * 2 + 1], suf[B + 1][maxn * 2 + 1];
int mx[maxn * 2 + 1];
inline int getID(int l, int r) { return (l < r) | (l + r); }
inline void update(int t, int l, int r) {
int mid = (l + r) >> 1, lt = getID(l, mid), rt = getID(mid + 1, r);
mx[t] = max(mx[lt], mx[rt]);
for (int i = 1; i <= B; ++i) {
pre[i][t] = pre[i][lt] + (pre[i][lt] == mid - l + 1 ? pre[i][rt] : 0);
suf[i][t] = suf[i][rt] + (suf[i][rt] == r - mid ? suf[i][lt] : 0);
if (suf[i][lt] && pre[i][rt])
mx[t] = max(mx[t], (suf[i][lt] + pre[i][rt] + 1) * i);
}
}
void build(int l, int r) {
int t = getID(l, r);
if (l == r) {
for (int i = 1; i <= B; ++i) pre[i][t] = suf[i][t] = lcp[l] >= i;
mx[t] = max(lcp[l] * 2, (int)a[l].size());
return;
}
int mid = (l + r) >> 1;
build(l, mid), build(mid + 1, r);
update(t, l, r);
}
void modify(int l, int r, int x) {
int t = getID(l, r);
if (l == r) {
for (int i = 1; i <= B; ++i) pre[i][t] = suf[i][t] = lcp[l] >= i;
mx[t] = max(lcp[l] * 2, (int)a[l].size());
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
modify(l, mid, x);
else
modify(mid + 1, r, x);
update(t, l, r);
}
void ask(int l, int r, int x, int y) {
int t = getID(l, r);
if (x <= l && y >= r) {
for (int i = 1; i <= B; ++i) {
if (tmp_suf[i] || pre[i][t])
tmp_mx = max(tmp_mx, (tmp_suf[i] + pre[i][t] + 1) * i);
tmp_suf[i] = suf[i][t] + (suf[i][t] == r - l + 1 ? tmp_suf[i] : 0);
}
tmp_mx = max(tmp_mx, mx[t]);
return;
}
int mid = (l + r) >> 1;
if (x <= mid) ask(l, mid, x, y);
if (y > mid) ask(mid + 1, r, x, y);
}
} tree;
inline int strlcp(string &a, string &b) {
int tmp = 0;
while (tmp < a.size() && tmp < b.size() && a[tmp] == b[tmp]) ++tmp;
return tmp;
}
int work(vector<int> &v) {
int m = v.size();
stack<int> sta;
vector<int> L(m);
for (int i = 0; i < m; ++i) {
while (!sta.empty() && v[i] <= v[sta.top()]) sta.pop();
L[i] = sta.empty() ? -1 : sta.top();
sta.push(i);
}
while (!sta.empty()) sta.pop();
int mx = 0;
for (int i = m - 1; i >= 0; --i) {
while (!sta.empty() && v[i] <= v[sta.top()]) sta.pop();
int R = sta.empty() ? m : sta.top();
mx = max(mx, (R - L[i]) * v[i]);
sta.push(i);
}
return mx;
}
int work(int l, int r) {
auto lt = st.lower_bound(l), rt = st.upper_bound(r);
if (lt == rt) return 0;
vector<int> v;
v.push_back(lcp[*lt]);
int last = *lt, res = 0;
++lt;
while (lt != rt) {
if (*lt != last + 1) res = max(res, work(v)), v.clear();
last = *lt;
v.push_back(lcp[*lt]);
++lt;
}
return max(res, work(v));
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
a[i] = s;
}
for (int i = 1; i <= n - 1; ++i) {
lcp[i] = strlcp(a[i], a[i + 1]);
if (lcp[i] > B) st.insert(i);
}
if (n > 1) tree.build(1, n - 1);
while (q--) {
static int ty, l, r, x;
scanf("%d", &ty);
if (ty == 1) {
scanf("%d%d", &l, &r);
tmp_mx = 0;
memset(tmp_suf, 0, sizeof(tmp_suf));
if (l < r) tree.ask(1, n - 1, l, r - 1);
int ans = max((int)a[r].size(), tmp_mx);
ans = max(ans, work(l, r - 1));
printf("%d\n", ans);
} else {
scanf("%d%s", &x, s);
a[x] = s;
if (x > 1) {
if (lcp[x - 1] > B) st.erase(x - 1);
lcp[x - 1] = strlcp(a[x - 1], a[x]);
tree.modify(1, n - 1, x - 1);
if (lcp[x - 1] > B) st.insert(x - 1);
}
if (x < n) {
if (lcp[x] > B) st.erase(x);
lcp[x] = strlcp(a[x], a[x + 1]);
tree.modify(1, n - 1, x);
if (lcp[x] > B) st.insert(x);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class segtree {
private:
using T = array<int, 4>;
int b;
vector<T> tr;
T merge(const T& x, const T& y) {
return {max({x[0], y[0], x[2] + y[1]}), (x[1] == x[3]) * y[1] + x[1],
(y[2] == y[3]) * x[2] + y[2], x[3] + y[3]};
}
T single(int x = -1) {
int X = (x >= LB);
return {X, X, X, 1};
}
public:
int LB;
segtree(int lb, const vector<int>& a) {
LB = lb;
b = 1;
while (b < (int)a.size()) {
b <<= 1;
}
tr.assign(2 * b, single());
for (int i = 0; i < (int)a.size(); i++) {
tr[i + b] = single(a[i]);
}
for (int i = b - 1; i > 0; i--) {
tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
}
}
void upd(int i, int v) {
tr[i += b] = single(v);
for (i >>= 1; i > 0; i >>= 1) {
tr[i] = merge(tr[i << 1], tr[i << 1 | 1]);
}
}
int qry(int l, int r) {
T ansr = {}, ansl = {};
for (l += b, r += b; l <= r; l >>= 1, r >>= 1) {
if (l & 1) ansl = merge(ansl, tr[l++]);
if (!(r & 1)) ansr = merge(tr[r--], ansr);
}
return merge(ansl, ansr)[0];
}
};
class segtree2 {
private:
int b;
vector<int> tr;
public:
segtree2(const vector<int>& a) {
b = 1;
while (b < (int)a.size()) {
b <<= 1;
}
tr.assign(2 * b, 0);
for (int i = 0; i < (int)a.size(); i++) {
tr[i + b] = a[i];
}
for (int i = b - 1; i > 0; i--) {
tr[i] = max(tr[i << 1], tr[i << 1 | 1]);
}
}
void upd(int i, int v) {
tr[i += b] = v;
for (i >>= 1; i > 0; i >>= 1) {
tr[i] = max(tr[i << 1], tr[i << 1 | 1]);
}
}
int qry(int l, int r) {
int ans = 0;
for (l += b, r += b; l <= r; l >>= 1, r >>= 1) {
if (l & 1) ans = max(ans, tr[l++]);
if (!(r & 1)) ans = max(ans, tr[r--]);
}
return ans;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<string> s(n);
vector<int> LN(n, 0);
set<int> Vals;
for (int i = 0; i < n; i++) {
cin >> s[i];
LN[i] = s[i].length();
}
auto LCP = [&](const string& ss, const string& t) {
int ans = 0;
for (int i = 0; i < (int)min(ss.length(), t.length()); i++) {
if (ss[i] == t[i]) {
ans++;
} else {
break;
}
}
Vals.insert(ans);
return ans;
};
vector<int> OP(q), L(q), R(q), res(q, 0), Lcp(n - 1, 0);
vector<vector<pair<int, int>>> qc(q);
for (int i = 1; i < n; i++) {
Lcp[i - 1] = LCP(s[i - 1], s[i]);
}
for (int tt = 0; tt < q; tt++) {
cin >> OP[tt];
if (OP[tt] == 1) {
cin >> L[tt] >> R[tt];
--L[tt];
--R[tt];
} else {
cin >> L[tt];
--L[tt];
cin >> s[L[tt]];
R[tt] = s[L[tt]].length();
if (L[tt] > 0) {
qc[tt].emplace_back(L[tt] - 1, LCP(s[L[tt] - 1], s[L[tt]]));
}
if (L[tt] + 1 < n) {
qc[tt].emplace_back(L[tt], LCP(s[L[tt]], s[L[tt] + 1]));
}
}
}
for (int mn : Vals) {
segtree st(mn, Lcp);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
int a = L[tt], b = R[tt];
int& ans = res[tt];
if (a < b) {
int z = st.qry(a, b - 1);
ans = max(ans, mn * (z + (z > 0)));
}
} else {
for (const auto& p : qc[tt]) {
st.upd(p.first, p.second);
}
}
}
}
segtree2 lns(LN);
for (int tt = 0; tt < q; tt++) {
if (OP[tt] == 1) {
cout << max(res[tt], lns.qry(L[tt], R[tt])) << '\n';
} else {
lns.upd(L[tt], R[tt]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const int MAXN = 100005;
struct tree1 {
private:
int mx;
int l;
int r;
tree1 *lson;
tree1 *rson;
public:
tree1() {
mx = 0;
lson = rson = NULL;
}
void build(int L, int R) {
l = L;
r = R;
if (l == r) return;
lson = new tree1;
rson = new tree1;
int mid = (l + r) / 2;
lson->build(l, mid);
rson->build(mid + 1, r);
}
void modify(int id, int k) {
if (l == r) {
mx = k;
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
mx = max(lson->mx, rson->mx);
}
int query(int L, int R) {
if (l >= L && r <= R) return mx;
int mid = (l + r) / 2;
if (R <= mid) return lson->query(L, R);
if (L > mid) return rson->query(L, R);
return max(lson->query(L, R), rson->query(L, R));
}
};
struct line {
int k;
int b;
line(int K = 0, int B = 0) {
k = K;
b = B;
}
int calc(int x) { return k * x + b; }
double cross(line t) { return (double)(t.b - b) / (k - t.k); }
};
struct tree {
bool tag;
int l;
int r;
line *L;
int cnt;
line *R;
int rcnt;
int mx;
tree *lson;
tree *rson;
tree() {
tag = false;
L = R = NULL;
cnt = rcnt = mx = 0;
lson = rson = NULL;
}
void fixup() {
static line tmp[MAXN];
l = lson->l;
r = rson->r;
if (L) delete L;
L = new line[lson->cnt + rson->cnt];
cnt = lson->cnt;
for (int i = 0; i < cnt; i++) L[i] = lson->L[i];
for (int i = 0; i < rson->cnt; i++) {
if (rson->L[i].k >= L[cnt - 1].k)
L[cnt - 1].b = (lson->r - lson->l + 1) + rson->L[i].b;
else {
L[cnt++] = rson->L[i];
L[cnt - 1].b += (lson->r - lson->l + 1);
}
}
if (R) delete R;
R = new line[lson->rcnt + rson->rcnt];
rcnt = rson->rcnt;
for (int i = 0; i < rcnt; i++) R[i] = rson->R[i];
for (int i = 0; i < lson->rcnt; i++) {
if (lson->R[i].k >= R[rcnt - 1].k)
R[rcnt - 1].b = (rson->r - rson->l + 1) + lson->R[i].b;
else {
R[rcnt++] = lson->R[i];
R[rcnt - 1].b += (rson->r - rson->l + 1);
}
}
mx = max(lson->mx, rson->mx);
int cur = 0, p = 0, s = 0;
memset(tmp, 0, sizeof(line) * rson->cnt);
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
for (int i = 0; i < lson->rcnt; i++) {
while (cur < rson->cnt && rson->L[cur].k < lson->R[i].k) {
line t = rson->L[cur++];
t.b = (t.b + 1) * t.k;
while (s > 1 && tmp[s - 2].cross(t) < tmp[s - 2].cross(tmp[s - 1])) s--;
if (p >= s) p = max(s - 1, 0);
tmp[s++] = t;
}
while (p < s - 1 &&
tmp[p].calc(lson->R[i].b) < tmp[p + 1].calc(lson->R[i].b))
p++;
while (p && tmp[p].calc(lson->R[i].b) < tmp[p - 1].calc(lson->R[i].b))
p--;
if (cur < rson->cnt)
mx = max(mx, (lson->R[i].b + rson->L[cur].b + 1) * lson->R[i].k);
mx = max(mx, tmp[p].calc(lson->R[i].b));
}
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
}
void build(int rL, int rR, int *a) {
tag = true;
l = rL;
r = rR;
if (l == r) {
mx = a[l] * 2;
L = new line[1];
R = new line[1];
cnt = rcnt = 1;
L[0] = R[0] = line(a[l], 1);
return;
}
int mid = (l + r) / 2;
lson = new tree;
rson = new tree;
lson->build(l, mid, a);
rson->build(mid + 1, r, a);
fixup();
}
void modify(int id, int k) {
if (l == r) {
mx = k * 2;
L[0] = R[0] = line(k, 1);
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
fixup();
}
tree *query(int rL, int rR) {
if (l >= rL && r <= rR) return this;
int mid = (l + r) / 2;
if (rR <= mid) return lson->query(rL, rR);
if (rL > mid) return rson->query(rL, rR);
tree *temp = new tree;
temp->lson = lson->query(rL, rR);
temp->rson = rson->query(rL, rR);
temp->fixup();
return temp;
}
void query_clear() {
if (tag) return;
lson->query_clear();
rson->query_clear();
if (L) delete L;
if (R) delete R;
}
};
void print(int *a, int n) {
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
int N, q;
tree1 T1;
tree T;
char *s[MAXN], str[MAXN];
int len[MAXN], lcp[MAXN];
void init() {
scanf("%d %d", &N, &q);
T1.build(1, N);
for (int i = 1; i <= N; i++) {
scanf("%s", str);
len[i] = strlen(str);
s[i] = new char[len[i]];
memcpy(s[i], str, sizeof(char) * len[i]);
T1.modify(i, len[i]);
}
for (int i = 1; i < N; i++) {
int t = 0;
while (t < len[i] && t < len[i + 1] && s[i][t] == s[i + 1][t]) t++;
lcp[i] = t;
}
if (N > 1) T.build(1, N - 1, lcp);
}
int main() {
int ty, x, y;
init();
for (int i = 0; i < q; i++) {
scanf("%d %d", &ty, &x);
if (ty == 1) {
scanf("%d", &y);
int ans = T1.query(x, y);
if (x == y) {
printf("%d\n", ans);
continue;
}
tree *p = T.query(x, y - 1);
ans = max(ans, p->mx);
p->query_clear();
if (!p->l && !p->r) delete p;
std::cout << ans << std::endl;
} else {
scanf("%s", str);
len[x] = strlen(str);
s[x] = new char[len[x]];
memcpy(s[x], str, sizeof(char) * len[x]);
T1.modify(x, len[x]);
int t = 0;
if (x > 1) {
for (t = 0; t < len[x - 1] && t < len[x] && s[x - 1][t] == s[x][t]; t++)
;
lcp[x - 1] = t;
T.modify(x - 1, t);
}
if (x < N) {
for (t = 0; t < len[x] && t < len[x + 1] && s[x][t] == s[x + 1][t]; t++)
;
lcp[x] = t;
T.modify(x, t);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wunused-result"
using namespace std;
template <class T>
inline bool chkmax(T &a, const T &b) {
return b > a ? a = b, true : false;
}
template <class T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, true : false;
}
template <class T, class F = less<T>>
void sort_uniq(vector<T> &v, F f = F()) {
sort(begin(v), end(v), f);
v.resize(unique(begin(v), end(v)) - begin(v));
}
template <class T>
using MaxHeap = priority_queue<T>;
template <class T>
using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
struct SegTreeRangeAsk {
int n;
vector<T> dat;
template <typename F>
void init(int id, int l, int r, F f) {
if (l == r) {
dat[id] = f(l);
return;
}
int m = (l + r) / 2;
init(id * 2, l, m, f);
init(id * 2 + 1, m + 1, r, f);
dat[id] = dat[id * 2] + dat[id * 2 + 1];
}
template <typename F>
void init(int _n, F f) {
n = _n;
dat.resize(4 * (n + 1));
init(1, 1, n, f);
}
void init(int _n, T *a) {
init(_n, [a](int i) { return a[i]; });
}
void init(int _n, T val) {
init(_n, [val](int) { return val; });
}
T ask(int id, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return dat[id];
int m = (l + r) / 2;
if (qr <= m) return ask(id * 2, l, m, ql, qr);
if (ql > m) return ask(id * 2 + 1, m + 1, r, ql, qr);
T tl = ask(id * 2, l, m, ql, qr);
T tr = ask(id * 2 + 1, m + 1, r, ql, qr);
return tl + tr;
}
T ask(int l, int r) {
assert(l <= r);
return ask(1, 1, n, l, r);
}
void chg(int id, int l, int r, int qx, T qv) {
if (l == r) {
dat[id] = qv;
return;
}
int m = (l + r) / 2;
if (qx <= m)
chg(id * 2, l, m, qx, qv);
else
chg(id * 2 + 1, m + 1, r, qx, qv);
dat[id] = dat[id * 2] + dat[id * 2 + 1];
}
void chg(int qx, T qv) {
assert(1 <= qx && qx <= n);
chg(1, 1, n, qx, qv);
}
};
int lcp(const string &a, const string &b) {
int l = 0;
while (l < ((int)(a).size()) && l < ((int)(b).size()) && a[l] == b[l]) l++;
return l;
}
struct Max {
int x;
Max operator+(const Max &other) { return {max(x, other.x)}; }
};
SegTreeRangeAsk<Max> seg_len;
const int L = 64;
struct Lcp {
int l, r, cl[L], cm[L], cr[L];
int len() const { return r - l + 1; }
int eval() const {
int mx = 0;
for (int i = 0; i < int(L); i++)
if (cm[i]) chkmax(mx, (i + 1) * (cm[i] + 1));
return mx;
}
};
Lcp operator+(const Lcp &a, const Lcp &b) {
Lcp c;
c.l = a.l;
c.r = b.r;
int na = a.len(), nb = b.len();
for (int i = 0; i < int(L); i++) {
c.cl[i] = (a.cl[i] < na ? a.cl[i] : na + b.cl[i]);
c.cr[i] = (b.cr[i] < nb ? b.cr[i] : nb + a.cr[i]);
c.cm[i] = max({a.cm[i], b.cm[i], a.cr[i] + b.cl[i]});
}
return c;
}
SegTreeRangeAsk<Lcp> seg_lcp;
const int N = 1e5 + 10;
int n, m, h[N];
string s[N];
Max gen_max(int i) { return Max{((int)(s[i]).size())}; }
Lcp gen_lcp(int p) {
Lcp x;
x.l = x.r = p;
for (int i = 0; i < int(L); i++) x.cl[i] = x.cm[i] = x.cr[i] = (i < h[p]);
return x;
}
set<int> ls;
int solve_ls(int l, int r) {
vector<int> v;
auto it = ls.lower_bound(l);
while (it != ls.end() && *it <= r) v.push_back(*it++);
vector<int> a;
for (int i = 0; i < int(((int)(v).size())); i++) {
if (i > 0 && v[i] != v[i - 1] + 1) a.push_back(0);
a.push_back(h[v[i]]);
}
a.push_back(0);
int ans = 0;
vector<int> stk;
for (int i = 0; i < int(((int)(a).size())); i++) {
while (!stk.empty() && a[stk.back()] >= a[i]) {
int x = stk.back();
stk.pop_back();
int lb = stk.empty() ? 0 : stk.back() + 1;
int rb = i - 1;
int now = a[x] * (rb - lb + 2);
chkmax(ans, now);
}
stk.push_back(i);
}
return ans;
}
void solve_1() {
while (m--) {
int op;
cin >> op;
if (op == 1) {
int l, r;
cin >> l >> r;
cout << ((int)(s[1]).size()) << '\n';
} else if (op == 2) {
int x;
cin >> x;
cin >> s[x];
} else
assert(0);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = (1); i <= int(n); i++) cin >> s[i];
if (n == 1) {
solve_1();
return 0;
}
for (int i = (1); i <= int(n - 1); i++) h[i] = lcp(s[i], s[i + 1]);
seg_len.init(n, gen_max);
seg_lcp.init(n - 1, gen_lcp);
for (int i = (1); i <= int(n - 1); i++)
if (h[i] > L) ls.insert(i);
while (m--) {
int op;
cin >> op;
if (op == 1) {
int l, r;
cin >> l >> r;
int ans = 0;
auto qlen = seg_len.ask(l, r);
chkmax(ans, qlen.x);
;
if (l < r) {
auto qlcp = seg_lcp.ask(l, r - 1);
chkmax(ans, qlcp.eval());
auto qls = solve_ls(l, r - 1);
chkmax(ans, qls);
;
}
cout << ans << '\n';
} else if (op == 2) {
int x;
cin >> x;
cin >> s[x];
seg_len.chg(x, gen_max(x));
if (x - 1 >= 1) {
h[x - 1] = lcp(s[x - 1], s[x]);
seg_lcp.chg(x - 1, gen_lcp(x - 1));
if (h[x - 1] <= L)
ls.erase(x - 1);
else
ls.insert(x - 1);
}
if (x + 1 <= n) {
h[x] = lcp(s[x], s[x + 1]);
seg_lcp.chg(x, gen_lcp(x));
if (h[x] <= L)
ls.erase(x);
else
ls.insert(x);
}
} else
assert(0);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 4e5 + 10;
struct Node {
int a, b, ab, f;
friend Node operator+(Node X, Node Y) {
return {X.a + X.f * Y.a, Y.b + Y.f * X.b, max({X.ab, Y.ab, X.b + Y.a}),
X.f && Y.f};
}
};
long long int A[N];
int mx[N << 2], type[N], L[N], R[N], n, q;
vector<int> vec;
Node seg[N << 2];
string second[N], T[N], Q[N];
char C[N];
int LCP(int x, int y) {
if (max(x, y) > n || min(x, y) <= 0) return 0;
int z;
for (z = 0; z < min((int)T[x].size(), (int)T[y].size()) && T[x][z] == T[y][z];
z++)
;
return z;
}
void buildmax(int id = 1, int l = 1, int r = n + 1) {
if (r - l == 1) {
mx[id] = (int)T[l].size();
return;
}
int mid = (l + r) >> 1;
buildmax(id << 1, l, mid);
buildmax(id << 1 | 1, mid, r);
mx[id] = max(mx[id << 1], mx[id << 1 | 1]);
}
void updatemax(int pos, int id = 1, int l = 1, int r = n + 1) {
if (r - l == 1) {
mx[id] = (int)T[l].size();
return;
}
int mid = (l + r) >> 1;
if (pos < mid)
updatemax(pos, id << 1, l, mid);
else
updatemax(pos, id << 1 | 1, mid, r);
mx[id] = max(mx[id << 1 | 1], mx[id << 1]);
}
int getmax(int ql, int qr, int id = 1, int l = 1, int r = n + 1) {
if (qr <= l || r <= ql) return 0;
if (ql <= l && r <= qr) return mx[id];
int mid = (l + r) >> 1;
return max(getmax(ql, qr, id << 1, l, mid),
getmax(ql, qr, id << 1 | 1, mid, r));
}
void build(int x, int id = 1, int l = 1, int r = n) {
if (r - l == 1) {
if (LCP(l, r) >= x)
seg[id] = {1, 1, 1, 1};
else
seg[id] = {0, 0, 0, 0};
return;
}
int mid = (l + r) >> 1;
build(x, id << 1, l, mid);
build(x, id << 1 | 1, mid, r);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
void update(int pos, int x, int id = 1, int l = 1, int r = n) {
if (pos < l || pos >= r) return;
if (r - l == 1) {
seg[id] = {x, x, x, x};
return;
}
int mid = (l + r) >> 1;
if (pos < mid)
update(pos, x, id << 1, l, mid);
else
update(pos, x, id << 1 | 1, mid, r);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
Node get(int ql, int qr, int id = 1, int l = 1, int r = n) {
if (qr <= l || r <= ql) return Node{0, 0, 0, 0};
if (ql <= l && r <= qr) return seg[id];
int mid = (l + r) >> 1;
return get(ql, qr, id << 1, l, mid) + get(ql, qr, id << 1 | 1, mid, r);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%s", C);
second[i] = C;
T[i] = second[i];
if (i > 1) vec.push_back(LCP(i, i - 1));
}
buildmax();
for (int i = 1; i <= q; i++) {
scanf("%d", &type[i]);
if (type[i] == 1) {
scanf("%d%d", &L[i], &R[i]);
A[i] = getmax(L[i], R[i] + 1);
} else {
scanf("%d%s", &L[i], C);
Q[i] = C;
T[L[i]] = C;
updatemax(L[i]);
vec.push_back(LCP(L[i], L[i] + 1));
vec.push_back(LCP(L[i] - 1, L[i]));
}
}
if (n == 1) {
for (int i = 1; i <= q; i++)
if (type[i] == 1) printf("%lld\n", A[i]);
exit(0);
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int x : vec) {
for (int i = 1; i <= n; i++) T[i] = second[i];
build(x);
for (int i = 1; i <= q; i++) {
if (type[i] == 1) {
int t = get(L[i], R[i]).ab;
if (t) t++;
A[i] = max(A[i], 1LL * t * x);
} else {
T[L[i]] = Q[i];
update(L[i], LCP(L[i], L[i] + 1) >= x);
update(L[i] - 1, LCP(L[i] - 1, L[i]) >= x);
}
}
}
for (int i = 1; i <= q; i++)
if (type[i] == 1) printf("%lld\n", A[i]);
return 0;
}
|
#include <bits/stdc++.h>
typedef long long LL;
const double INF = 1e100;
const int oo = ~0u >> 2;
const double pi = acos(-1.0);
const double EPS = 1e-8;
const int MAXN = 100033;
std::string a[MAXN];
int lcp[MAXN], n, q;
struct node {
int ans;
std::vector<std::pair<int, int> > L, R;
} T[262144];
node merge(const node& L, const node& R, int m) {
node res;
res.ans = std::max(L.ans, R.ans);
res.L = L.L;
for (auto i = L.R.end() - 1, j = R.L.end() - 1; i >= L.R.begin(); --i) {
while (j > R.L.begin() && j->first < i->first) --j;
if (j->first < i->first) break;
res.ans = std::max(
res.ans, (j->second - i->second + 1) * std::min(lcp[m], i->first));
}
for (auto i = R.L.end() - 1, j = L.R.end() - 1; i >= R.L.begin(); --i) {
while (j > L.R.begin() && j->first < i->first) --j;
if (j->first < i->first) break;
res.ans = std::max(
res.ans, (i->second - j->second + 1) * std::min(lcp[m], i->first));
}
for (auto i : R.L) {
i.first = std::min(i.first, lcp[m]);
if (i.first >= res.L.back().first)
res.L.back().second = i.second;
else
res.L.push_back(i);
}
res.R = R.R;
for (auto i : L.R) {
i.first = std::min(i.first, lcp[m]);
if (i.first >= res.R.back().first)
res.R.back().second = i.second;
else
res.R.push_back(i);
}
return res;
}
void build(int p, int l, int r) {
if (l == r) {
T[p].ans = a[l].length();
T[p].L = T[p].R = {{a[l].length(), l}};
return;
}
int m = l + r >> 1;
build(p << 1, l, m);
build(p << 1 | 1, m + 1, r);
T[p] = merge(T[p << 1], T[p << 1 | 1], m);
}
node G(int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return T[p];
int m = l + r >> 1;
if (R <= m) return G(p << 1, l, m, L, R);
if (L > m) return G(p << 1 | 1, m + 1, r, L, R);
return merge(G(p << 1, l, m, L, R), G(p << 1 | 1, m + 1, r, L, R), m);
}
void update(int p, int l, int r, int x) {
if (l == r) {
T[p].ans = a[l].length();
T[p].L = T[p].R = {{a[l].length(), l}};
return;
}
int m = l + r >> 1;
if (x <= m) update(p << 1, l, m, x);
if (x >= m) update(p << 1 | 1, m + 1, r, x);
T[p] = merge(T[p << 1], T[p << 1 | 1], m);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = (1), __ = (n); i <= __; ++i) std::cin >> a[i];
for (int i = (1), __ = (n); i < __; ++i)
while (a[i][lcp[i]] == a[i + 1][lcp[i]]) ++lcp[i];
build(1, 1, n);
while (q--) {
int ty;
scanf("%d", &ty);
if (ty == 1) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", G(1, 1, n, l, r).ans);
} else {
int x;
scanf("%d", &x);
std::cin >> a[x];
if (x > 1) {
lcp[x - 1] = 0;
while (a[x - 1][lcp[x - 1]] == a[x][lcp[x - 1]]) ++lcp[x - 1];
update(1, 1, n, x - 1);
}
if (x < n) {
lcp[x] = 0;
while (a[x][lcp[x]] == a[x + 1][lcp[x]]) ++lcp[x];
update(1, 1, n, x);
}
update(1, 1, n, x);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int S = 80;
const int N = 1e5 + 10;
struct node {
int lv, rv, mx, sum;
} f[N * 4], d;
struct ques {
int x, y, z;
string s;
int id;
int v[2];
int len;
} q[N];
int g[N * 4];
int n, m;
int v[N];
int gd;
long long ans[N];
int len[N], vv[N], lenn[N];
string s[N];
int w[N], L[N], R[N], dw[N];
int getlcs(int i) {
int x = 0;
while (x < len[i] && x < len[i + 1] && s[i][x] == s[i + 1][x]) x++;
return x;
}
int I;
void combine(node& a, node b, node c) {
a.sum = b.sum + c.sum;
if (b.lv == b.sum)
a.lv = b.lv + c.lv;
else
a.lv = b.lv;
if (c.rv == c.sum)
a.rv = c.rv + b.rv;
else
a.rv = c.rv;
a.mx = max(b.mx, max(c.mx, b.rv + c.lv));
}
void build(int l, int r, int s) {
if (l == r) {
f[s].lv = f[s].rv = f[s].mx = (v[l] > I), f[s].sum = 1;
g[s] = len[l];
return;
}
build(l, (l + r) / 2, s + s);
build((l + r) / 2 + 1, r, s + s + 1);
combine(f[s], f[s + s], f[s + s + 1]);
g[s] = max(g[s + s], g[s + s + 1]);
}
void change(int l, int r, int s, int ll, int rr) {
if (r < ll || rr < l) return;
if (l == r) {
g[s] = len[l];
f[s].lv = f[s].rv = f[s].mx = (v[l] > I), f[s].sum = 1;
return;
}
change(l, (l + r) / 2, s + s, ll, rr);
change((l + r) / 2 + 1, r, s + s + 1, ll, rr);
combine(f[s], f[s + s], f[s + s + 1]);
g[s] = max(g[s + s], g[s + s + 1]);
}
void get(int l, int r, int s, int ll, int rr) {
if (r < ll || rr < l) return;
if (ll <= l && r <= rr) {
if (l == ll) {
d = f[s];
} else {
combine(d, d, f[s]);
}
gd = max(gd, g[s]);
return;
}
get(l, (l + r) / 2, s + s, ll, rr);
get((l + r) / 2 + 1, r, s + s + 1, ll, rr);
}
void buildw() {
dw[0] = 0;
for (int i = 1; i <= w[0]; i++) {
if (i > 1 && w[i] != w[i - 1] + 1)
dw[0] = 0, L[i] = w[i];
else {
L[i] = w[i];
while (dw[0] && v[w[dw[dw[0]]]] >= v[w[i]]) {
L[i] = L[dw[dw[0]]];
dw[0]--;
}
}
dw[++dw[0]] = i;
}
dw[0] = 0;
for (int i = w[0]; i >= 1; i--) {
if (i < w[0] && w[i] != w[i + 1] - 1)
dw[0] = 0, R[i] = w[i];
else {
R[i] = w[i];
while (dw[0] && v[w[dw[dw[0]]]] >= v[w[i]]) {
R[i] = R[dw[dw[0]]];
dw[0]--;
}
}
dw[++dw[0]] = i;
}
}
void add(int x) {
for (int i = 1; i <= w[0]; i++)
if (w[i] > x) {
for (int j = w[0]; j >= i; j--) w[j + 1] = w[j];
w[i] = x;
w[0]++;
break;
}
if (w[w[0]] < x) w[++w[0]] = x;
}
void del(int x) {
for (int i = 1; i <= w[0]; i++)
if (w[i] == x) {
for (int j = i; j < w[0]; j++) w[j] = w[j + 1];
w[0]--;
break;
}
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> s[i], lenn[i] = len[i] = s[i].length();
}
for (int i = 1; i < n; i++) {
v[i] = getlcs(i);
if (v[i] > S) w[++w[0]] = i;
vv[i] = v[i];
}
int tot = 0;
buildw();
for (int i = 1; i <= m; i++) {
cin >> q[i].x >> q[i].y;
if (q[i].x == 1)
cin >> q[i].z, q[i].id = ++tot;
else
cin >> q[i].s;
}
for (I = 0; I < S; I++) {
for (int i = 1; i <= n; i++) v[i] = vv[i], len[i] = lenn[i];
build(1, n, 1);
for (int j = 1; j <= m; j++) {
int x = q[j].x, y = q[j].y;
if (x == 1) {
int z = q[j].z;
if (y == z) {
ans[q[j].id] = max(ans[q[j].id], 1ll * len[y]);
continue;
}
gd = len[z];
get(1, n, 1, y, z - 1);
if (!I) {
ans[q[j].id] = max(ans[q[j].id], 1ll * gd);
buildw();
for (int i = 1; i <= w[0]; i++)
ans[q[j].id] =
max(ans[q[j].id],
1ll * (min(z - 1, R[i]) - max(y, L[i]) + 2) * v[w[i]]);
}
if (d.mx) ans[q[j].id] = max(ans[q[j].id], 1ll * (I + 1) * (d.mx + 1));
} else {
if (!I) {
if (y != n && v[y] > S) del(y);
if (y != 1 && v[y - 1] > S) del(y - 1);
}
if (!I) {
s[y] = q[j].s;
len[y] = s[y].length();
q[j].len = len[y];
} else
len[y] = q[j].len;
if (y != 1) {
if (!I) {
q[j].v[0] = v[y - 1] = getlcs(y - 1);
} else
v[y - 1] = q[j].v[0];
if (!I && v[y - 1] > S) add(y - 1);
}
if (y != n) {
if (!I) {
q[j].v[1] = v[y] = getlcs(y);
} else
v[y] = q[j].v[1];
if (!I && v[y] > S) add(y);
}
if (!I) buildw();
change(1, n, 1, y - 1, y);
}
}
}
for (int i = 1; i <= tot; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 40;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
string s[maxn];
int d[maxn];
struct node {
vector<pair<int, int> > l, r;
int ans;
void init() {
l.clear();
r.clear();
ans = 0;
}
} f[maxn << 2];
node fmerge(node L, node R) {
node a;
a.ans = max(L.ans, R.ans);
for (auto u : L.r) {
for (auto v : R.l)
a.ans = max(a.ans, min(u.first, v.first) * (u.second + v.second + 1));
}
a.l = L.l;
pair<int, int> w = a.l.back();
int k = a.l.size(), m = 0;
for (auto u : R.l) {
if (u.first >= w.first)
m = max(m, u.second);
else
a.l.push_back(pair<int, int>(u.first, u.second + w.second));
}
a.l[k - 1].second += m;
a.r = R.r;
w = a.r.back();
k = a.r.size();
m = 0;
for (auto u : L.r) {
if (u.first >= w.first)
m = max(m, u.second);
else
a.r.push_back(pair<int, int>(u.first, u.second + w.second));
}
a.r[k - 1].second += m;
return a;
}
void build(int t, int l, int r) {
if (l == r) {
f[t].init();
f[t].l.push_back(pair<int, int>(d[l], 1));
f[t].r.push_back(pair<int, int>(d[l], 1));
f[t].ans = max(d[l] << 1, (int)max(s[l].size(), s[l + 1].size()));
return;
}
int mid = (l + r) >> 1;
build(t << 1, l, mid);
build(t << 1 | 1, mid + 1, r);
f[t] = fmerge(f[t << 1], f[t << 1 | 1]);
}
void updata(int t, int l, int r, int x) {
if (l == r) {
f[t].init();
f[t].l.push_back(pair<int, int>(d[l], 1));
f[t].r.push_back(pair<int, int>(d[l], 1));
f[t].ans = max(d[l] << 1, (int)max(s[l].size(), s[l + 1].size()));
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
updata(t << 1, l, mid, x);
else
updata(t << 1 | 1, mid + 1, r, x);
f[t] = fmerge(f[t << 1], f[t << 1 | 1]);
}
node query(int t, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return f[t];
int mid = (l + r) >> 1;
if (rr <= mid)
return query(t << 1, l, mid, ll, rr);
else if (ll > mid)
return query(t << 1 | 1, mid + 1, r, ll, rr);
else
return fmerge(query(t << 1, l, mid, ll, rr),
query(t << 1 | 1, mid + 1, r, ll, rr));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, q, i, j, x;
cin >> n >> q;
for (i = 1; i <= n; i++) cin >> s[i];
if (n == 1) {
while (q--) {
cin >> x;
if (x == 1) {
cin >> i >> j;
printf("%d\n", (int)s[1].size());
} else {
cin >> i;
cin >> s[i];
}
}
return 0;
}
for (i = 1; i < n; i++) {
for (j = 0;
j < (int)min(s[i].size(), s[i + 1].size()) && s[i][j] == s[i + 1][j];
j++)
;
d[i] = j;
}
build(1, 1, n - 1);
while (q--) {
cin >> x;
if (x == 1) {
cin >> i >> j;
if (i == j)
printf("%d\n", (int)s[i].size());
else
printf("%d\n", query(1, 1, n - 1, i, j - 1).ans);
} else {
cin >> i;
cin >> s[i];
if (i > 1) {
for (j = 0; j < (int)min(s[i].size(), s[i - 1].size()) &&
s[i][j] == s[i - 1][j];
j++)
;
d[i - 1] = j;
updata(1, 1, n - 1, i - 1);
}
if (i < n) {
for (j = 0; j < (int)min(s[i].size(), s[i + 1].size()) &&
s[i][j] == s[i + 1][j];
j++)
;
d[i] = j;
updata(1, 1, n - 1, i);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const int B = 50;
char s[maxn];
string a[maxn];
int lcp[maxn];
set<int> st;
int n, q;
int tmp_mx, tmp_suf[B + 1];
struct SegmentTree {
int pre[B + 1][maxn * 2 + 1], suf[B + 1][maxn * 2 + 1];
int mx[maxn * 2 + 1];
inline int getID(int l, int r) { return (l < r) | (l + r); }
inline void update(int t, int l, int r) {
int mid = (l + r) >> 1, lt = getID(l, mid), rt = getID(mid + 1, r);
mx[t] = max(mx[lt], mx[rt]);
for (int i = 1; i <= B; ++i) {
pre[i][t] = pre[i][lt] + (pre[i][lt] == mid - l + 1 ? pre[i][rt] : 0);
suf[i][t] = suf[i][rt] + (suf[i][rt] == r - mid ? suf[i][lt] : 0);
if (suf[i][lt] && pre[i][rt])
mx[t] = max(mx[t], (suf[i][lt] + pre[i][rt] + 1) * i);
}
}
void build(int l, int r) {
int t = getID(l, r);
if (l == r) {
for (int i = 1; i <= B; ++i) pre[i][t] = suf[i][t] = lcp[l] >= i;
mx[t] = max(lcp[l] * 2, (int)a[l].size());
return;
}
int mid = (l + r) >> 1;
build(l, mid), build(mid + 1, r);
update(t, l, r);
}
void modify(int l, int r, int x) {
int t = getID(l, r);
if (l == r) {
for (int i = 1; i <= B; ++i) pre[i][t] = suf[i][t] = lcp[l] >= i;
mx[t] = max(lcp[l] * 2, (int)a[l].size());
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
modify(l, mid, x);
else
modify(mid + 1, r, x);
update(t, l, r);
}
void ask(int l, int r, int x, int y) {
int t = getID(l, r);
if (x <= l && y >= r) {
for (int i = 1; i <= B; ++i) {
if (tmp_suf[i] || pre[i][t])
tmp_mx = max(tmp_mx, (tmp_suf[i] + pre[i][t] + 1) * i);
tmp_suf[i] = suf[i][t] + (suf[i][t] == r - l + 1 ? tmp_suf[i] : 0);
}
tmp_mx = max(tmp_mx, mx[t]);
return;
}
int mid = (l + r) >> 1;
if (x <= mid) ask(l, mid, x, y);
if (y > mid) ask(mid + 1, r, x, y);
}
} tree;
inline int strlcp(string &a, string &b) {
int tmp = 0;
while (tmp < a.size() && tmp < b.size() && a[tmp] == b[tmp]) ++tmp;
return tmp;
}
int work(vector<int> &v) {
int m = v.size();
stack<int> sta;
vector<int> L(m);
for (int i = 0; i < m; ++i) {
while (!sta.empty() && v[i] <= v[sta.top()]) sta.pop();
L[i] = sta.empty() ? -1 : sta.top();
sta.push(i);
}
while (!sta.empty()) sta.pop();
int mx = 0;
for (int i = m - 1; i >= 0; --i) {
while (!sta.empty() && v[i] <= v[sta.top()]) sta.pop();
int R = sta.empty() ? m : sta.top();
mx = max(mx, (R - L[i]) * v[i]);
sta.push(i);
}
return mx;
}
int work(int l, int r) {
auto lt = st.lower_bound(l), rt = st.upper_bound(r);
if (lt == rt) return 0;
vector<int> v;
v.push_back(lcp[*lt]);
int last = *lt, res = 0;
++lt;
while (lt != rt) {
if (*lt != last + 1) res = max(res, work(v)), v.clear();
last = *lt;
v.push_back(lcp[*lt]);
++lt;
}
return max(res, work(v));
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
a[i] = s;
}
for (int i = 1; i <= n - 1; ++i) {
lcp[i] = strlcp(a[i], a[i + 1]);
if (lcp[i] > B) st.insert(i);
}
if (n > 1) tree.build(1, n - 1);
while (q--) {
static int ty, l, r, x;
scanf("%d", &ty);
if (ty == 1) {
scanf("%d%d", &l, &r);
tmp_mx = 0;
memset(tmp_suf, 0, sizeof(tmp_suf));
if (l < r) tree.ask(1, n - 1, l, r - 1);
int ans = max((int)a[r].size(), tmp_mx);
ans = max(ans, work(l, r - 1));
printf("%d\n", ans);
} else {
scanf("%d%s", &x, s);
a[x] = s;
if (x > 1) {
if (lcp[x - 1] > B) st.erase(x - 1);
lcp[x - 1] = strlcp(a[x - 1], a[x]);
tree.modify(1, n - 1, x - 1);
if (lcp[x - 1] > B) st.insert(x - 1);
}
if (x < n) {
if (lcp[x] > B) st.erase(x);
lcp[x] = strlcp(a[x], a[x + 1]);
tree.modify(1, n - 1, x);
if (lcp[x] > B) st.insert(x);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxN1 = 1e5, mxN2 = 1 << 18, INF = 1e9;
struct dat {
int len = 0, max;
vector<pair<int, int>> pref, suf;
} tree[mxN2];
int n, q, qt;
string ss[mxN1];
inline void cmb(dat &d, dat &a, dat &b) {
d.len = a.len + b.len;
d.max = max(a.max, b.max);
for (int i1 = 0, i2 = 0; i1 < a.suf.size() - 1;) {
if (a.suf[i1].first <= b.pref[i2].first) {
d.max = max(a.suf[i1].first * (a.suf[i1].second + b.pref[i2].second + 1),
d.max);
++i1;
} else {
d.max = max(b.pref[i2].first * (a.suf[i1].second + b.pref[i2].second + 1),
d.max);
++i2;
}
}
int i1 = 0, i2 = 0;
d.pref.clear();
if (a.pref[0].second == a.len)
for (; b.pref[i2].first < a.pref[0].first; ++i2)
d.pref.push_back(make_pair(b.pref[i2].first, a.len + b.pref[i2].second));
for (; i1 < a.pref.size();) {
if (a.pref[i1].first <= b.pref[i2].first) {
d.pref.push_back(
make_pair(a.pref[i1].first, a.pref[i1].second == a.len
? a.len + b.pref[i2].second
: a.pref[i1].second));
++i1;
} else
++i2;
}
i1 = 0, i2 = 0;
d.suf.clear();
if (b.suf[0].second == b.len)
for (; a.suf[i2].first < b.suf[0].first; ++i2)
d.suf.push_back(make_pair(a.suf[i2].first, b.len + a.suf[i2].second));
for (; i1 < b.suf.size();) {
if (b.suf[i1].first <= a.suf[i2].first) {
d.suf.push_back(make_pair(b.suf[i1].first, b.suf[i1].second == b.len
? b.len + a.suf[i2].second
: b.suf[i1].second));
++i1;
} else
++i2;
}
}
void bld(int l, int r, int i) {
if (l == r) {
int j = 0;
for (; j < ss[l].size() && j < ss[l + 1].size() && ss[l][j] == ss[l + 1][j];
++j)
;
tree[i].len = 1;
tree[i].max = max(j * 2, (int)max(ss[l].size(), ss[l + 1].size()));
tree[i].pref = {make_pair(j, 1), make_pair(INF, 0)};
tree[i].suf = {make_pair(j, 1), make_pair(INF, 0)};
} else {
int m = (l + r) / 2;
bld(l, m, 2 * i);
bld(m + 1, r, 2 * i + 1);
cmb(tree[i], tree[2 * i], tree[2 * i + 1]);
}
}
void upd(int i2, int i, int l, int r) {
if (l == r) {
int j = 0;
for (; j < ss[l].size() && j < ss[l + 1].size() && ss[l][j] == ss[l + 1][j];
++j)
;
tree[i].max = max(j * 2, (int)max(ss[l].size(), ss[l + 1].size()));
tree[i].pref[0].first = tree[i].suf[0].first = j;
} else {
int m = (l + r) / 2;
if (i2 <= m)
upd(i2, 2 * i, l, m);
else
upd(i2, 2 * i + 1, m + 1, r);
cmb(tree[i], tree[2 * i], tree[2 * i + 1]);
}
}
dat qry(int l2, int r2, int i, int l, int r) {
if (l2 <= l && r <= r2) return tree[i];
dat res;
int m = (l + r) / 2;
bool lc = l2 <= m, rc = m < r2;
if (lc && rc) {
dat lr = qry(l2, r2, 2 * i, l, m), rr = qry(l2, r2, 2 * i + 1, m + 1, r);
cmb(res, lr, rr);
} else if (lc)
res = qry(l2, r2, 2 * i, l, m);
else
res = qry(l2, r2, 2 * i + 1, m + 1, r);
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> q;
for (int i = 0; i < n; ++i) cin >> ss[i];
if (n > 1) bld(0, n - 2, 1);
while (q--) {
cin >> qt;
if (qt == 1) {
int a, b;
cin >> a >> b;
--a, --b;
cout << (a == b ? ss[a].size() : qry(a, b - 1, 1, 0, n - 2).max) << "\n";
} else {
int x;
cin >> x;
--x;
cin >> ss[x];
if (n > 1) {
if (x) upd(x - 1, 1, 0, n - 2);
upd(x, 1, 0, n - 2);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int ch[maxn][26];
int root, tot;
int dfn[maxn * 2], in[maxn], idx = 0, dep[maxn];
void dfs(int u) {
dfn[in[u] = ++idx] = u;
for (int i = (0); i < (26); ++i) {
if (ch[u][i] == 0) continue;
dep[ch[u][i]] = dep[u] + 1;
dfs(ch[u][i]);
dfn[++idx] = u;
}
}
int Min(int x, int y) { return (dep[x] < dep[y]) ? x : y; }
int f[maxn * 2][20];
int lg2[maxn * 2];
int lca(int x, int y) {
x = in[x], y = in[y];
if (x > y) swap(x, y);
int k = lg2[y - x + 1];
return Min(f[x][k], f[y - (1 << k) + 1][k]);
}
void init_lca() {
lg2[0] = -1;
for (int i = (1); i < (idx + 1); ++i)
f[i][0] = dfn[i], lg2[i] = lg2[i >> 1] + 1;
for (int j = 1; j < 19; ++j) {
for (int i = 1; i + (1 << j) - 1 <= idx; ++i)
f[i][j] = Min(f[i][j - 1], f[i + (1 << (j - 1))][j - 1]);
}
}
int ip[maxn];
int n, m;
int op[maxn], a[maxn], b[maxn];
char s[maxn];
void init() {
root = tot = 1;
cin >> n >> m;
for (int i = (1); i < (n + 1); ++i) {
scanf("%s", s);
int len = strlen(s);
int p = root;
for (int j = (0); j < (len); ++j) {
int x = s[j] - 'a';
if (!ch[p][x]) ch[p][x] = ++tot;
p = ch[p][x];
}
ip[i] = p;
}
for (int i = (1); i < (m + 1); ++i) {
scanf("%d", &op[i]);
if (op[i] == 1)
scanf("%d%d", &a[i], &b[i]);
else {
scanf("%d", &a[i]);
scanf("%s", s);
int len = strlen(s);
int p = root;
for (int j = (0); j < (len); ++j) {
int x = s[j] - 'a';
if (!ch[p][x]) ch[p][x] = ++tot;
p = ch[p][x];
}
b[i] = p;
}
}
dfs(root);
init_lca();
}
struct node {
vector<pair<int, int> > f, g;
int ans;
node() {
f.clear();
g.clear();
ans = 0;
}
} t[maxn << 2];
node merge(node a, node b) {
node tmp;
tmp.f = a.f;
for (int i = (0); i < (b.f.size()); ++i) {
int u = b.f[i].first;
int id = b.f[i].second;
assert(tmp.f.size());
int pre = tmp.f[tmp.f.size() - 1].first;
int p = lca(u, pre);
if (p != pre)
tmp.f.push_back(pair<int, int>(p, id));
else
tmp.f[tmp.f.size() - 1].second = id;
}
tmp.g = b.g;
for (int i = (0); i < (a.g.size()); ++i) {
int u = a.g[i].first;
int id = a.g[i].second;
assert(tmp.g.size());
int pre = tmp.g[tmp.g.size() - 1].first;
int p = lca(u, pre);
if (p != pre)
tmp.g.push_back(pair<int, int>(p, id));
else
tmp.g[tmp.g.size() - 1].second = id;
}
tmp.ans = max(a.ans, b.ans);
int rp = 0;
for (int i = (0); i < (a.g.size()); ++i) {
int u = a.g[i].first;
int id1 = a.g[i].second;
while (rp + 1 < b.f.size()) {
int v1 = b.f[rp].first;
int v2 = b.f[rp + 1].first;
int p1 = lca(u, v1);
int p2 = lca(u, v2);
if (dep[p1] <= dep[p2])
rp++;
else
break;
}
int v = b.f[rp].first;
int id2 = b.f[rp].second;
int p = lca(u, v);
tmp.ans = max(tmp.ans, (id2 - id1 + 1) * dep[p]);
}
int lp = 0;
for (int i = (0); i < (b.f.size()); ++i) {
int v = b.f[i].first;
int id2 = b.f[i].second;
while (lp + 1 < a.g.size()) {
int u1 = a.g[lp].first;
int u2 = a.g[lp + 1].first;
int p1 = lca(v, u1);
int p2 = lca(v, u2);
if (dep[p1] <= dep[p2])
lp++;
else
break;
}
int u = a.g[lp].first;
int id1 = a.g[lp].second;
int p = lca(u, v);
tmp.ans = max(tmp.ans, (id2 - id1 + 1) * dep[p]);
}
return tmp;
}
void build(int rt, int l, int r) {
if (l == r) {
t[rt].f.push_back(pair<int, int>(ip[l], l));
t[rt].g.push_back(pair<int, int>(ip[l], l));
t[rt].ans = dep[ip[l]];
return;
}
build(rt << 1, l, ((l + r) >> 1));
build(rt << 1 | 1, ((l + r) >> 1) + 1, r);
t[rt] = merge(t[rt << 1], t[rt << 1 | 1]);
return;
}
void update(int rt, int l, int r, int pos, int x) {
if (l == r) {
t[rt].f.clear();
t[rt].f.push_back(pair<int, int>(x, l));
t[rt].g.clear();
t[rt].g.push_back(pair<int, int>(x, l));
t[rt].ans = dep[x];
return;
}
if (pos <= ((l + r) >> 1))
update(rt << 1, l, ((l + r) >> 1), pos, x);
else
update(rt << 1 | 1, ((l + r) >> 1) + 1, r, pos, x);
t[rt] = merge(t[rt << 1], t[rt << 1 | 1]);
return;
}
node qry(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return t[rt];
}
if (L <= ((l + r) >> 1) && R > ((l + r) >> 1)) {
return merge(qry(rt << 1, l, ((l + r) >> 1), L, R),
qry(rt << 1 | 1, ((l + r) >> 1) + 1, r, L, R));
} else if (L <= ((l + r) >> 1))
return qry(rt << 1, l, ((l + r) >> 1), L, R);
else
return qry(rt << 1 | 1, ((l + r) >> 1) + 1, r, L, R);
}
void sol() {
build(1, 1, n);
for (int i = (1); i < (m + 1); ++i) {
if (op[i] == 1) {
node tmp = qry(1, 1, n, a[i], b[i]);
printf("%d\n", tmp.ans);
} else {
update(1, 1, n, a[i], b[i]);
}
}
}
int main() {
init();
sol();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 19;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const int MAXN = 100005;
struct tree1 {
private:
int mx;
int l;
int r;
tree1 *lson;
tree1 *rson;
public:
tree1() {
mx = 0;
lson = rson = NULL;
}
void build(int L, int R) {
l = L;
r = R;
if (l == r) return;
lson = new tree1;
rson = new tree1;
int mid = (l + r) / 2;
lson->build(l, mid);
rson->build(mid + 1, r);
}
void modify(int id, int k) {
if (l == r) {
mx = k;
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
mx = max(lson->mx, rson->mx);
}
int query(int L, int R) {
if (l >= L && r <= R) return mx;
int mid = (l + r) / 2;
if (R <= mid) return lson->query(L, R);
if (L > mid) return rson->query(L, R);
return max(lson->query(L, R), rson->query(L, R));
}
};
struct line {
int k;
int b;
line(int K = 0, int B = 0) {
k = K;
b = B;
}
int calc(int x) { return k * x + b; }
double cross(line t) { return (double)(t.b - b) / (k - t.k); }
};
struct tree {
bool tag;
int l;
int r;
line *L;
int cnt;
line *R;
int rcnt;
int mx;
tree *lson;
tree *rson;
tree() {
tag = false;
L = R = NULL;
cnt = rcnt = mx = 0;
lson = rson = NULL;
}
void fixup() {
static line tmp[MAXN];
l = lson->l;
r = rson->r;
if (L) delete L;
L = new line[lson->cnt + rson->cnt];
cnt = lson->cnt;
for (int i = 0; i < cnt; i++) L[i] = lson->L[i];
for (int i = 0; i < rson->cnt; i++) {
if (rson->L[i].k >= L[cnt - 1].k)
L[cnt - 1].b = (lson->r - lson->l + 1) + rson->L[i].b;
else {
L[cnt++] = rson->L[i];
L[cnt - 1].b += (lson->r - lson->l + 1);
}
}
if (R) delete R;
R = new line[lson->rcnt + rson->rcnt];
rcnt = rson->rcnt;
for (int i = 0; i < rcnt; i++) R[i] = rson->R[i];
for (int i = 0; i < lson->rcnt; i++) {
if (lson->R[i].k >= R[rcnt - 1].k)
R[rcnt - 1].b = (rson->r - rson->l + 1) + lson->R[i].b;
else {
R[rcnt++] = lson->R[i];
R[rcnt - 1].b += (rson->r - rson->l + 1);
}
}
mx = max(lson->mx, rson->mx);
int cur = 0, p = 0, s = 0;
memset(tmp, 0, sizeof(line) * rson->cnt);
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
for (int i = 0; i < lson->rcnt; i++) {
while (cur < rson->cnt && rson->L[cur].k < lson->R[i].k) {
line t = rson->L[cur++];
t.b = (t.b + 1) * t.k;
while (s > 1 && tmp[s - 2].cross(t) < tmp[s - 2].cross(tmp[s - 1])) s--;
if (p >= s) p = max(s - 1, 0);
tmp[s++] = t;
}
while (p < s - 1 &&
tmp[p].calc(lson->R[i].b) < tmp[p + 1].calc(lson->R[i].b))
p++;
if (cur < rson->cnt)
mx = max(mx, (lson->R[i].b + rson->L[cur].b + 1) * lson->R[i].k);
mx = max(mx, tmp[p].calc(lson->R[i].b));
}
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
}
void build(int rL, int rR, int *a) {
tag = true;
l = rL;
r = rR;
if (l == r) {
mx = a[l] * 2;
L = new line[1];
R = new line[1];
cnt = rcnt = 1;
L[0] = R[0] = line(a[l], 1);
return;
}
int mid = (l + r) / 2;
lson = new tree;
rson = new tree;
lson->build(l, mid, a);
rson->build(mid + 1, r, a);
fixup();
}
void modify(int id, int k) {
if (l == r) {
mx = k * 2;
L[0] = R[0] = line(k, 1);
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
fixup();
}
tree *query(int rL, int rR) {
if (l >= rL && r <= rR) return this;
int mid = (l + r) / 2;
if (rR <= mid) return lson->query(rL, rR);
if (rL > mid) return rson->query(rL, rR);
tree *temp = new tree;
temp->lson = lson->query(rL, rR);
temp->rson = rson->query(rL, rR);
temp->fixup();
return temp;
}
void query_clear() {
if (tag) return;
lson->query_clear();
rson->query_clear();
if (L) delete L;
if (R) delete R;
}
};
void print(int *a, int n) {
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
int N, q;
tree1 T1;
tree T;
char *s[MAXN], str[MAXN];
int len[MAXN], lcp[MAXN];
void init() {
scanf("%d %d", &N, &q);
T1.build(1, N);
for (int i = 1; i <= N; i++) {
scanf("%s", str);
len[i] = strlen(str);
s[i] = new char[len[i]];
memcpy(s[i], str, sizeof(char) * len[i]);
T1.modify(i, len[i]);
}
for (int i = 1; i < N; i++) {
int t = 0;
while (t < len[i] && t < len[i + 1] && s[i][t] == s[i + 1][t]) t++;
lcp[i] = t;
}
if (N > 1) T.build(1, N - 1, lcp);
}
int main() {
int ty, x, y;
init();
for (int i = 0; i < q; i++) {
scanf("%d %d", &ty, &x);
if (ty == 1) {
scanf("%d", &y);
int ans = T1.query(x, y);
if (x == y) {
printf("%d\n", ans);
continue;
}
tree *p = T.query(x, y - 1);
ans = max(ans, p->mx);
p->query_clear();
if (!p->l && !p->r) delete p;
std::cout << ans << std::endl;
} else {
scanf("%s", str);
len[x] = strlen(str);
s[x] = new char[len[x]];
memcpy(s[x], str, sizeof(char) * len[x]);
T1.modify(x, len[x]);
int t = 0;
if (x > 1) {
for (t = 0; t < len[x - 1] && t < len[x] && s[x - 1][t] == s[x][t]; t++)
;
lcp[x - 1] = t;
T.modify(x - 1, t);
}
if (x < N) {
for (t = 0; t < len[x] && t < len[x + 1] && s[x][t] == s[x + 1][t]; t++)
;
lcp[x] = t;
T.modify(x, t);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int SQ = 80;
int n, q;
string s[MAX];
int lcp[MAX];
set<int> active;
const int LIM = 3e5 + 5;
struct node {
int lsuf[SQ], rsuf[SQ], maxi, len;
node() {
maxi = len = 0;
for (int i = 0; i < SQ; i++) {
lsuf[i] = rsuf[i] = 0;
}
}
node(int x) {
x = min(SQ - 1, x);
maxi = x;
len = 1;
for (int i = 0; i < SQ; i++) {
lsuf[i] = rsuf[i] = (i <= x);
}
}
node operator+(const node& other) {
node res;
res.maxi = max(other.maxi, maxi);
res.len = other.len + len;
for (int i = 0; i < SQ; i++) {
res.lsuf[i] = lsuf[i];
if (len == lsuf[i]) {
res.lsuf[i] += other.lsuf[i];
}
res.rsuf[i] = other.rsuf[i];
if (other.rsuf[i] == other.len) {
res.rsuf[i] += rsuf[i];
}
if (rsuf[i] || other.lsuf[i]) {
res.maxi = max(res.maxi, i * (rsuf[i] + other.lsuf[i] + 1));
}
}
return res;
}
} segt[LIM];
int seg[LIM];
void combine(int t) { seg[t] = max(seg[t * 2], seg[t * 2 + 1]); }
void build(int t, int i, int j) {
if (i == j) {
seg[t] = s[i].length();
return;
}
int mid = (i + j) / 2;
build(t * 2, i, mid);
build(t * 2 + 1, mid + 1, j);
combine(t);
}
void update(int t, int i, int j, int x) {
if (i > x || j < x) {
return;
}
if (i == j) {
seg[t] = s[i].length();
return;
}
int mid = (i + j) / 2;
update(t * 2, i, mid, x);
update(t * 2 + 1, mid + 1, j, x);
combine(t);
}
int query(int t, int i, int j, int l, int r) {
if (i > r || j < l) {
return 0;
}
if (l <= i && j <= r) {
return seg[t];
}
int mid = (i + j) / 2;
int a = query(t * 2, i, mid, l, r);
int b = query(t * 2 + 1, mid + 1, j, l, r);
return max(a, b);
}
void combine2(int t) { segt[t] = segt[t * 2] + segt[t * 2 + 1]; }
void build2(int t, int i, int j) {
if (i == j) {
segt[t] = node(lcp[i]);
return;
}
int mid = (i + j) / 2;
build2(t * 2, i, mid);
build2(t * 2 + 1, mid + 1, j);
combine2(t);
}
void update2(int t, int i, int j, int x) {
if (i > x || j < x) {
return;
}
if (i == j) {
segt[t] = node(lcp[i]);
return;
}
int mid = (i + j) / 2;
update2(t * 2, i, mid, x);
update2(t * 2 + 1, mid + 1, j, x);
combine2(t);
}
node query2(int t, int i, int j, int l, int r) {
if (i > r || j < l) {
return node(0);
}
if (l <= i && j <= r) {
return segt[t];
}
int mid = (i + j) / 2;
node a = query2(t * 2, i, mid, l, r);
node b = query2(t * 2 + 1, mid + 1, j, l, r);
return (a + b);
}
int lc(int x, int y) {
int ptr = 0;
while (ptr < s[x].length() && ptr < s[y].length() && s[x][ptr] == s[y][ptr]) {
ptr++;
}
return ptr;
}
int solve1(int a, int b) {
b--;
if (a > b) {
return s[a].length();
}
int an = query2(1, 1, n - 1, a, b).maxi;
b++;
an = max(an, query(1, 1, n, a, b));
return an;
}
vector<int> tmp;
int rgt[2 * MAX];
int lft[2 * MAX];
stack<int> st;
int solve2(int a, int b) {
b--;
if (a > b) {
return s[a].length();
}
set<int>::iterator it = active.lower_bound(a);
set<int>::iterator it1 = active.upper_bound(b);
int last = -1;
for (; it != it1; it++) {
if ((*it) != (last + 1)) {
tmp.push_back(0);
}
tmp.push_back(lcp[*it]);
last = (*it);
}
for (int i = 0; i < tmp.size(); i++) {
while (st.size() > 0 && tmp[st.top()] >= tmp[i]) {
st.pop();
}
if (!st.size()) {
lft[i] = -1;
} else {
lft[i] = st.top();
}
st.push(i);
}
while (!st.empty()) {
st.pop();
}
for (int i = tmp.size() - 1; i >= 0; i--) {
int u = tmp[i];
while (st.size() > 0 && tmp[st.top()] >= tmp[i]) {
st.pop();
}
if (!st.size()) {
rgt[i] = tmp.size();
} else {
rgt[i] = st.top();
}
st.push(i);
}
while (!st.empty()) {
st.pop();
}
int ans = 0;
for (int i = 0; i < tmp.size(); i++) {
int u = tmp[i];
ans = max(ans, u * (rgt[i] - lft[i]));
}
tmp.clear();
return ans;
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
for (int i = 1; i < n; i++) {
lcp[i] = lc(i, i + 1);
}
build(1, 1, n);
if (n > 1) build2(1, 1, n - 1);
for (int i = 1; i < n; i++) {
if (lcp[i] >= SQ) {
active.insert(i);
}
}
for (int i = 1; i <= q; i++) {
int typ;
scanf("%d", &typ);
if (typ == 1) {
int a, b;
scanf("%d %d", &a, &b);
printf("%d\n", max(solve1(a, b), solve2(a, b)));
} else {
int a;
string b;
scanf("%d", &a);
cin >> b;
s[a] = b;
update(1, 1, n, a);
if (a < n) {
if (lcp[a] >= SQ) {
active.erase(a);
}
lcp[a] = lc(a, a + 1);
if (lcp[a] >= SQ) {
active.insert(a);
}
update2(1, 1, n - 1, a);
}
if (a > 1) {
if (lcp[a - 1] >= SQ) {
active.erase(a - 1);
}
lcp[a - 1] = lc(a - 1, a);
if (lcp[a - 1] >= SQ) {
active.insert(a - 1);
}
update2(1, 1, n - 1, a - 1);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 30;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
std::string a[100001];
int lcp[100001], N, Q;
struct node {
int ans;
std::vector<std::pair<int, int> > L, R;
} T[262144];
node merge(const node &L, const node &R, int m) {
node res;
res.ans = std::max(L.ans, R.ans);
res.L = L.L;
for (auto i = L.R.end() - 1, j = R.L.end() - 1; i >= L.R.begin(); i--) {
while (j > R.L.begin() && j->first < i->first) j--;
if (j->first < i->first) break;
res.ans = std::max(
res.ans, (j->second - i->second + 1) * std::min(lcp[m], i->first));
}
for (auto i = R.L.end() - 1, j = L.R.end() - 1; i >= R.L.begin(); i--) {
while (j > L.R.begin() && j->first < i->first) j--;
if (j->first < i->first) break;
res.ans = std::max(
res.ans, (i->second - j->second + 1) * std::min(lcp[m], i->first));
}
for (auto i : R.L) {
i.first = std::min(i.first, lcp[m]);
if (i.first >= res.L.back().first)
res.L.back().second = i.second;
else
res.L.push_back(i);
}
res.R = R.R;
for (auto i : L.R) {
i.first = std::min(i.first, lcp[m]);
if (i.first >= res.R.back().first)
res.R.back().second = i.second;
else
res.R.push_back(i);
}
return res;
}
void build(int p, int l, int r) {
if (l == r) {
T[p].ans = a[l].length();
T[p].L = T[p].R = {{a[l].length(), l}};
return;
}
int m = (l + r) >> 1;
build(p << 1, l, m);
build(p << 1 | 1, m + 1, r);
T[p] = merge(T[p << 1], T[p << 1 | 1], m);
}
node G(int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return T[p];
int m = l + r >> 1;
if (R <= m) return G(p << 1, l, m, L, R);
if (L > m) return G(p << 1 | 1, m + 1, r, L, R);
return merge(G(p << 1, l, m, L, R), G(p << 1 | 1, m + 1, r, L, R), m);
}
void update(int p, int l, int r, int x) {
if (l == r) {
T[p].ans = a[l].length();
T[p].L = T[p].R = {{a[l].length(), l}};
return;
}
int m = l + r >> 1;
if (x <= m) update(p << 1, l, m, x);
if (x >= m) update(p << 1 | 1, m + 1, r, x);
T[p] = merge(T[p << 1], T[p << 1 | 1], m);
}
int main() {
scanf("%d%d", &N, &Q);
for (int i = 1; i <= N; i++) std::cin >> a[i];
for (int i = 1; i < N; i++)
while (a[i][lcp[i]] == a[i + 1][lcp[i]]) lcp[i]++;
build(1, 1, N);
while (Q--) {
int ty;
scanf("%d", &ty);
if (ty == 1) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", G(1, 1, N, l, r).ans);
} else {
int x;
scanf("%d", &x);
std::cin >> a[x];
if (x > 1) {
lcp[x - 1] = 0;
while (a[x - 1][lcp[x - 1]] == a[x][lcp[x - 1]]) lcp[x - 1]++;
update(1, 1, N, x - 1);
}
if (x < N) {
lcp[x] = 0;
while (a[x][lcp[x]] == a[x + 1][lcp[x]]) lcp[x]++;
update(1, 1, N, x);
}
update(1, 1, N, x);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 15;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = 269000;
const int blc = 60;
const int root = 1;
int fa[N][18];
int dep[N];
int ch[N][26];
int tot = 1;
int len[N], lcp[N], p[N];
int a[N], cnt;
int father[N], L[N], R[N], vis[N];
int n;
char str[N];
struct SEG1 {
int seg[M];
inline void update(int node) {
seg[node] = max(seg[node << 1], seg[node << 1 | 1]);
}
void build(int node, int l, int r) {
if (l == r) {
seg[node] = len[l];
return;
}
int mid = l + r >> 1;
build(node << 1, l, mid);
build(node << 1 | 1, mid + 1, r);
update(node);
}
void cg(int node, int l, int r, int x, int w) {
if (l > x || r < x) return;
if (l == r) {
seg[node] = w;
return;
}
int mid = l + r >> 1;
cg(node << 1, l, mid, x, w);
cg(node << 1 | 1, mid + 1, r, x, w);
update(node);
}
int query(int node, int l, int r, int fl, int fr) {
if (fl <= l && r <= fr) return seg[node];
int mid = l + r >> 1;
if (mid >= fr)
return query(node << 1, l, mid, fl, fr);
else if (mid + 1 <= fl)
return query(node << 1 | 1, mid + 1, r, fl, fr);
else
return max(query(node << 1, l, mid, fl, fr),
query(node << 1 | 1, mid + 1, r, fl, fr));
}
};
struct data {
int ls, rs, ans;
data() {}
data(int ls, int rs, int ans) : ls(ls), rs(rs), ans(ans) {}
};
data cur;
struct SEG2 {
data seg[M];
bool ok[M];
inline void update(int node) {
ok[node] = ok[node << 1] && ok[node << 1 | 1];
seg[node].ls = ok[node << 1] ? seg[node << 1].ls + seg[node << 1 | 1].ls
: seg[node << 1].ls;
seg[node].rs = ok[node << 1 | 1] ? seg[node << 1 | 1].rs + seg[node << 1].rs
: seg[node << 1 | 1].rs;
seg[node].ans = max(seg[node << 1].rs + seg[node << 1 | 1].ls,
max(seg[node << 1].ans, seg[node << 1 | 1].ans));
}
void cg(int node, int l, int r, int x, int w) {
if (l > x || r < x) return;
if (l == r) {
seg[node].ls = seg[node].rs = seg[node].ans = ok[node] = w;
return;
}
int mid = l + r >> 1;
cg(node << 1, l, mid, x, w);
cg(node << 1 | 1, mid + 1, r, x, w);
update(node);
}
void query(int node, int l, int r, int fl, int fr) {
if (l > fr || r < fl) return;
if (fl <= l && r <= fr) {
cur.ans = max(cur.ans, max(seg[node].ans, cur.rs + seg[node].ls));
cur.rs = ok[node] ? seg[node].rs + cur.rs : seg[node].rs;
return;
}
int mid = l + r >> 1;
query(node << 1, l, mid, fl, fr);
query(node << 1 | 1, mid + 1, r, fl, fr);
}
};
SEG2 s[blc + 1];
SEG1 S;
int lca(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int i, delta = dep[x] - dep[y];
for (i = 0; i <= 17; i++)
if (1 << i & delta) x = fa[x][i];
if (x == y) return dep[x];
for (i = 17; i >= 0; i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return dep[fa[x][0]];
}
void insert(int id) {
scanf("%s", str + 1);
len[id] = strlen(str + 1);
int x = root, i, j;
for (i = 1; i <= len[id]; i++) {
if (!ch[x][str[i] - 'a']) {
ch[x][str[i] - 'a'] = ++tot;
dep[tot] = dep[x] + 1;
fa[tot][0] = x;
for (j = 1; j <= 17; j++) fa[tot][j] = fa[fa[tot][j - 1]][j - 1];
}
x = ch[x][str[i] - 'a'];
}
p[id] = x;
}
bool cmp(int x, int y) { return lcp[x] < lcp[y]; }
void erase(int id) {
register int i, j;
for (i = 1; i <= cnt; i++)
if (a[i] == id) break;
for (j = i + 1; j <= cnt; j++) a[j - 1] = a[j];
cnt--;
}
void add(int id) {
register int i;
a[++cnt] = id;
for (i = cnt - 1; i; i--)
if (lcp[a[i]] > lcp[a[i + 1]]) swap(a[i], a[i + 1]);
}
void work(int id) {
int pre, now;
register int i;
pre = lcp[id];
now = lcp[id] = lca(p[id], p[id + 1]);
if (pre > blc) erase(id);
if (now > blc) add(id);
if (pre < now)
for (i = min(blc, pre) + 1; i <= min(blc, now); i++)
s[i].cg(1, 1, n - 1, id, 1);
if (now < pre)
for (i = min(now, blc) + 1; i <= min(blc, pre); i++)
s[i].cg(1, 1, n - 1, id, 0);
}
int find(int x) {
if (father[x] != x) father[x] = find(father[x]);
return father[x];
}
int main() {
int j, Q, opt, l, r, x, ans;
register int i;
scanf("%d%d", &n, &Q);
for (i = 1; i <= n; i++) insert(i);
S.build(1, 1, n);
for (i = 1; i <= n - 1; i++) lcp[i] = lca(p[i], p[i + 1]);
for (i = 1; i <= n - 1; i++) {
for (j = 1; j <= min(blc, lcp[i]); j++) s[j].cg(1, 1, n - 1, i, 1);
if (lcp[i] > blc) a[++cnt] = i;
}
sort(a + 1, a + 1 + cnt, cmp);
for (i = 1; i <= n; i++) father[i] = L[i] = R[i] = i, vis[i] = 0;
while (Q--) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d%d", &l, &r);
ans = S.query(1, 1, n, l, r);
if (l == r) {
printf("%d\n", ans);
continue;
}
for (i = 1; i <= blc; i++) {
cur = data(0, 0, 0);
s[i].query(1, 1, n - 1, l, r - 1);
if (cur.ans) ans = max(ans, i * (cur.ans + 1));
}
for (i = cnt; i; i--)
if (l <= a[i] && a[i] <= r - 1) {
vis[a[i]] = 1;
if (a[i] > l && vis[a[i] - 1]) {
x = find(a[i] - 1);
father[x] = a[i];
L[a[i]] = L[x];
}
if (a[i] < r - 1 && vis[a[i] + 1]) {
x = find(a[i] + 1);
father[x] = a[i];
R[a[i]] = R[x];
}
ans = max(ans, (R[a[i]] - L[a[i]] + 2) * lcp[a[i]]);
}
for (i = cnt; i; i--) {
vis[a[i]] = 0;
father[a[i]] = L[a[i]] = R[a[i]] = a[i];
}
printf("%d\n", ans);
}
if (opt == 2) {
scanf("%d", &x);
insert(x);
S.cg(1, 1, n, x, len[x]);
if (x > 1) work(x - 1);
if (x < n) work(x);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 5;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long sq(long long x) { return (x * x) % MOD; }
long long modP(long long a, long long b) {
return (!b ? 1 : (sq(modP(a, b / 2)) * (b % 2 ? a : 1)) % MOD);
}
int n, a[maxN], l[maxN], r[maxN], t[maxN];
long long res[maxN];
string str[maxN], s[maxN], qS[maxN];
vector<int> vec;
int LCP(string s1, string s2) {
int ans = 0;
while (ans < (int)min(s1.size(), s2.size()) && s1[ans] == s2[ans]) ans++;
return ans;
}
int tmp[4 * maxN];
void update(int p, int x, int id = 1, int s = 0, int e = n) {
if (e - s <= 1) {
tmp[id] = x;
return;
}
int md = (s + e) / 2;
if (p < md)
update(p, x, 2 * id, s, md);
else
update(p, x, 2 * id + 1, md, e);
tmp[id] = max(tmp[2 * id], tmp[2 * id + 1]);
return;
}
int bitch(int lt, int rt, int id = 1, int s = 0, int e = n) {
if (lt <= s && e <= rt) return tmp[id];
if (lt >= e || s >= rt) return 0;
int md = (s + e) / 2;
return max(bitch(lt, rt, 2 * id, s, md), bitch(lt, rt, 2 * id + 1, md, e));
}
struct node {
int val, lt, rt;
bool flag;
void fill(int x) { val = lt = rt = flag = x; }
node() { fill(0); }
} seg[4 * maxN];
node operator+(node A, node B) {
node C;
C.flag = (A.flag & B.flag);
C.lt = A.lt + (A.flag ? B.lt : 0);
C.rt = B.rt + (B.flag ? A.rt : 0);
C.val = max(A.rt + B.lt, max(A.val, B.val));
return C;
}
void put(int p, int x, int id = 1, int s = 0, int e = n - 1) {
if (e - s <= 1) {
seg[id].fill(x);
return;
}
int md = (s + e) / 2;
if (p < md)
put(p, x, 2 * id, s, md);
else
put(p, x, 2 * id + 1, md, e);
seg[id] = seg[2 * id] + seg[2 * id + 1];
return;
}
node fetch(int lt, int rt, int id = 1, int s = 0, int e = n - 1) {
if (lt <= s && e <= rt) return seg[id];
if (lt >= e || s >= rt) return node();
int md = (s + e) / 2;
return (fetch(lt, rt, 2 * id, s, md) + fetch(lt, rt, 2 * id + 1, md, e));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> str[i];
s[i] = str[i];
update(i, (int)str[i].size());
}
for (int i = 0; i < n - 1; i++) {
a[i] = LCP(s[i], s[i + 1]);
vec.push_back(a[i]);
}
for (int i = 0; i < q; i++) {
cin >> t[i];
if (t[i] == 1) {
cin >> l[i] >> r[i];
l[i]--;
res[i] = bitch(l[i], r[i]);
r[i]--;
} else {
cin >> l[i] >> qS[i];
l[i]--;
s[l[i]] = qS[i];
update(l[i], (int)qS[i].size());
if (l[i] > 0) {
a[l[i] - 1] = LCP(s[l[i] - 1], s[l[i]]);
vec.push_back(a[l[i] - 1]);
}
if (l[i] < n - 1) {
a[l[i]] = LCP(s[l[i]], s[l[i] + 1]);
vec.push_back(a[l[i]]);
}
}
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (auto v : vec) {
for (int i = 0; i < n; i++) s[i] = str[i];
for (int i = 0; i < n - 1; i++) {
a[i] = LCP(s[i], s[i + 1]);
put(i, (a[i] >= v));
}
for (int i = 0; i < q; i++) {
if (t[i] == 1) {
int T = fetch(l[i], r[i]).val;
res[i] = max(res[i], (1ll + (T > 0 ? T : -1)) * (1ll * v));
} else {
s[l[i]] = qS[i];
if (l[i] > 0) {
a[l[i] - 1] = LCP(s[l[i] - 1], s[l[i]]);
put(l[i] - 1, (a[l[i] - 1] >= v));
}
if (l[i] < n - 1) {
a[l[i]] = LCP(s[l[i]], s[l[i] + 1]);
put(l[i], (a[l[i]] >= v));
}
}
}
}
for (int i = 0; i < q; i++)
if (t[i] % 2) cout << res[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long long int N = 4e5 + 10;
struct Node {
int a, b, ab, f;
friend Node operator+(Node X, Node Y) {
return {X.a + X.f * Y.a, Y.b + Y.f * X.b, max({X.ab, Y.ab, X.b + Y.a}),
X.f && Y.f};
}
};
long long int A[N];
int mx[N << 2], type[N], L[N], R[N], n, q;
vector<int> vec;
Node seg[N << 2];
string second[N], T[N], Q[N];
char C[N];
int LCP(int x, int y) {
if (max(x, y) > n || min(x, y) <= 0) return 0;
int z;
for (z = 0; z < min((int)T[x].size(), (int)T[y].size()) && T[x][z] == T[y][z];
z++)
;
return z;
}
void buildmax(int id = 1, int l = 1, int r = n + 1) {
if (r - l == 1) {
mx[id] = (int)T[l].size();
return;
}
int mid = (l + r) >> 1;
buildmax(id << 1, l, mid);
buildmax(id << 1 | 1, mid, r);
mx[id] = max(mx[id << 1], mx[id << 1 | 1]);
}
void updatemax(int pos, int id = 1, int l = 1, int r = n + 1) {
if (r - l == 1) {
mx[id] = (int)T[l].size();
return;
}
int mid = (l + r) >> 1;
if (pos < mid)
updatemax(pos, id << 1, l, mid);
else
updatemax(pos, id << 1 | 1, mid, r);
mx[id] = max(mx[id << 1 | 1], mx[id << 1]);
}
int getmax(int ql, int qr, int id = 1, int l = 1, int r = n + 1) {
if (qr <= l || r <= ql) return 0;
if (ql <= l && r <= qr) return mx[id];
int mid = (l + r) >> 1;
return max(getmax(ql, qr, id << 1, l, mid),
getmax(ql, qr, id << 1 | 1, mid, r));
}
void build(int x, int id = 1, int l = 1, int r = n) {
if (r - l == 1) {
if (LCP(l, r) >= x)
seg[id] = {1, 1, 1, 1};
else
seg[id] = {0, 0, 0, 0};
return;
}
int mid = (l + r) >> 1;
build(x, id << 1, l, mid);
build(x, id << 1 | 1, mid, r);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
void update(int pos, int x, int id = 1, int l = 1, int r = n) {
if (pos < l || pos >= r) return;
if (r - l == 1) {
seg[id] = {x, x, x, x};
return;
}
int mid = (l + r) >> 1;
if (pos < mid)
update(pos, x, id << 1, l, mid);
else
update(pos, x, id << 1 | 1, mid, r);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
Node get(int ql, int qr, int id = 1, int l = 1, int r = n) {
if (qr <= l || r <= ql) return Node{0, 0, 0, 0};
if (ql <= l && r <= qr) return seg[id];
int mid = (l + r) >> 1;
return get(ql, qr, id << 1, l, mid) + get(ql, qr, id << 1 | 1, mid, r);
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%s", C);
second[i] = C;
T[i] = second[i];
if (i > 1) vec.push_back(LCP(i, i - 1));
}
buildmax();
for (int i = 1; i <= q; i++) {
scanf("%d", &type[i]);
if (type[i] == 1) {
scanf("%d%d", &L[i], &R[i]);
A[i] = getmax(L[i], R[i] + 1);
} else {
scanf("%d%s", &L[i], C);
Q[i] = C;
T[L[i]] = C;
updatemax(L[i]);
vec.push_back(LCP(L[i], L[i] + 1));
vec.push_back(LCP(L[i] - 1, L[i]));
}
}
if (n == 1) {
for (int i = 1; i <= q; i++)
if (type[i] == 1) printf("%lld\n", A[i]);
exit(0);
}
sort(vec.begin(), vec.end());
vec.resize(unique(vec.begin(), vec.end()) - vec.begin());
for (int x : vec) {
for (int i = 1; i <= n; i++) T[i] = second[i];
build(x);
for (int i = 1; i <= q; i++) {
if (type[i] == 1) {
int t = get(L[i], R[i]).ab;
if (t) t++;
A[i] = max(A[i], 1LL * t * x);
} else {
T[L[i]] = Q[i];
update(L[i], LCP(L[i], L[i] + 1) >= x);
update(L[i] - 1, LCP(L[i] - 1, L[i]) >= x);
}
}
}
for (int i = 1; i <= q; i++)
if (type[i] == 1) printf("%lld\n", A[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int sz, l, r, best;
node() {
sz = -1;
l = r = -1;
best = -1;
}
node(int a) { *this = node(1, 0, 0, 0); }
node(int a, int b, int c, int d) {
sz = a;
l = b;
r = c;
best = d;
}
};
node operator+(node a, node b) {
if (a.sz == -1) return b;
if (b.sz == -1) return a;
node ans;
if (a.l == a.sz && b.r == b.sz)
ans = node(a.sz + b.sz, a.sz + b.sz, a.sz + b.sz, a.sz + b.sz);
else if (a.l == a.sz) {
ans = node(a.sz + b.sz, a.sz + b.l, b.r, max({a.best, b.best, a.sz + b.l}));
} else if (b.r == b.sz) {
ans = node(a.sz + b.sz, a.l, a.r + b.sz, max({a.best, b.best, a.r + b.sz}));
} else {
ans = node(a.sz + b.sz, a.l, b.r, max({a.best, b.best, a.r + b.l}));
}
return ans;
}
template <typename T>
class segment_tree {
private:
static const int default_size = 100001;
int my_size;
vector<T> tree;
void build(vector<T>& data, int id, int l, int r) {
if (l == r)
tree[id] = data[l];
else {
int mid = (l + r) >> 1;
build(data, id << id, l, mid);
build(data, id << 1 | 1, mid + 1, r);
tree[id] = tree[id << 1] + tree[id << 1 | 1];
}
}
void update(int id, int l, int r, int pos, T v) {
if (l == r)
tree[id] = v;
else {
int mid = (l + r) >> 1;
if (pos <= mid)
update(id << 1, l, mid, pos, v);
else
update(id << 1 | 1, mid + 1, r, pos, v);
tree[id] = tree[id << 1] + tree[id << 1 | 1];
}
}
T query(int id, int l, int r, int x, int y) {
if (l > y || r < x) return T();
if (x <= l && r <= y) return tree[id];
int mid = (l + r) >> 1;
return query(id << 1, l, mid, x, y) + query(id << 1 | 1, mid + 1, r, x, y);
}
public:
segment_tree() {}
segment_tree(int size) {
my_size = size;
clear();
}
void clear() { tree.assign(my_size << 2, T(0)); }
void build(vector<T>& data) {
data.resize(my_size);
build(data, 1, 0, my_size - 1);
}
void setPos(int pos, T value) { update(1, 0, my_size - 1, pos, value); }
void update(int pos, T value) { setPos(pos, value); }
T getPos(int pos) { return query(1, 0, my_size - 1, pos, pos); }
void addToPos(int pos, T value) { setPos(pos, getPos(pos) + value); }
T getInterval(int l, int r) { return query(1, 0, my_size - 1, l, r); }
T query(int l, int r) { return getInterval(l, r); }
};
struct histogram_solver {
vector<int> dp;
vector<int> he;
static long long solve(vector<int> values) {
stack<int> s;
int i = 0;
long long ans = 0;
while (i < values.size()) {
if (s.empty() || values[s.top()] <= values[i])
s.push(i++);
else {
int tp = s.top();
s.pop();
long long area = 1ll * values[tp] * (s.empty() ? i + 1 : i - s.top());
ans = max(ans, area);
}
}
while (!s.empty()) {
int tp = s.top();
s.pop();
long long area = 1ll * values[tp] * (s.empty() ? i + 1 : i - s.top());
ans = max(ans, area);
}
return ans;
}
};
const int maxn = 100100;
const int magic = 37;
segment_tree<node> trees[magic];
struct max_t {
long long value;
max_t() { value = -(1ll << 50); }
max_t(long long v) { value = v; }
max_t operator+(const max_t& other) { return max_t(max(value, other.value)); }
};
segment_tree<max_t> library;
string arr[maxn];
char str[maxn];
int lcp[maxn];
int solve(set<int>& B, int l, int r) {
int last = -1;
vector<int> to_apply;
for (int v : B) {
if (v >= l && v < r) {
if (last != -1 && last + 1 != v) to_apply.push_back(0);
to_apply.push_back(lcp[v]);
last = v;
}
}
histogram_solver lol;
return lol.solve(to_apply);
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int e = 0; e < n; e++) {
scanf("%s", str);
arr[e] = str;
}
for (int e = 0; e < n - 1; e++) {
while (lcp[e] < arr[e].size() && lcp[e] < arr[e + 1].size() &&
arr[e][lcp[e]] == arr[e + 1][lcp[e]])
lcp[e]++;
}
for (int e = 0; e < magic; e++) trees[e] = segment_tree<node>(n);
library = segment_tree<max_t>(n);
set<int> big;
for (int e = 0; e < n - 1; e++) {
for (int f = 0; f <= min(lcp[e], magic - 1); f++)
trees[f].update(e, node(1, 1, 1, 1));
if (lcp[e] >= magic) big.insert(e);
}
for (int e = 0; e < n; e++) library.update(e, arr[e].size());
cerr << "build " << clock() << " ms" << endl;
for (int e = 0; e < q; e++) {
int type;
scanf("%d", &type);
if (type == 1) {
int l, r;
scanf("%d %d", &l, &r);
l--;
r--;
int ans = library.query(l, r).value;
if (l < r) {
for (int f = 0; f < magic; f++) {
int sz = trees[f].query(l, r - 1).best;
if (sz == 0) sz--;
ans = max(ans, (sz + 1) * f);
}
ans = max(ans, solve(big, l, r));
}
printf("%d\n", ans);
} else {
int l;
scanf("%d %s", &l, str);
l--;
arr[l] = str;
library.update(l, arr[l].size());
if (l) {
if (lcp[l - 1] >= magic) big.erase(l - 1);
for (int f = 0; f <= min(magic - 1, lcp[l - 1]); f++)
trees[f].update(l - 1, node(0));
lcp[l - 1] = 0;
while (lcp[l - 1] < arr[l - 1].size() && lcp[l - 1] < arr[l].size() &&
arr[l - 1][lcp[l - 1]] == arr[l][lcp[l - 1]])
lcp[l - 1]++;
for (int f = 0; f <= min(magic - 1, lcp[l - 1]); f++)
trees[f].update(l - 1, node(1, 1, 1, 1));
if (lcp[l - 1] >= magic) big.insert(l - 1);
}
if (l < n - 1) {
if (lcp[l] >= magic) big.erase(l);
for (int f = 0; f <= min(magic - 1, lcp[l]); f++)
trees[f].update(l, node(0));
lcp[l] = 0;
while (lcp[l] < arr[l].size() && lcp[l] < arr[l + 1].size() &&
arr[l][lcp[l]] == arr[l + 1][lcp[l]])
lcp[l]++;
for (int f = 0; f <= min(magic - 1, lcp[l]); f++)
trees[f].update(l, node(1, 1, 1, 1));
if (lcp[l] >= magic) big.insert(l);
}
}
}
cerr << "over " << clock() << " ms" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 1e5 + 7;
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = a * a % M)
if (b & 1) ret = 1ll * ret * a % M;
return ret;
}
char a[maxn];
int S[maxn], L[maxn];
int lcp[maxn];
struct node {
long long max;
int lpos, rpos;
vector<pair<int, int> > L, R;
} T[maxn << 2];
node merge(const node &A, const node &B) {
node ret;
ret.max = max(A.max, B.max);
ret.lpos = A.lpos;
ret.rpos = B.rpos;
int i, j, pos = A.rpos;
j = B.L.size() - 1;
for (i = A.R.size() - 1; i >= 0; i--) {
while (j >= 0 && B.L[j].first < A.R[i].first) j--;
if (j < 0) break;
ret.max =
max(ret.max, 1ll * min(min(A.R[i].first, B.L[j].first), lcp[pos]) *
(B.L[j].second - A.R[i].second + 1));
}
i = A.R.size() - 1;
for (j = B.L.size() - 1; j >= 0; j--) {
while (i >= 0 && B.L[j].first > A.R[i].first) i--;
if (i < 0) break;
ret.max =
max(ret.max, 1ll * min(min(A.R[i].first, B.L[j].first), lcp[pos]) *
(B.L[j].second - A.R[i].second + 1));
}
ret.L = A.L;
for (auto now : B.L) {
now.first = min(lcp[pos], now.first);
if (now.first >= ret.L.back().first)
ret.L.back().second = now.second;
else
ret.L.push_back(now);
}
ret.R = B.R;
for (auto now : A.R) {
now.first = min(lcp[pos], now.first);
if (now.first >= ret.R.back().first)
ret.R.back().second = now.second;
else
ret.R.push_back(now);
}
return ret;
}
void build(int x, int l, int r) {
if (l == r) {
T[x].lpos = l;
T[x].rpos = r;
lcp[l] = 0;
while (lcp[l] < L[l] && lcp[l] < L[l + 1] &&
a[S[l] + lcp[l]] == a[S[l + 1] + lcp[l]])
lcp[l]++;
T[x].L.clear();
T[x].R.clear();
T[x].L.push_back(make_pair(L[l], l));
T[x].R.push_back(make_pair(L[r], r));
T[x].max = L[l];
return;
}
int mid = (l + r) / 2;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
T[x] = merge(T[x << 1], T[x << 1 | 1]);
}
node query(int x, int l, int r) {
int L = T[x].lpos, R = T[x].rpos;
if (l <= L && R <= r) return T[x];
int mid = (L + R) / 2;
if (r > mid && mid >= l)
return merge(query(x << 1, l, r), query(x << 1 | 1, l, r));
if (mid >= l) return query(x << 1, l, r);
if (r > mid) return query(x << 1 | 1, l, r);
}
void update(int x, int pos) {
int l = T[x].lpos, r = T[x].rpos;
if (l == r) {
lcp[l] = 0;
while (lcp[l] < L[l] && lcp[l] < L[l + 1] &&
a[S[l] + lcp[l]] == a[S[l + 1] + lcp[l]])
lcp[l]++;
T[x].L.clear();
T[x].R.clear();
T[x].L.push_back(make_pair(L[l], l));
T[x].R.push_back(make_pair(L[r], r));
T[x].max = L[l];
return;
}
int mid = (l + r) / 2;
if (mid >= pos)
update(x << 1, pos);
else
update(x << 1 | 1, pos);
T[x] = merge(T[x << 1], T[x << 1 | 1]);
}
int n, m;
int k;
int now;
int main() {
scanf("%d%d", &n, &m);
int i;
for (i = 1; i <= n; i++) {
scanf("%s", a + now);
S[i] = now;
L[i] = strlen(a + now);
now += L[i];
}
build(1, 1, n);
while (m--) {
scanf("%d", &k);
if (k == 1) {
int l, r;
scanf("%d%d", &l, &r);
node now = query(1, l, r);
printf("%I64d\n", query(1, l, r).max);
} else {
int pos;
scanf("%d", &pos);
scanf("%s", a + now);
S[pos] = now;
L[pos] = strlen(a + now);
now += L[pos];
update(1, pos);
if (pos != 1) update(1, pos - 1);
}
}
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
template <typename T>
T min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T max(T x, T y) {
return x > y ? x : y;
};
const int MAXN = 100005;
struct tree1 {
private:
int mx;
int l;
int r;
tree1 *lson;
tree1 *rson;
public:
tree1() {
mx = 0;
lson = rson = NULL;
}
void build(int L, int R) {
l = L;
r = R;
if (l == r) return;
lson = new tree1;
rson = new tree1;
int mid = (l + r) / 2;
lson->build(l, mid);
rson->build(mid + 1, r);
}
void modify(int id, int k) {
if (l == r) {
mx = k;
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
mx = max(lson->mx, rson->mx);
}
int query(int L, int R) {
if (l >= L && r <= R) return mx;
int mid = (l + r) / 2;
if (R <= mid) return lson->query(L, R);
if (L > mid) return rson->query(L, R);
return max(lson->query(L, R), rson->query(L, R));
}
};
struct line {
int k;
int b;
line(int K = 0, int B = 0) {
k = K;
b = B;
}
int calc(int x) { return k * x + b; }
double cross(line t) { return (double)(t.b - b) / (k - t.k); }
};
struct tree {
bool tag;
int l;
int r;
line *L;
int cnt;
line *R;
int rcnt;
int mx;
tree *lson;
tree *rson;
tree() {
tag = false;
L = R = NULL;
cnt = rcnt = mx = 0;
lson = rson = NULL;
}
void fixup() {
static line tmp[MAXN];
l = lson->l;
r = rson->r;
if (L) delete L;
L = new line[lson->cnt + rson->cnt];
cnt = lson->cnt;
for (int i = 0; i < cnt; i++) L[i] = lson->L[i];
for (int i = 0; i < rson->cnt; i++) {
if (rson->L[i].k >= L[cnt - 1].k)
L[cnt - 1].b = (lson->r - lson->l + 1) + rson->L[i].b;
else {
L[cnt++] = rson->L[i];
L[cnt - 1].b += (lson->r - lson->l + 1);
}
}
if (R) delete R;
R = new line[lson->rcnt + rson->rcnt];
rcnt = rson->rcnt;
for (int i = 0; i < rcnt; i++) R[i] = rson->R[i];
for (int i = 0; i < lson->rcnt; i++) {
if (lson->R[i].k >= R[rcnt - 1].k)
R[rcnt - 1].b = (rson->r - rson->l + 1) + lson->R[i].b;
else {
R[rcnt++] = lson->R[i];
R[rcnt - 1].b += (rson->r - rson->l + 1);
}
}
mx = max(lson->mx, rson->mx);
int cur = 0, p = 0, s = 0;
memset(tmp, 0, sizeof(line) * rson->cnt);
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
for (int i = 0; i < lson->rcnt; i++) {
while (cur < rson->cnt && rson->L[cur].k < lson->R[i].k) {
line t = rson->L[cur++];
t.b = (t.b + 1) * t.k;
while (s > 1 && tmp[s - 2].cross(t) < tmp[s - 2].cross(tmp[s - 1])) s--;
if (p >= s) p = max(s - 1, 0);
tmp[s++] = t;
}
while (p < s - 1 &&
tmp[p].calc(lson->R[i].b) < tmp[p + 1].calc(lson->R[i].b))
p++;
while (p && tmp[p].calc(lson->R[i].b) < tmp[p - 1].calc(lson->R[i].b))
p--;
if (cur < rson->cnt)
mx = max(mx, (lson->R[i].b + rson->L[cur].b + 1) * lson->R[i].k);
mx = max(mx, tmp[p].calc(lson->R[i].b));
}
std::reverse(lson->R, lson->R + lson->rcnt);
std::reverse(rson->L, rson->L + rson->cnt);
}
void build(int rL, int rR, int *a) {
tag = true;
l = rL;
r = rR;
if (l == r) {
mx = a[l] * 2;
L = new line[1];
R = new line[1];
cnt = rcnt = 1;
L[0] = R[0] = line(a[l], 1);
return;
}
int mid = (l + r) / 2;
lson = new tree;
rson = new tree;
lson->build(l, mid, a);
rson->build(mid + 1, r, a);
fixup();
}
void modify(int id, int k) {
if (l == r) {
mx = k * 2;
L[0] = R[0] = line(k, 1);
return;
}
int mid = (l + r) / 2;
if (id <= mid)
lson->modify(id, k);
else
rson->modify(id, k);
fixup();
}
tree *query(int rL, int rR) {
if (l >= rL && r <= rR) return this;
int mid = (l + r) / 2;
if (rR <= mid) return lson->query(rL, rR);
if (rL > mid) return rson->query(rL, rR);
tree *temp = new tree;
temp->lson = lson->query(rL, rR);
temp->rson = rson->query(rL, rR);
temp->fixup();
return temp;
}
void query_clear() {
if (tag) return;
lson->query_clear();
rson->query_clear();
if (L) delete L;
if (R) delete R;
}
};
void print(int *a, int n) {
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
int N, q;
tree1 T1;
tree T;
char *s[MAXN], str[MAXN];
int len[MAXN], lcp[MAXN];
void init() {
scanf("%d %d", &N, &q);
T1.build(1, N);
for (int i = 1; i <= N; i++) {
scanf("%s", str);
len[i] = strlen(str);
s[i] = new char[len[i]];
memcpy(s[i], str, sizeof(char) * len[i]);
T1.modify(i, len[i]);
}
for (int i = 1; i < N; i++) {
int t = 0;
while (t < len[i] && t < len[i + 1] && s[i][t] == s[i + 1][t]) t++;
lcp[i] = t;
}
if (N > 1) T.build(1, N - 1, lcp);
}
int main() {
int ty, x, y;
init();
for (int i = 0; i < q; i++) {
scanf("%d %d", &ty, &x);
if (ty == 1) {
scanf("%d", &y);
int ans = T1.query(x, y);
if (x == y) {
printf("%d\n", ans);
continue;
}
tree *p = T.query(x, y - 1);
ans = max(ans, p->mx);
p->query_clear();
if (!p->l && !p->r) delete p;
std::cout << ans << std::endl;
} else {
scanf("%s", str);
len[x] = strlen(str);
s[x] = new char[len[x]];
memcpy(s[x], str, sizeof(char) * len[x]);
T1.modify(x, len[x]);
int t = 0;
if (x > 1) {
for (t = 0; t < len[x - 1] && t < len[x] && s[x - 1][t] == s[x][t]; t++)
;
lcp[x - 1] = t;
T.modify(x - 1, t);
}
if (x < N) {
for (t = 0; t < len[x] && t < len[x + 1] && s[x][t] == s[x + 1][t]; t++)
;
lcp[x] = t;
T.modify(x, t);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const int MOD = 1e9 + 7;
const int N = 1e5 + 5;
int n, q, A[N], T[N], L[N], R[N], SEGMX[N << 2];
long long ANS[N];
string TMP[N], S[N], Q[N];
struct Node {
int pre, suf, mx;
bool flag;
Node() {}
Node(int _pre, int _suf, int _mx, bool _flag)
: pre(_pre), suf(_suf), mx(_mx), flag(_flag) {}
} SEG[N << 2];
Node Merge(const Node &x, const Node &y) {
return Node(x.pre + x.flag * y.pre, y.suf + y.flag * x.suf,
max(x.suf + y.pre, max(x.mx, y.mx)), x.flag & y.flag);
}
void UpdateMX(int p, int x, int id = 1, int s = 0, int e = n) {
if (e - s < 2) {
SEGMX[id] = x;
return;
}
int md = (s + e) >> 1;
if (p < md)
UpdateMX(p, x, id << 1, s, md);
else
UpdateMX(p, x, id << 1 | 1, md, e);
SEGMX[id] = max(SEGMX[id << 1], SEGMX[id << 1 | 1]);
}
void Update(int p, bool x, int id = 1, int s = 0, int e = n) {
if (e - s < 2) {
SEG[id] = Node(x, x, x, x);
return;
}
int md = (s + e) >> 1;
if (p < md)
Update(p, x, id << 1, s, md);
else
Update(p, x, id << 1 | 1, md, e);
SEG[id] = Merge(SEG[id << 1], SEG[id << 1 | 1]);
}
int GetMX(int l, int r, int id = 1, int s = 0, int e = n) {
if (l >= e || s >= r) return 0;
if (l <= s && e <= r) return SEGMX[id];
int md = (s + e) >> 1;
return max(GetMX(l, r, id << 1, s, md), GetMX(l, r, id << 1 | 1, md, e));
}
Node Get(int l, int r, int id = 1, int s = 0, int e = n) {
if (l >= e || s >= r) return Node(0, 0, 0, 0);
if (l <= s && e <= r) return SEG[id];
int md = (s + e) >> 1;
return Merge(Get(l, r, id << 1, s, md), Get(l, r, id << 1 | 1, md, e));
}
int LCP(string &s, string &t) {
int ans = 0;
while (ans < (int)(s.size()) && ans < (int)(t.size()) && s[ans] == t[ans])
ans++;
return ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> q;
vector<int> comp;
for (int i = 0; i < n; i++)
cin >> S[i], TMP[i] = S[i], UpdateMX(i, (int)(S[i].size()));
for (int i = 0; i < n - 1; i++) comp.push_back(LCP(TMP[i], TMP[i + 1]));
for (int i = 0; i < q; i++) {
cin >> T[i] >> L[i];
L[i]--;
if (T[i] == 1) {
cin >> R[i];
ANS[i] = GetMX(L[i], R[i]);
} else {
cin >> Q[i];
TMP[L[i]] = Q[i];
UpdateMX(L[i], (int)(Q[i].size()));
if (L[i]) comp.push_back(LCP(TMP[L[i] - 1], TMP[L[i]]));
if (n - 1 - L[i]) comp.push_back(LCP(TMP[L[i]], TMP[L[i] + 1]));
}
}
sort(comp.begin(), comp.end());
comp.resize(unique(comp.begin(), comp.end()) - comp.begin());
for (int x : comp) {
for (int i = 0; i < n; i++) TMP[i] = S[i];
for (int i = 0; i < n - 1; i++) Update(i, LCP(TMP[i], TMP[i + 1]) >= x);
for (int i = 0; i < q; i++) {
if (T[i] == 1) {
int len = Get(L[i], R[i] - 1).mx + 1;
if (len == 1) len = 0;
ANS[i] = max(ANS[i], 1LL * len * x);
} else {
TMP[L[i]] = Q[i];
if (L[i]) Update(L[i] - 1, LCP(TMP[L[i] - 1], TMP[L[i]]) >= x);
if (n - 1 - L[i]) Update(L[i], LCP(TMP[L[i]], TMP[L[i] + 1]) >= x);
}
}
}
for (int i = 0; i < q; i++)
if (T[i] == 1) cout << ANS[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
struct RMQTree {
int n, tree[MAXN * 4];
void init(int tn) { n = tn; }
void update(int l, int r, int p, int v, int id) {
if (l == r) {
tree[id] = v;
return;
}
int m = (l + r) / 2, lc = id * 2, rc = id * 2 + 1;
if (p <= m)
update(l, m, p, v, lc);
else
update(m + 1, r, p, v, rc);
tree[id] = max(tree[lc], tree[rc]);
}
int query(int l, int r, int ql, int qr, int id) {
if (r < ql or qr < l) return -MAXN;
if (ql <= l and r <= qr) return tree[id];
int m = (l + r) / 2, lc = id * 2, rc = id * 2 + 1;
return max(query(l, m, ql, qr, lc), query(m + 1, r, ql, qr, rc));
}
void upd(int x, int v) { update(1, n, x, v, 1); }
int qry(int l, int r) { return query(1, n, l, r, 1); }
} rmqtree;
struct SegmentTree {
struct Node {
int prv, suf, ans, all;
Node() { prv = suf = ans = all = 0; }
} tree[MAXN * 4];
int n;
void init(int tn) {
n = tn;
for (int i = 0; i < (n * 4); i++) tree[i] = Node();
}
Node merge(const Node &lc, const Node &rc) {
Node nd;
nd.ans = max(lc.ans, rc.ans);
nd.ans = max(nd.ans, lc.suf + rc.prv);
nd.prv = lc.prv;
if (lc.all) nd.prv += rc.prv;
nd.suf = rc.suf;
if (rc.all) nd.suf += lc.suf;
if (lc.all and rc.all) nd.all = 1;
return nd;
}
void update(int l, int r, int x, int v, int id) {
if (l == r) {
tree[id].prv = tree[id].suf = tree[id].ans = tree[id].all = v;
return;
}
int m = (l + r) / 2, lc = id * 2, rc = id * 2 + 1;
if (x <= m)
update(l, m, x, v, lc);
else
update(m + 1, r, x, v, rc);
tree[id] = merge(tree[lc], tree[rc]);
}
Node query(int l, int r, int ql, int qr, int id) {
if (l == ql and r == qr) return tree[id];
int m = (l + r) / 2, lc = id * 2, rc = id * 2 + 1;
if (qr <= m) return query(l, m, ql, qr, lc);
if (m < ql) return query(m + 1, r, ql, qr, rc);
Node a = query(l, m, ql, m, lc);
Node b = query(m + 1, r, m + 1, qr, rc);
return merge(a, b);
}
void upd(int x, int v) { update(1, n, x, v, 1); }
int qry(int l, int r) {
if (l > r) return 0;
return query(1, n, l, r, 1).ans;
}
} tree;
struct Operation {
int cmd, a, b;
vector<pair<int, int> > event;
void add_event(int x, int v) { event.emplace_back(x, v); }
} op[MAXN];
int N, Q, A[MAXN];
long long sol[MAXN];
string ip[MAXN], second[MAXN];
vector<int> plen;
int lcp(const string &s1, const string &s2) {
int len = min(((int)((s1).size())), ((int)((s2).size())));
for (int i = 0; i < (len); i++) {
if (s1[i] != s2[i]) return i;
}
return len;
}
int lcp(int l, int r) {
if (l == r) return ((int)((second[l]).size()));
int res = MAXN;
for (int i = (l); i <= (r - 1); i++) {
res = min(res, lcp(second[i], second[i + 1]));
}
return res;
}
long long slow(int a, int b) {
long long res = 0;
for (int l = (a); l <= (b); l++) {
for (int r = (l); r <= (b); r++) {
long long tmp = 1LL * (r - l + 1) * lcp(l, r);
res = max(res, tmp);
}
}
return res;
}
void input() {
cin >> N >> Q;
rmqtree.init(N);
for (int i = (1); i <= (N); i++) {
cin >> ip[i];
second[i] = ip[i];
rmqtree.upd(i, ((int)((ip[i]).size())));
}
for (int i = (1); i <= (N - 1); i++) {
A[i] = lcp(second[i], second[i + 1]);
plen.push_back(A[i]);
}
for (int i = 0; i < (Q); i++) {
cin >> op[i].cmd;
if (op[i].cmd == 1) {
cin >> op[i].a >> op[i].b;
sol[i] = rmqtree.qry(op[i].a, op[i].b);
} else {
int id;
string s;
cin >> id >> s;
rmqtree.upd(id, ((int)((s).size())));
second[id] = s;
if (id > 1) {
op[i].add_event(id - 1, lcp(second[id - 1], second[id]));
}
if (id < N) {
op[i].add_event(id, lcp(second[id], second[id + 1]));
}
for (auto it : op[i].event) plen.push_back(it.second);
}
}
}
void solve() {
sort(begin(plen), end(plen));
plen.resize(unique(begin(plen), end(plen)) - begin(plen));
;
for (auto lb : plen) {
for (int i = (1); i <= (N); i++) second[i] = ip[i];
tree.init(N);
for (int i = (1); i <= (N - 1); i++) {
A[i] = lcp(second[i], second[i + 1]);
if (A[i] >= lb)
tree.upd(i, 1);
else
tree.upd(i, 0);
}
for (int i = 0; i < (Q); i++) {
if (op[i].cmd == 1) {
int width = tree.qry(op[i].a, op[i].b - 1);
if (!width) continue;
width++;
sol[i] = max(sol[i], 1LL * lb * width);
} else {
for (auto it : op[i].event) {
int x = it.first, v = it.second;
A[x] = v;
if (v >= lb)
tree.upd(x, 1);
else
tree.upd(x, 0);
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
input();
solve();
for (int i = 0; i < (Q); i++) {
if (op[i].cmd == 1) {
cout << sol[i] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 77;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 100;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 1e5 + 7;
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = a * a % M)
if (b & 1) ret = 1ll * ret * a % M;
return ret;
}
char a[maxn];
int S[maxn], L[maxn];
int lcp[maxn];
struct node {
long long max;
int lpos, rpos;
vector<pair<int, int> > L, R;
} T[maxn << 2];
node merge(node A, node B) {
node ret;
ret.max = max(A.max, B.max);
ret.lpos = A.lpos;
ret.rpos = B.rpos;
int i, j, pos = A.rpos;
j = B.L.size() - 1;
for (i = A.R.size() - 1; i >= 0; i--) {
while (j >= 0 && B.L[j].first < A.R[i].first) j--;
if (j < 0) break;
ret.max =
max(ret.max, 1ll * min(min(A.R[i].first, B.L[j].first), lcp[pos]) *
(B.L[j].second - A.R[i].second + 1));
}
i = A.R.size() - 1;
for (j = B.L.size() - 1; j >= 0; j--) {
while (i >= 0 && B.L[j].first > A.R[i].first) i--;
if (i < 0) break;
ret.max =
max(ret.max, 1ll * min(min(A.R[i].first, B.L[j].first), lcp[pos]) *
(B.L[j].second - A.R[i].second + 1));
}
ret.L = A.L;
for (auto now : B.L) {
now.first = min(lcp[pos], now.first);
if (now.first >= ret.L.back().first)
ret.L.back().second = now.second;
else
ret.L.push_back(now);
}
ret.R = B.R;
for (auto now : A.R) {
now.first = min(lcp[pos], now.first);
if (now.first >= ret.R.back().first)
ret.R.back().second = now.second;
else
ret.R.push_back(now);
}
return ret;
}
void build(int x, int l, int r) {
if (l == r) {
T[x].lpos = l;
T[x].rpos = r;
lcp[l] = 0;
while (lcp[l] < L[l] && lcp[l] < L[l + 1] &&
a[S[l] + lcp[l]] == a[S[l + 1] + lcp[l]])
lcp[l]++;
T[x].L.clear();
T[x].R.clear();
T[x].L.push_back(make_pair(L[l], l));
T[x].R.push_back(make_pair(L[r], r));
T[x].max = L[l];
return;
}
int mid = (l + r) / 2;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
T[x] = merge(T[x << 1], T[x << 1 | 1]);
}
node query(int x, int l, int r) {
int L = T[x].lpos, R = T[x].rpos;
if (l <= L && R <= r) return T[x];
int mid = (L + R) / 2;
if (r > mid && mid >= l)
return merge(query(x << 1, l, r), query(x << 1 | 1, l, r));
if (mid >= l) return query(x << 1, l, r);
if (r > mid) return query(x << 1 | 1, l, r);
}
void update(int x, int pos) {
int l = T[x].lpos, r = T[x].rpos;
if (l == r) {
lcp[l] = 0;
while (lcp[l] < L[l] && lcp[l] < L[l + 1] &&
a[S[l] + lcp[l]] == a[S[l + 1] + lcp[l]])
lcp[l]++;
T[x].L.clear();
T[x].R.clear();
T[x].L.push_back(make_pair(L[l], l));
T[x].R.push_back(make_pair(L[r], r));
T[x].max = L[l];
return;
}
int mid = (l + r) / 2;
if (mid >= pos)
update(x << 1, pos);
else
update(x << 1 | 1, pos);
T[x] = merge(T[x << 1], T[x << 1 | 1]);
}
int n, m;
int k;
int now;
int main() {
scanf("%d%d", &n, &m);
int i;
for (i = 1; i <= n; i++) {
scanf("%s", a + now);
S[i] = now;
L[i] = strlen(a + now);
now += L[i];
}
build(1, 1, n);
while (m--) {
scanf("%d", &k);
if (k == 1) {
int l, r;
scanf("%d%d", &l, &r);
node now = query(1, l, r);
printf("%I64d\n", query(1, l, r).max);
} else {
int pos;
scanf("%d", &pos);
scanf("%s", a + now);
S[pos] = now;
L[pos] = strlen(a + now);
now += L[pos];
update(1, pos);
if (pos != 1) update(1, pos - 1);
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC target("pclmul")
using ul = std::uint32_t;
using ull = std::uint64_t;
using li = std::int32_t;
using ll = std::int64_t;
using llf = long double;
using us = std::uint16_t;
const ul maxn = 1e5;
const ul maxlen = 1e5;
const ul bu = 17;
std::mt19937_64 rnd;
class node {
public:
ul lc = 0;
ul rc = 0;
ul val = 0;
ul ans[bu + 1];
ul lenl[bu + 1];
ul lenr[bu + 1];
ul cnt = 0;
ull rk = 0;
};
ul tim;
node tree[maxn + maxn];
void update(ul x) {
tree[x].cnt = tree[tree[x].lc].cnt + tree[tree[x].rc].cnt + 1;
for (ul i = 1; i <= bu; ++i) {
ul tmp = tree[x].val >= i;
if (tmp) {
tmp += tree[tree[x].lc].lenr[i] + tree[tree[x].rc].lenl[i];
}
tree[x].ans[i] = std::max(
tmp, std::max(tree[tree[x].lc].ans[i], tree[tree[x].rc].ans[i]));
tree[x].lenl[i] = tree[tree[x].lc].lenr[i] == tree[tree[x].lc].cnt && tmp
? tmp
: tree[tree[x].lc].lenl[i];
tree[x].lenr[i] = tree[tree[x].rc].lenl[i] == tree[tree[x].rc].cnt && tmp
? tmp
: tree[tree[x].rc].lenr[i];
}
}
void split(ul x, ul& a, ul& b, ul key) {
if (!x) {
a = b = 0;
return;
}
if (x < key) {
a = x;
split(tree[x].rc, tree[a].rc, b, key);
} else {
b = x;
split(tree[x].lc, a, tree[b].lc, key);
}
update(x);
}
void merge(ul& x, ul a, ul b) {
if (!a || !b) {
x = a ^ b;
return;
}
if (tree[a].rk > tree[b].rk) {
x = a;
merge(tree[x].rc, tree[a].rc, b);
} else {
x = b;
merge(tree[x].lc, a, tree[b].lc);
}
update(x);
}
ul n;
ul q;
std::string s[maxn + 1];
char str[maxlen + 2];
ul root;
ul lcp(const std::string& a, const std::string& b) {
ul i = 0;
for (; i != a.size() && i != b.size() && a[i] == b[i]; ++i)
;
return i;
}
ul sz = 0;
std::pair<ul, ul> stack[maxn + maxn];
ul left[maxn + maxn];
ul right[maxn + maxn];
std::vector<std::pair<ul, ul>> stack2;
bool al = false;
void erase(ul key) {
--sz;
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= key) {
stack[i] = stack[i + 1];
}
}
al = false;
}
void insert(ul key, ul val) {
++sz;
for (ul i = sz; i >= 1; --i) {
if (stack[i - 1].first > key) {
stack[i] = stack[i - 1];
} else {
stack[i].first = key;
stack[i].second = val;
break;
}
}
al = false;
}
int main() {
rnd.seed(std::time(0));
std::scanf("%u%u", &n, &q);
for (ul i = 1; i <= n; ++i) {
std::scanf("%s", str + 1);
s[i] = str + 1;
if (i != 1) {
++tim;
tree[tim].val = lcp(s[i - 1], s[i]);
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
++tim;
tree[tim].val = s[i].size();
tree[tim].rk = rnd();
update(tim);
merge(root, root, tim);
if (tree[tim].val > bu) {
++sz;
stack[sz].first = tim;
stack[sz].second = tree[tim].val;
}
}
for (ul Case = 1; Case <= q; ++Case) {
ul k;
std::scanf("%u", &k);
if (k == 1) {
ul x, y;
std::scanf("%u%u", &x, &y);
x = (x << 1) - 1;
y = (y << 1) - 1;
ul a, b, c;
split(root, a, b, x);
split(b, b, c, y + 1);
ul ans = 0;
for (ul i = 1; i <= bu; ++i) {
ans = std::max(ans, (tree[b].ans[i] + 1 >> 1) * i);
}
merge(root, a, b);
merge(root, root, c);
if (!al) {
al = true;
for (ul i = 1; i <= sz; ++i) {
if (i == 1 || stack[i].first != stack[i - 1].first + 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first - 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
left[stack[i].first] = stack2.back().first + 1;
stack2.push_back(stack[i]);
}
for (ul i = sz; i >= 1; --i) {
if (i == sz || stack[i].first != stack[i + 1].first - 1) {
stack2.resize(0);
stack2.push_back(std::pair<ul, ul>(stack[i].first + 1, 0));
} else {
while (stack2.size() && stack2.back().second >= stack[i].second) {
stack2.pop_back();
}
}
right[stack[i].first] = stack2.back().first - 1;
stack2.push_back(stack[i]);
}
}
for (ul i = 1; i <= sz; ++i) {
if (stack[i].first >= x && stack[i].first <= y) {
ans = std::max(ans, (std::min(right[stack[i].first], y) -
std::max(left[stack[i].first], x) + 1 + 1 >>
1) *
stack[i].second);
}
}
std::printf("%u\n", ans);
} else {
ul x;
std::scanf("%u%s", &x, str + 1);
s[x] = str + 1;
ul y = (x << 1) - 1;
ul a, b, c;
split(root, a, b, std::max(y - 1, ul(1)));
split(b, b, c, std::min(y + 1, n + n - 1) + 1);
if (tree[y].val > bu) {
erase(y);
}
tree[y].val = s[x].size();
tree[y].lc = 0;
tree[y].rc = 0;
update(y);
if (tree[y].val > bu) {
insert(y, tree[y].val);
}
b = y;
if (x != 1) {
if (tree[y - 1].val > bu) {
erase(y - 1);
}
tree[y - 1].val = lcp(s[x - 1], s[x]);
tree[y - 1].lc = 0;
tree[y - 1].rc = 0;
update(y - 1);
if (tree[y - 1].val > bu) {
insert(y - 1, tree[y - 1].val);
}
merge(b, y - 1, b);
}
if (x != n) {
if (tree[y + 1].val > bu) {
erase(y + 1);
}
tree[y + 1].val = lcp(s[x], s[x + 1]);
tree[y + 1].lc = 0;
tree[y + 1].rc = 0;
update(y + 1);
if (tree[y + 1].val > bu) {
insert(y + 1, tree[y + 1].val);
}
merge(b, b, y + 1);
}
merge(b, a, b);
merge(b, b, c);
root = b;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 1e5 + 7;
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = a * a % M)
if (b & 1) ret = 1ll * ret * a % M;
return ret;
}
char a[maxn];
int S[maxn], L[maxn];
int lcp[maxn];
struct node {
long long max;
int lpos, rpos;
vector<pair<int, int> > L, R;
} T[maxn << 2];
node merge(node A, node B) {
node ret;
ret.max = max(A.max, B.max);
ret.lpos = A.lpos;
ret.rpos = B.rpos;
int i, j, pos = A.rpos;
j = B.L.size() - 1;
for (i = A.R.size() - 1; i >= 0; i--) {
while (j >= 0 && B.L[j].first < A.R[i].first) j--;
if (j < 0) break;
ret.max =
max(ret.max, 1ll * min(min(A.R[i].first, B.L[j].first), lcp[pos]) *
(B.L[j].second - A.R[i].second + 1));
}
i = A.R.size() - 1;
for (j = B.L.size() - 1; j >= 0; j--) {
while (i >= 0 && B.L[j].first > A.R[i].first) i--;
if (i < 0) break;
ret.max =
max(ret.max, 1ll * min(min(A.R[i].first, B.L[j].first), lcp[pos]) *
(B.L[j].second - A.R[i].second + 1));
}
ret.L = A.L;
for (auto now : B.L) {
now.first = min(lcp[pos], now.first);
if (now.first >= ret.L.back().first)
ret.L.back().second = now.second;
else
ret.L.push_back(now);
}
ret.R = B.R;
for (auto now : A.R) {
now.first = min(lcp[pos], now.first);
if (now.first >= ret.R.back().first)
ret.R.back().second = now.second;
else
ret.R.push_back(now);
}
return ret;
}
void build(int x, int l, int r) {
if (l == r) {
T[x].lpos = l;
T[x].rpos = r;
lcp[l] = 0;
while (lcp[l] < L[l] && lcp[l] < L[l + 1] &&
a[S[l] + lcp[l]] == a[S[l + 1] + lcp[l]])
lcp[l]++;
T[x].L.clear();
T[x].R.clear();
T[x].L.push_back(make_pair(L[l], l));
T[x].R.push_back(make_pair(L[r], r));
T[x].max = L[l];
return;
}
int mid = (l + r) / 2;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
T[x] = merge(T[x << 1], T[x << 1 | 1]);
}
node query(int x, int l, int r) {
int L = T[x].lpos, R = T[x].rpos;
if (l <= L && R <= r) return T[x];
int mid = (L + R) / 2;
if (r > mid && mid >= l)
return merge(query(x << 1, l, r), query(x << 1 | 1, l, r));
if (mid >= l) return query(x << 1, l, r);
if (r > mid) return query(x << 1 | 1, l, r);
}
void update(int x, int pos) {
int l = T[x].lpos, r = T[x].rpos;
if (l == r) {
lcp[l] = 0;
while (lcp[l] < L[l] && lcp[l] < L[l + 1] &&
a[S[l] + lcp[l]] == a[S[l + 1] + lcp[l]])
lcp[l]++;
T[x].L.clear();
T[x].R.clear();
T[x].L.push_back(make_pair(L[l], l));
T[x].R.push_back(make_pair(L[r], r));
T[x].max = L[l];
return;
}
int mid = (l + r) / 2;
if (mid >= pos)
update(x << 1, pos);
else
update(x << 1 | 1, pos);
T[x] = merge(T[x << 1], T[x << 1 | 1]);
}
int n, m;
int k;
int now;
int main() {
scanf("%d%d", &n, &m);
int i;
for (i = 1; i <= n; i++) {
scanf("%s", a + now);
S[i] = now;
L[i] = strlen(a + now);
now += L[i];
}
build(1, 1, n);
while (m--) {
scanf("%d", &k);
if (k == 1) {
int l, r;
scanf("%d%d", &l, &r);
node now = query(1, l, r);
printf("%I64d\n", query(1, l, r).max);
} else {
int pos;
scanf("%d", &pos);
scanf("%s", a + now);
S[pos] = now;
L[pos] = strlen(a + now);
now += L[pos];
update(1, pos);
if (pos != 1) update(1, pos - 1);
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.