text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
long long modpow(long long x, long long d) {
if (d == 0) {
return 1ll;
}
long long ret = modpow(x, d / 2);
ret = (ret * ret) % mod;
if (d & 1) {
ret = (ret * x) % mod;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
int n, m, k;
cin >> n >> m >> k;
vector<int> pa(n);
iota(pa.begin(), pa.end(), 0);
vector<int> sz(n, 1);
auto root = [&](int x) {
while (pa[x] != x) {
x = pa[x] = pa[pa[x]];
}
return x;
};
auto unite = [&](int x, int y) {
x = root(x), y = root(y);
if (sz[x] < sz[y]) {
swap(x, y);
}
pa[y] = x;
sz[x] += sz[y];
};
for (int i = 0; i + k <= n; i++) {
int left = i, right = i + k - 1;
while (left < right) {
unite(left, right);
left++, right--;
}
}
int comps = 0;
for (int i = 0; i < n; i++) {
comps += (root(i) == i);
}
cout << modpow(m, comps);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k > n) {
long long res = 1;
for (long i = 0; i < n; i++) {
res *= m;
res %= mod;
}
cout << res;
} else if (k == 1) {
long long res = 1;
for (long i = 0; i < n; i++) {
res *= m;
res %= mod;
}
cout << res;
} else if (k == 2) {
cout << m;
} else if (n > k) {
if (k % 2 == 1)
cout << m * m;
else
cout << m;
} else {
long long res = 1;
for (long i = 0; i < (k + 1) / 2; i++) {
res *= m;
res %= mod;
}
cout << res;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, K, F[2005];
int Get(int u) {
if (F[u] == u) return u;
return F[u] = Get(F[u]);
}
void Join(int u, int v) {
int fx = Get(u), fy = Get(v);
if (fx != fy) F[fx] = fy;
}
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 1; i <= N; i++) F[i] = i;
for (int i = 1; i <= N - K + 1; i++) {
int l = i, r = i + K - 1;
for (int k = 1; k <= K / 2; k++) Join(l + k - 1, r - k + 1);
}
int Ans = 1;
for (int i = 1; i <= N; i++)
if (Get(i) == i) Ans = (1ll * Ans * M) % 1000000007;
printf("%d\n", Ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
if ((k == 1) || k > n) {
long long ans = 1;
for (int i = 0; i < n; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans << endl;
return 0;
}
if (k == n) {
long long ans = 1;
for (int i = 0; i < (n + 1) / 2; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans << endl;
return 0;
}
if (k & 1) {
printf("%d\n", m * m);
} else {
printf("%d\n", m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
long long n, m, k;
long long ans = 1;
scanf("%lld%lld%lld", &n, &m, &k);
if (k < n && k % 2 == 0) {
printf("%d\n", m);
return 0;
}
if (k == n) {
if (n % 2 == 0)
ans = 1;
else
ans = m;
for (int i = 1; i <= k / 2; i++) {
ans = ans * m % mod;
}
} else if (k == 1 || k > n) {
for (int i = 1; i <= n; i++) ans = ans * m % mod;
} else {
ans = m * m;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
int bit(int x, int i) { return ((x >> (i - 1)) & 1); }
long long power(long long a, long long n, long long m) {
long long ans = 1;
while (n > 0) {
if (n % 2) ans = (ans * a) % m;
n = n >> 1;
a = (a * a) % m;
}
return ans;
}
void merge(long long arr[], long long low, long long mid, long long high) {
long long i = low, j = mid + 1, k = low;
long long brr[100000];
while (i <= mid && j <= high) {
if (arr[i] <= arr[j])
brr[k++] = arr[i++];
else
brr[k++] = arr[j++];
}
while (i <= mid) brr[k++] = arr[i++];
while (j <= high) brr[k++] = arr[j++];
for (k = low; k <= high; k++) arr[k] = brr[k];
}
void mergesort(long long arr[], long long low, long long high) {
if (low < high) {
long long mid = (low + high) / 2;
mergesort(arr, low, mid);
mergesort(arr, mid + 1, high);
merge(arr, low, mid, high);
}
}
bool cmp(pair<pair<long long, long long>, long long> a,
pair<pair<long long, long long>, long long> b) {
if (a.first.first == b.first.first) return a.first.second < b.first.second;
return a.first.first < b.first.first;
}
int digit(int n) {
int d = 0;
while (n > 0) {
d++;
n = n / 10;
}
return d;
}
int mat[26][26];
void dfs(int node, vector<bool>& vis) {
vis[node] = 1;
for (int i = 0; i < 26; i++) {
if (!vis[i] && mat[node][i]) dfs(i, vis);
}
}
int root(int par[], int i) {
if (par[i] != i) par[i] = root(par, par[i]);
return par[i];
}
void make_union(int par[], int size[], int a, int b) {
int ra = root(par, a);
int rb = root(par, b);
if (ra == rb) return;
if (size[ra] < size[rb]) {
par[ra] = par[rb];
size[rb] += size[ra];
} else {
par[rb] = par[ra];
size[ra] += size[rb];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
int par[n + 1], size[n + 1];
for (int i = 0; i <= n; i++) {
size[i] = 1;
par[i] = i;
}
for (int i = 1; i <= n; i++) {
int x = i, y = i + k - 1;
if (y > n) break;
while (x < y) {
make_union(par, size, x, y);
x++;
y--;
}
}
set<int> S;
for (int i = 1; i <= n; i++) S.insert(root(par, i));
long long nn = S.size();
long long x = m;
long long ans = power(x, nn, mod);
cout << ans % mod << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long Power(int base, int power) {
if (power == 0) return 1ll;
if (power == 1) return base % 1000000007;
long long sub = Power(base, power / 2) % 1000000007;
sub = (sub * sub) % 1000000007;
if (power & 1) return (base * sub) % 1000000007;
return sub;
}
int main() {
long long n, m, k, res;
while (cin >> n >> m >> k) {
if (k == 1 || k > n) {
cout << Power(m, n) << endl;
continue;
}
if (k == n) {
if (k & 1)
cout << Power(m, 1 + (n / 2)) << endl;
else
cout << Power(m, n / 2) << endl;
continue;
}
res = m;
if (k & 1) {
res += m * (m - 1);
}
cout << res << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k, i, ans;
while (cin >> n >> m >> k) {
if (m == 1) {
cout << 1 << endl;
continue;
}
if (k == 1 || k > n) {
ans = 1;
for (i = 1; i <= n; i++) {
ans = ans * m % 1000000007;
}
cout << ans << endl;
continue;
}
if (k % 2 && k < n) {
ans = m;
ans += m * (m - 1);
cout << ans << endl;
continue;
}
if (k < n) {
cout << m << endl;
continue;
}
ans = 1;
for (i = 1; i <= n / 2; i++) {
ans = ans * m % 1000000007;
}
if (n % 2) ans = ans * m % 1000000007;
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int md = 1000000007;
int n, m, k;
int chk[2222];
vector<int> g[2222];
int ans;
void dfs(int u) {
chk[u] = 1;
for (int i = 0; i < g[u].size(); ++i)
if (!chk[g[u][i]]) dfs(g[u][i]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n - k + 1; ++i) {
int l = i, r = i + k - 1;
while (l < r) {
g[l].push_back(r);
g[r].push_back(l);
++l;
--r;
}
}
for (int i = 1; i <= n; ++i)
if (!chk[i]) dfs(i), ++ans;
long long f = 1;
for (int i = 1; i <= ans; ++i) f = f * m % md;
printf("%I64d", f);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
return (b) == 0 ? (a) : gcd((b), ((a) % (b)));
}
template <class T>
inline T lcm(T a, T b) {
return ((a) / gcd((a), (b)) * (b));
}
template <class T>
inline T BigMod(T Base, T power, T M = 1000000007) {
if (power == 0) return 1;
if (power & 1)
return ((Base % M) * (BigMod(Base, power - 1, M) % M)) % M;
else {
T y = BigMod(Base, power / 2, M) % M;
return (y * y) % M;
}
}
template <class T>
inline T ModInv(T A, T M = 1000000007) {
return BigMod(A, M - 2, M);
}
int fx[] = {-1, +0, +1, +0, +1, +1, -1, -1, +0};
int fy[] = {+0, -1, +0, +1, +1, -1, +1, -1, +0};
int day[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, k;
cin >> n >> m >> k;
long long ans = 1;
if (k == 1 || k > n) {
for (int i = 0; i < n; i++) ans = (ans * m) % 1000000007;
} else if (k == n) {
for (int i = 0; i < (n + 1) / 2; i++) ans = (ans * m) % 1000000007;
} else if (k & 1) {
ans = m * m;
} else {
ans = m;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 0.0000000001;
const long long mod1 = 998244353;
const long long mod2 = 1000000007;
const long long mod3 = 1000000009;
const long long inf = 1000000000000000000;
long long get(long long n, long long a, long long mod = mod2) {
if (!a) return 1;
if (a == 1) return n % mod;
if (a & 1) return n % mod * get(n, a - 1) % mod;
return get(n, a / 2) % mod * get(n, a / 2) % mod;
}
signed main() {
long long a, b, c;
cin >> a >> b >> c;
if (a == c) {
cout << get(b, (a + 1) / 2) % mod2;
return 0;
}
if (c > a) {
cout << get(b, a) % mod2;
return 0;
}
if (c == 1) {
cout << get(b, a) % mod2 << endl;
return 0;
}
if (c % 2 == 0) {
cout << b % mod2;
return 0;
}
cout << b * b % mod2;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
int main() {
int n, m, k;
cin >> n >> m >> k;
long long res = 1;
if (k > n || k == 1) {
for (int i = 1; i <= n; i++) res = ((res % mod) * (m % mod)) % mod;
cout << res;
} else if (k == n) {
for (int i = 1; i <= n / 2 + n % 2; i++)
res = ((res % mod) * (m % mod)) % mod;
cout << res;
} else if (k % 2 == 0)
cout << m;
else {
cout << (m * m) % mod;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
scanf("%lld %lld %lld", &n, &m, &k);
if (k == 1 || k > n) {
long long an = 1;
for (int i = 0; i < n; i++) {
an *= m;
an %= 1000000007;
}
printf("%lld", an);
} else if (k == n) {
long long an = 1;
for (int i = 0; i < (n + 1) / 2; i++) {
an *= m;
an %= 1000000007;
}
printf("%lld", an);
} else if (k % 2 == 0) {
printf("%lld", m);
} else {
printf("%lld", m * m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 2e3 + 5;
long long n, m, k;
long long p[N], sz[N];
long long lead(long long x) { return p[x] == x ? x : p[x] = lead(p[x]); }
void unite(long long x, long long y) {
x = lead(x);
y = lead(y);
if (sz[x] < sz[y]) swap(x, y);
p[y] = x;
sz[x] += sz[y];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
for (long long i = 1; i <= n; ++i) {
p[i] = i;
sz[i] = 1;
}
for (long long i = 1; i <= n - k + 1; ++i)
for (long long j = 1; j <= k / 2; ++j) unite(i + j - 1, i + k - j);
long long ans = 1;
for (long long i = 1; i <= n; ++i)
if (lead(i) == i) ans = ans * m % mod;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long power(long long x, long long p) {
if (p == 0) return 1 % MOD;
if (p & 1) return x * power(x, p - 1) % MOD;
return power(x * x % MOD, p >> 1);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << power(m, n) << '\n';
} else if (k == n) {
cout << power(m, (n + 1) / 2);
} else if (k % 2 == 0) {
cout << power(m, 1) << '\n';
} else {
cout << power(m, 2) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int parent[2000], cont;
int Find(int x) {
if (parent[x] != x) parent[x] = Find(parent[x]);
return parent[x];
}
void Union(int x, int y) {
x = Find(x);
y = Find(y);
if (x != y) {
--cont;
parent[x] = y;
}
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i) parent[i] = i;
cont = n;
for (int i = 0; i + k <= n; ++i)
for (int j = 0, j2 = k - 1; j < j2; ++j, --j2) Union(i + j, i + j2);
long long ans = 1;
for (int i = 0; i < cont; ++i) ans = ans * m % 1000000007;
printf("%d\n", (int)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007LL;
int main() {
long long n, m, k, ans = 1LL, i;
scanf("%lld%lld%lld", &n, &m, &k);
if (k == 1 || k > n) {
for (i = 1; i <= n; ++i) ans = ans * m % mod;
printf("%lld\n", ans);
} else if (k < n) {
if (k & 1)
ans = m * m;
else
ans = m;
printf("%lld\n", ans);
} else if (k == n) {
for (i = 1; i * 2 <= n + 1; ++i) ans = ans * m % mod;
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
int pov(int a, int b) {
int result = 1;
for (int i = 1; i <= b; i++) {
result = ((long long)result * a) % 1000000007;
}
return result;
}
int main(void) {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
int sol = 0;
if (k == 1 || k > n) {
sol = pov(m, n);
} else if (k == n) {
sol = pov(m, (n + 1) / 2);
} else if (k % 2 == 0) {
sol = m;
} else {
sol = m * m;
}
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline string toString(const T& o) {
ostringstream os("");
os << o;
return os.str();
}
template <typename T>
void unique(vector<T>& v) {
sort(all(v));
v.erase(unique(all(v)) - v.begin());
}
template <typename T>
void append(vector<T>& v, const vector<T>& u) {
v.insert(v.end(), (u).begin(), (u).end());
}
bool g[2003][2003];
bool u[2003];
const long long MOD = 1000000007LL;
void dfs(int v, int n) {
u[v] = true;
for (int i = 0; i < n; ++i) {
if (g[v][i] && !u[i]) {
dfs(i, n);
}
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int start = 0; start + k - 1 < n; ++start) {
for (int i = start, j = start + k - 1; i < j; ++i, --j) {
g[i][j] = g[j][i] = true;
}
}
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (!u[i]) {
dfs(i, n);
++cnt;
}
}
long long ret = 1;
for (int i = 0; i < cnt; ++i) {
ret *= m;
ret %= MOD;
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int n, long long int m) {
if (n == 0) return 1;
if (n == 1) return x;
x %= m;
if (n % 2) return (x * (power((x * x) % m, n / 2, m) % m)) % m;
return power((x * x) % m, n / 2, m) % m;
}
long long int parent[100010];
long long int siz[100010];
long long int find_parent(long long int x) {
while (x != parent[x]) {
parent[x] = parent[parent[x]];
x = parent[x];
}
return x;
}
void union1(long long int x, long long int y) {
x = find_parent(x);
y = find_parent(y);
if (x == y) return;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
parent[y] = x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, m, k, x, y, ans = 1, mod = 1e9 + 7;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) parent[i] = i;
if (k <= n) {
for (int i = 0; i + k - 1 < n; i++) {
x = i, y = i + k - 1;
while (x < y) {
union1(x, y);
x++, y--;
}
}
}
for (int i = 0; i < n; i++) {
if (find_parent(i) == i) {
ans = (ans * m) % mod;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> G[2005 + 2];
long long pre[2005 + 2];
bool vis[2005 + 2];
int n, m, k;
long long Bfs(int st) {
queue<int> Q;
Q.push(st);
vis[st] = 1;
long long cnt = 0LL;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < (int)(G[u].size()); i++) {
int v = G[u][i];
if (!vis[v]) {
vis[v] = 1;
cnt++;
Q.push(v);
}
}
}
return (long long)m;
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
scanf("%d", &k);
int kk = ((k + 1) / 2);
for (i = 1; i <= n; i++) {
int nx = i + k - 1;
if (nx > n) break;
for (j = 1; j <= kk; j++) {
int lf = i + j - 1;
int rg = nx - j + 1;
G[lf].push_back(rg);
G[rg].push_back(lf);
}
}
memset(vis, 0, sizeof(vis));
long long ans = 1LL;
for (i = 1; i <= n; i++) {
if (!vis[i]) {
ans = (ans * Bfs(i)) % 1000000007LL;
}
}
printf("%lld\n", (ans + 1000000007LL) % 1000000007LL);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int ncc;
void makeset(long long int arr[], long long int len) {
long long int i;
for (long long int i = 0; i <= len - 1; i++) arr[i] = -1;
}
long long int rfind(long long int arr[], long long int x) {
if (arr[x] < 0) return x;
arr[x] = rfind(arr, arr[x]);
return arr[x];
}
void runion(long long int arr[], long long int root1, long long int root2) {
long long int a = rfind(arr, root1), b = rfind(arr, root2);
if (a == b) {
return;
}
ncc--;
if (arr[a] > arr[b]) swap(a, b);
arr[a] += arr[b];
arr[b] = a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int TESTS, n, m, k, i, j, a, b, c, q;
TESTS = 1;
while (TESTS--) {
cin >> n >> m >> k;
long long int arr[n];
makeset(arr, n);
ncc = n;
for (long long int i = 0; i <= n - k; i++) {
for (long long int j = 0; j <= k - 1; j++)
runion(arr, i + j, i + k - 1 - j);
}
long long int ans = 1;
for (long long int i = 0; i <= ncc - 1; i++) ans = (ans * m) % 1000000007;
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int a[2005];
int r[2005];
int find(int s) {
if (a[s] == s)
return s;
else
return a[s] = find(a[s]);
}
void merge(int s, int t) {
int ps = find(s), pt = find(t);
if (r[ps] > r[pt]) {
a[pt] = ps;
} else if (r[ps] < r[pt]) {
a[ps] = pt;
} else {
a[pt] = ps;
++r[ps];
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
a[i] = i;
r[i] = 1;
}
for (int i = 0; i < n - k + 1; ++i) {
for (int j = 0; j < k; ++j) {
merge(i + j, i + k - 1 - j);
}
}
int count = 0;
for (int i = 0; i < n; ++i) count += a[i] == i;
if (count == 0)
cout << 0 << endl;
else {
long long ans = 1;
for (int i = 0; i < count; ++i) ans = ans * m % mod;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int modPow(int x, int y) {
long long res = 1;
long long a = x;
while (y > 0) {
if (y % 2 == 1) {
res = (res * a) % MOD;
}
a = (a * a) % MOD;
y /= 2;
}
return (int)(res);
}
int visited[2000];
void dfs(int x, int n, int k) {
if (visited[x] == -1) {
visited[x] = 1;
for (int p = 0; p < k; p++) {
int b = x - p;
if ((b >= 0) && (b + k <= n)) {
int q = k - p - 1;
int y = q + b;
dfs(y, n, k);
}
}
}
}
int solve(int n, int m, int k) {
memset(visited, -1, sizeof(visited));
int compos = 0;
for (int i = 0; i < n; i++) {
if (visited[i] == -1) {
compos++;
dfs(i, n, k);
}
}
return modPow(m, compos);
}
inline void init() {}
int main() {
init();
int n, m, k;
while (cin >> n >> m >> k) {
cout << solve(n, m, k) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int delta = 1000 * 1000 * 1000 + 7;
long long n, k, m, ans = 1;
int main() {
cin >> n >> m >> k;
if (k > n) {
for (int i = 0; i < n; ++i) {
ans *= m;
ans %= delta;
}
cout << ans << "\n";
} else if (k == n) {
for (int i = 0; i < (n + 1) / 2; ++i) {
ans *= m;
ans %= delta;
}
cout << ans << "\n";
} else if (k % 2 == 0)
cout << m << "\n";
else {
if (k == 1) {
for (int i = 0; i < n; ++i) {
ans *= m;
ans %= delta;
}
cout << ans << "\n";
} else
cout << m * m << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 1000000007;
long long exp(long long a, long long b) {
if (b == 0) return 1;
long long tmp = exp(a, b / 2);
if (b % 2 == 0)
return (tmp * tmp) % N;
else
return (((a * tmp) % N) * tmp) % N;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
if (k == 1) {
cout << exp(m, n) << endl;
} else if (k < n && k % 2 == 1) {
cout << exp(m, 2) << endl;
} else if (k < n && k % 2 == 0) {
cout << m << endl;
} else if (k == n) {
cout << exp(m, (k + 1) / 2) << endl;
} else {
cout << exp(m, n) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
vector<long long> mp;
vector<vector<long long> > v;
void dfs(long long t, long long cnt) {
mp[t] = cnt;
for (long long i = 0; i < v[t].size(); i++) {
if (mp[v[t][i]] == -1) dfs(v[t][i], cnt);
}
}
void check(long long& a, long long b) {
long long x = a * b;
if (x >= mod) x %= mod;
a = x;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
v.resize(n);
for (long long i = 0; i + k - 1 < n; i++) {
for (long long j = i; j <= i + k - 1; j++) {
v[j].push_back(i + k - 1 - (j - i));
v[i + k - 1 - (j - i)].push_back(j);
}
}
mp.assign(n, -1);
long long cnt = 0;
for (long long i = 0; i < n; i++) {
if (mp[i] == -1) {
dfs(i, cnt);
cnt++;
}
}
long long sum = 1;
for (long long i = 0; i < cnt; i++) check(sum, m);
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
const long long mod = 1e9 + 7;
long long quick_pow(long long a, long long b, long long m) {
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = ans * a % m;
}
a = a * a % m;
b >>= 1;
}
return ans;
}
int main() {
while (scanf("%lld %lld %lld", &n, &m, &k) != EOF) {
if (k == 1 || k > n) {
printf("%lld\n", quick_pow(m, n, mod));
continue;
}
if (n == k) {
printf("%lld\n", quick_pow(m, (n + 1) / 2, mod));
continue;
}
if (k & 1) {
printf("%lld\n", m * m);
} else {
printf("%lld\n", m);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> parent;
vector<int> rank2;
int mod = 1e9 + 7;
int find(int p) {
if (parent[p] == p) return p;
int temp = find(parent[p]);
return parent[p] = temp;
}
void union2(int p1, int p2) {
if (rank2[p1] < rank2[p2])
parent[p1] = p2;
else if (rank2[p1] > rank2[p2])
parent[p2] = p1;
else {
parent[p1] = p2;
rank2[p2] += 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
int i, j, n, m, k;
cin >> n >> m >> k;
if (k > n) {
long long ans = 1;
for (i = 0; i < n; i++) {
ans = (ans * m) % mod;
}
cout << ans << endl;
return 0;
}
parent.clear();
parent.resize(n, 0);
rank2.clear();
rank2.resize(n, 0);
for (i = 0; i < n; i++) {
parent[i] = i;
rank2[i] = 1;
}
for (i = 0; i <= n - k; i++) {
int diff = k - 1;
for (j = i;; j++) {
int l = j, r = j + diff;
if (l >= r) break;
if (l != r) {
int par1 = find(l);
int par2 = find(r);
if (par1 != par2) union2(par1, par2);
}
diff -= 2;
}
}
vector<int> num(n + 2, 0);
for (i = 0; i < n; i++) {
num[find(i)] += 1;
}
long long ans = 1;
for (i = 0; i < n; i++) {
if (num[i] != 0) ans = (ans * m) % mod;
}
cout << ans % mod << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
struct uf {
int par[2005];
uf() { memset(par, -1, sizeof(par)); }
int root(int a) {
if (par[a] == -1) return a;
return par[a] = root(par[a]);
}
void unite(int a, int b) {
a = root(a);
b = root(b);
if (a == b) return;
par[a] = b;
}
};
uf u;
int n, m, k;
const long long int mod = 1000000007;
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n + 1 - k; ++i) {
for (int j = 0; j < k; ++j) u.unite(i + j, i + k - 1 - j);
}
long long int res = 1;
for (int i = 0; i < n; ++i)
if (u.root(i) == i) {
res = (res * m) % mod;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
short negative = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') negative = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
x *= negative;
}
long long quickpower(long long n, long long k) {
long long ans = 1;
while (k) {
if (k % 2) {
ans *= n;
ans %= 1000000007;
}
n *= n;
n %= 1000000007;
k /= 2;
}
return ans;
}
string int_to_string(int n) {
string s = "";
while (n) {
int now = n % 10;
s += now + '0';
n /= 10;
}
reverse(s.begin(), s.end());
return s;
}
int string_to_int(string s) {
int n = 0;
for (int i = 0, _n = s.size(); i < s.size(); i++) {
n *= 10;
n += s[i] - '0';
}
return n;
}
int n, m, k;
vector<int> g[2222];
bool used[2222];
void dfs(int x) {
used[x] = 1;
for (int i = 0, _n = g[x].size(); i < g[x].size(); i++) {
if (!used[g[x][i]]) dfs(g[x][i]);
}
}
int ans = 0;
int main() {
ios::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 0, _n = n - k + 1; i < n - k + 1; i++) {
for (int j = (i), _b = (i + k / 2 - 1); j <= _b; j++) {
int a = i + k - 1 - (j - i);
g[a].push_back(j);
g[j].push_back(a);
}
}
for (int i = 0, _n = n; i < n; i++) {
if (!used[i]) {
ans++;
dfs(i);
}
}
cout << quickpower(m, ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 10e-8;
const int MAX = 1000;
const int INF = 1 << 30;
const int MOD = 1000000007;
int main(int argc, char **argv) {
int n, m, k;
cin >> n >> m >> k;
long long int answer = 0;
if (k == 1 || k > n) {
answer = 1;
for (int i = 0; i < n; i++) {
answer = (answer * m) % MOD;
}
} else {
if (k == n) {
answer = 1;
for (int i = 0; i < (n + 1) / 2; i++) {
answer = (answer * m) % MOD;
}
} else {
if (k % 2 == 0) {
answer = m;
} else {
if (n == 1) {
answer = m;
} else {
answer = m * m;
}
}
}
}
cout << answer;
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pow(int n, int exp) {
if (!exp) return 1;
if (exp & 1) return (n * pow(n, exp - 1)) % 1000000007;
long long r = pow(n, exp / 2);
return (r * r) % 1000000007;
}
int solve(int n, int m, int k) {
if (k > n) return pow(m, n);
if (k == n) return pow(m, (n + 1) / 2);
if (k == 1) return pow(m, n);
if (k & 1) return pow(m, 2);
return m;
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
printf("%d\n", solve(n, m, k));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mpow(int a, int k) {
return k == 0 ? 1 : mpow(a, k - 1) * a % 1000000007;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k < 2 || k > n) {
cout << mpow(m, n);
} else if (k == n) {
cout << mpow(m, (n + 1) / 2);
} else if (k % 2) {
cout << m * m;
} else {
cout << m;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
int n, m, k, i, j;
scanf("%d%d%d", &n, &m, &k);
long long ans;
if (k % 2 == 0) {
if (k > n) {
ans = 1;
for (i = 0; i < n; i++) ans = (ans * m) % mod;
cout << ans << endl;
} else {
if (k == n) {
n /= 2;
ans = 1;
for (i = 0; i < n; i++) ans = (ans * m) % mod;
cout << ans << endl;
} else
cout << m << endl;
}
} else if (k == 1) {
ans = 1;
for (i = 0; i < n; i++) ans = (ans * m) % mod;
cout << ans << endl;
} else {
if (k > n) {
ans = 1;
for (i = 0; i < n; i++) ans = (ans * m) % mod;
cout << ans << endl;
} else {
if (k == n)
n = (n + 1) / 2;
else
n = 2;
ans = 1;
for (i = 0; i < n; i++) ans = (ans * m) % mod;
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long power(long long A, long long B) {
long long result = 1;
long long temp = A;
while (B != 0) {
if (B % 2 == 1) {
result *= temp;
result %= MOD;
}
temp *= temp;
temp %= MOD;
B /= 2;
}
return result;
}
long long solve(long long n, long long m, long long k) {
if (k > n)
return power(m, n);
else if (k == n)
return power(m, (n + 1) / 2);
else {
if (k % 2 == 1) {
if (k == 1)
return power(m, n);
else
return power(m, 2);
} else
return power(m, 1);
}
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
cout << solve(n, m, k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
long long P(long long b, long long n) {
if (n == 0) return 1LL;
long long t = P(b, n / 2);
(t *= t) %= MOD;
if (n % 2) (t *= b) %= MOD;
return t;
}
int p[2036];
int F(int first) {
if (first == p[first]) return first;
return p[first] = F(p[first]);
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long ans;
{
for (int i = (0); i < (int)(n); i++) p[i] = i;
for (int i = (0); i < (int)(n); i++)
if (i + k <= n) {
for (int j = (0); j < (int)(k / 2); j++) {
int p1 = F(j + i);
int p2 = F(k - 1 - j + i);
if (p1 != p2) p[p1] = p2;
}
}
long long cnt = 0;
for (int i = (0); i < (int)(n); i++)
if (F(i) == i) cnt++;
ans = P(m, cnt);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int M = 1e9 + 7;
long long int n, k, m;
long long int z, q, u, a1, l, r, ax, cx, ay, by, cy, ql, qr, d, x, y;
vector<long long int> v[30000];
vector<long long int> v1[30];
vector<long long int> v2;
unordered_map<long long int, long long int> vis;
string s[105];
long long int f;
long long int f1;
long long int f2;
long long int cnt = 0;
long long int tot = 0;
unordered_map<long long int, long long int> ml, ml1;
long long int cnt1 = 0;
stack<long long int> ss;
void dfs(long long int i) {
vis[i] = 1;
for (int j = 0; j < v[i].size(); j++) {
if (vis[v[i][j]] == 0) {
dfs(v[i][j]);
}
}
}
void dfs1(long long int i) {
vis[i] = 1;
cnt++;
for (int j = 0; j < v1[i].size(); j++) {
if (vis[v1[i][j]] == 0) {
dfs1(v1[i][j]);
}
}
}
long long int tt = 0;
long long int bn[150];
void dfs3(long long int i, long long int p) {
bn[i + 96] = tt;
tt++;
vis[i] = 1;
for (int j = 0; j < v[i].size(); j++) {
if (v[i][j] == p) return;
dfs3(v[i][j], p);
}
}
long long int me(long long int a, long long int b, long long int M) {
if (b == 0)
return 1;
else if (b % 2 == 0)
return me((a * a) % M, b / 2, M);
else
return (a % M * me((a * a) % M, (b - 1) / 2, M) % M) % M;
}
long long int mI(long long int a, long long int m) { return me(a, m - 2, m); }
int main() {
cin >> n >> m >> k;
long long int f = 1;
if (k == 1 || k > n) return cout << me(m, n, M), 0;
for (int i = 1; i <= n - k + 1; i++) {
v[i].push_back(i + k - 1);
v[i + k - 1].push_back(i);
long long int cnt = k + i - 2;
for (int j = i + 1; j <= cnt; j++) {
v[j].push_back(cnt);
v[cnt].push_back(j);
cnt--;
}
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
dfs(i);
tot++;
}
}
long long int ans = me(m, tot, M);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int pre[2010];
int find(int x) {
if (pre[x] == -1) return x;
return pre[x] = find(pre[x]);
}
int main() {
int n, m, r;
cin >> n >> m >> r;
memset(pre, -1, sizeof(pre));
for (int i = 1; i + r - 1 <= n; i++) {
int st = i, ed = i + r - 1;
for (int i = 0; i + st <= ed; i++) {
int x = find(st + i);
int y = find(ed - i);
if (x != y) pre[x] = y;
}
}
long long ans = 1;
for (int i = 1; i <= n; i++)
if (pre[i] == -1) ans = ans * m % 1000000007;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int B=200;
typedef long long ll;
using namespace std;
int T,n,m,l;
map<string,vector<string> >V;
map<string,bool>vis;
string s,t;
int main(){
ios_base::sync_with_stdio(0), cin.tie(0);
cin>>n;
for(int i=1;i<=n;i++){
cin>>s;t=s;
sort(t.begin(),t.end());
V[t].push_back(s);
}
l=s.size();
ll ans=0,sum=0;
for(auto it:V){
auto &v=it.second;
m=v.size(),ans+=sum*m*1337,sum+=m;
if(m<=200*l){
for(int i=0;i<m;i++) for(int j=i+1;j<m;j++){
int L=0,R=l-1;
while(v[i][L]==v[j][L]&&L<=R) L++;
while(v[i][R]==v[j][R]&&L<=R) R--;
int f1=1,f2=1;
for(int k=L;k<R;k++){
f1&=(v[i][k]<=v[i][k+1]);
f2&=(v[j][k]<=v[j][k+1]);
}
if(f1||f2) ans++;
else ans+=2;
}
continue;
}
ll nw=m*(m-1ll);
vis.clear();
for(auto &s:v) vis[s]=true;
for(auto &s:v){
for(int i=0;i<l;i++) for(int j=i+2;j<=l;j++){
t=s,sort(t.begin()+i,t.begin()+j);
if(t[i]!=s[i]&&t[j-1]!=s[j-1]&&vis.count(t)) nw--;
}
}
ans+=nw;
}
cout<<ans<<"\n";
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int n,m,pre,N;
string s,t;
ll ans;
map<string,vector<string> >S;
map<string,bool>vis;
int main(){
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
cin>>n;
for(int i=1;i<=n;i++){
cin>>s;t=s;
sort(t.begin(),t.end());
S[t].push_back(s);
}
m=s.size();
for(auto it:S){
vector<string> v=it.second;
N=v.size(),ans+=1337ll*pre*N,pre+=N;
if(N<=200*m){
for(int i=0;i<N;i++)for(int j=i+1;j<N;j++){
int L=0,R=m-1;
while(v[i][L]==v[j][L]&&L<=R)L++;
while(v[i][R]==v[j][R]&&L<=R)R--;
bool f1=1,f2=1;
for(int k=L;k<R;k++)f1&=(v[i][k]<=v[i][k+1]),f2&=(v[j][k]<=v[j][k+1]);
ans+=2;
if(f1||f2)ans--;
}
}else{
ll cur=(ll)N*(N-1);
vis.clear();
for(auto s:v)vis[s]=1;
for(auto s:v)for(int i=0;i<m;i++)for(int j=i+2;j<=m;j++){
t=s,sort(t.begin()+i,t.begin()+j);
if(t[i]!=s[i]&&t[j-1]!=s[j-1]&&vis.count(t))cur--;
}
ans+=cur;
}
}
cout<<ans;
}
|
#include<bits/stdc++.h>
#define For(i,a,b) for(register int i=(a);i<=(b);++i)
#define Rep(i,a,b) for(register int i=(a);i>=(b);--i)
#define int long long
using namespace std;
inline int read()
{
char c=getchar();int x=0;bool f=0;
for(;!isdigit(c);c=getchar())f^=!(c^45);
for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+(c^48);
if(f)x=-x;return x;
}
#define fi first
#define se second
#define pb push_back
#define mkp make_pair
typedef pair<int,int>pii;
typedef vector<int>vi;
#define maxn 200005
int n,res;
string s[maxn];
string Sort(string s){
sort(s.begin(),s.end());
return s;
}
map<string,vi>mp;
struct Trie{
int ch[maxn][26],tot,rt;
int dfn[maxn],out[maxn],idx;
inline int newn(){
int u=++tot;
memset(ch[u],0,sizeof ch[u]); return u;
}
inline int ins(string s,bool rev=0){
int u=rt;
if(rev) reverse(s.begin(),s.end());
for(int i=0;i<s.size();++i){
int c=s[i]-'a';
if(!ch[u][c])ch[u][c]=newn();
u=ch[u][c];
}return u;
}
void dfs(int u){
dfn[u]=++idx;
For(c,0,25)if(ch[u][c])dfs(ch[u][c]);
out[u]=idx;
}
int walk(int u,int c){return ch[u][c];}
void New(){tot=idx=0,rt=newn();}
}t1,t2;
map<string,int>mp2;
pair<string,int> vec[maxn];int len;
int pos1[maxn],pos2[maxn],pos[maxn][2];
int tr[maxn];
inline void add(int x,int y){
for(;x<=t2.idx;x+=x&-x) tr[x]+=y;
}
inline int ask(int x){
int res=0;
for(;x;x^=x&-x) res+=tr[x];
return res;
}
inline int ask(int l,int r){return ask(r)-ask(l-1);}
vector< pii >Q[maxn],R[maxn];
inline void addask(int l1,int r1,int l2,int r2){
if(l1-1) R[l1-1].pb(mkp(l2,r2));
Q[r1].pb(mkp(l2,r2));
}
pii orz[maxn];
void solve(vi v)
{
int sz=v.size();
if(sz==1)return;
mp2.clear(),t1.New(),t2.New();
res+=2*sz*(sz-1)/2;
res-=1337*sz*(sz-1)/2;
for(auto it:v)mp2[s[it]]++;
// cout<<sz<<' '<<res<<endl;
len=0;
for(auto it:mp2){
vec[++len]=it,res-=2*(it.se)*(it.se-1)/2;
pos[len][0]=t1.ins(it.fi);
pos[len][1]=t2.ins(it.fi,1);
}
t1.dfs(1),t2.dfs(1);
// cout<<t1.idx<<' '<<t2.idx<<endl;
For(i,1,t1.idx) orz[i]=mkp(0,0),Q[i].clear(),R[i].clear();
For(i,1,t2.idx) tr[i]=0;
For(i,1,len){
orz[t1.dfn[pos[i][0]]]=mkp(t2.dfn[pos[i][1]],vec[i].se);
int sz=vec[i].fi.size();
string str=vec[i].fi;
pos1[0]=pos2[sz+1]=1;
For(j,1,sz) pos1[j]=t1.walk(pos1[j-1],str[j-1]-'a');
Rep(j,sz,1) pos2[j]=t2.walk(pos2[j+1],str[j-1]-'a');
// cout<<"str "<<str<<endl;
// For(j,1,sz) cout<<pos1[j]<<' '<<pos2[j]<<endl;
for(int l=1,r=1;l<=sz;l=r+1){
r=l;
while(r<sz && str[r]>=str[r-1])++r;
int u=pos1[l-1],v=pos2[r+1];
// cout<<"u,v "<<u<<' '<<v<<" "<<l<<" "<<r<<endl;
if(u&&v) addask(t1.dfn[u],t1.out[u],t2.dfn[v],t2.out[v]),++res;
}
}
For(i,1,t1.idx){
if(orz[i].fi) add(orz[i].fi,orz[i].se);
for(auto t:Q[i]) res-=ask(t.fi,t.se);//,cout<<"ask "<<t.fi<<" "<<t.se<<endl;
for(auto t:R[i]) res+=ask(t.fi,t.se);//,cout<<"-ask "<<t.fi<<' '<<t.se<<endl;
}
}
signed main()
{
n=read();
For(i,1,n)cin>>s[i],mp[Sort(s[i])].pb(i);
res=1337*n*(n-1)/2;
for(auto it:mp)solve(it.se);
cout<<res;
return 0;
}
|
#include <bits/stdc++.h>
const int B=500;
typedef long long ll;
using namespace std;
int T,n,m,l;
map<string,vector<string> >V;
map<string,bool>vis;
string s,t;
int main(){
ios_base::sync_with_stdio(0), cin.tie(0);
cin>>n;
for(int i=1;i<=n;i++){
cin>>s;t=s;
sort(t.begin(),t.end());
V[t].push_back(s);
}
l=s.size();
ll ans=0,sum=0;
for(auto it:V){
auto &v=it.second;
m=v.size(),ans+=sum*m*1337,sum+=m;
if(m<=200*l){
for(int i=0;i<m;i++) for(int j=i+1;j<m;j++){
int L=0,R=l-1;
while(v[i][L]==v[j][L]&&L<=R) L++;
while(v[i][R]==v[j][R]&&L<=R) R--;
int f1=1,f2=1;
for(int k=L;k<R;k++){
f1&=(v[i][k]<=v[i][k+1]);
f2&=(v[j][k]<=v[j][k+1]);
}
if(f1||f2) ans++;
else ans+=2;
}
continue;
}
ll nw=m*(m-1ll);
vis.clear();
for(auto &s:v) vis[s]=true;
for(auto &s:v){
for(int i=0;i<l;i++) for(int j=i+2;j<=l;j++){
t=s,sort(t.begin()+i,t.begin()+j);
if(t[i]!=s[i]&&t[j-1]!=s[j-1]&&vis.count(t)) nw--;
}
}
ans+=nw;
}
cout<<ans<<"\n";
}
|
#include <bits/stdc++.h>
#define MP make_pair
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++ i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++ i)
#define foreach(itr, c) for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); ++ itr)
typedef long long LL;
typedef pair<int, int> pii;
const int MAXN = 2e5 + 5;
int N;
string str[MAXN];
map<string, vector<string> > grps;
LL ans;
int solve_pair(string& s1, string& s2)
{
int prefix = 0, suffix = 0, n = s1.size();
while (s1[prefix] == s2[prefix]) prefix ++;
while (s1[n - suffix - 1] == s2[n - suffix - 1]) suffix ++;
return is_sorted(s1.begin() + prefix, s1.end() - suffix) || is_sorted(s2.begin() + prefix, s2.end() - suffix) ? 1ll : 2ll;
}
void solve(vector<string>& grp)
{
int n = grp.size(), len = grp[0].size();
ans -= 1ll * (n - 1) * n / 2 * 1337;
if (n <= 200 * len) {
rep(i, n) for (int j = i + 1; j < n; ++ j) {
ans += solve_pair(grp[i], grp[j]);
}
} else {
sort(grp.begin(), grp.end());
ans += 1ll * (n - 1) * n / 2 * 2;
for (auto& s : grp) {
rep(i, len) for (int j = i + 2; j <= len; ++ j) {
string sorted = s;
sort(sorted.begin() + i, sorted.begin() + j);
ans -= (sorted[i] != s[i] && sorted[j - 1] != s[j - 1] && binary_search(grp.begin(), grp.end(), sorted));
}
}
}
};
int main()
{
scanf("%d", &N);
rep(i, N) {
cin >> str[i];
string sorted = str[i];
sort(sorted.begin(), sorted.end());
grps[sorted].push_back(str[i]);
}
ans = 1ll * (N - 1) * N / 2 * 1337;
for (auto& grp : grps) solve(grp.second);
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
template <typename T>
void read(T &x) {
x = 0; char c = getchar(); int f = 0;
for (; !isdigit(c); c = getchar())
f |= c == '-';
for (; isdigit(c); c = getchar())
x = x * 10 + (c ^ '0');
if (f) x = -x;
}
template <typename T>
void write(T x, char ed = '\n') {
if (x < 0) putchar('-'), x = -x;
static short st[30], tp;
do st[++tp] = x % 10, x /= 10; while (x);
while (tp) putchar(st[tp--] | '0');
putchar(ed);
}
#define ull unsigned ll
#define se second
#define fi first
const int bas = 1333331, P = 998244353;
const int N = 200050;
map<pair<ull, int>, int> mp[N];
char s[N];
int id[N], siz[222], ch[N][26], cnt, n;
vector<pair<ull, int> > qry[N];
struct cont {
vector<int> a; vector<pair<ull, int> > hs;
int len; pair<ull, int> has;
void readin(void) {
scanf ("%s", s + 1), len = strlen(s + 1), a.resize(len + 1);
for (int i = 1;i <= len; ++i) a[i] = s[i] - 'a', ++siz[a[i]];
hs.resize(len + 2);
for (int i = len;i >= 1; --i)
hs[i].se = (1ll * hs[i + 1].se * bas + a[i] + 'a') % P, hs[i].fi = (hs[i + 1].fi * bas + a[i] + 'a');
//for (int i = 1;i <= len; ++i)
//printf ("hs[%d] = %d\n", i, hs[i]);
for (int i = 0;i < 26; ++i) {
has.se = (1ll * has.se * bas + (siz[i] ^ (i * 1919 + 810))) % P;
has.fi = (has.fi * bas + (siz[i] + 333) * i), siz[i] = 0;
}
//printf ("has = %d\n", has);
}
void insert(void) {
int p = 0;
for (int i = 1;i <= len; ++i) {
mp[p][hs[i]]++;
if (!ch[p][a[i]]) ch[p][a[i]] = ++cnt;
p = ch[p][a[i]];
}
mp[p][hs[len + 1]]++;
}
void calc(void) {
int p = 0;
for (int l = 1, r;l <= len; ) {
r = l;
while (r < len && a[r + 1] >= a[r]) ++r;
//write(p, ' '), write(hs[r + 1]);
qry[p].emplace_back(hs[r + 1]);
while (l <= r) p = ch[p][a[l]], ++l;
}
//printf ("res = %d\n", res);
}
}A[N];
ll all, ans;
void dfs(int x) {
for (int i = 0, y;i < 26; ++i) if (ch[x][i]) {
dfs(y = ch[x][i]);
if (mp[y].size() > mp[x].size()) swap(mp[x], mp[y]);
for (auto t: mp[y]) mp[x][t.first] += t.second;
}
for (auto t: qry[x]) all += mp[x][t] - 1;
qry[x].clear();
}
void solve(cont *A, int len) {
all = 0;
memset(ch, 0, (cnt + 1) * sizeof(ch[0]));
for (int i = 0;i <= cnt; ++i) mp[i].clear();
cnt = 0;
for (int i = 1;i <= len; ++i) A[i].insert();
for (int i = 1;i <= len; ++i) A[i].calc();
dfs(0);
ans += 1ll * len * (len - 1) - all;
}
int main() {
read(n);
for (int i = 1;i <= n; ++i) A[i].readin(), id[i] = i;
sort(A + 1, A + n + 1, [&](cont A, cont B) { return A.has < B.has; });
for (int l = 1, r;l <= n; l = r + 1) {
r = l;
while (r < n && A[r + 1].has == A[l].has) ++r;
ans += 1337ll * (r - l + 1) * (l - 1);
solve(A + l - 1, r - l + 1);
}
write(ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define erorp(x) cout<<#x<<"={"<<(x.F)<<" , "<<x.S<<"}"<<endl;
#define print(v,r) f(i,0,r) cout<<v[i]<<" "; cout<<endl;
#define Get(x,y) scanf("%I64d%I64d",&x,&y);
#define is_bit(x,y) (x%(1<<(y+1))>=(1<<y))
#define eror(x) cout<<#x<<'='<<(x)<<endl;
#define f_(i,a,b) for(int i=a;i>=b;i--)
#define Gett(x,y) scanf("%d%d",&x,&y);
#define f(i,a,b) for(int i=a;i<b;i++)
#define get(x) scanf("%I64d",&x);
#define gett(x) scanf("%d",&x);
#define maxm(a,b) a=max(a,b);
#define minm(a,b) a=min(a,b);
#define Add(x,y) x=(x+y)%mod
#define lst(x) x[x.size()-1]
#define sz(x) int(x.size())
#define mp make_pair
#define ll long long
#define pb push_back
#define S second
#define F first
const int N=2e5+99,E=1337,Z=27,base=31,R=2,sq=7000;
int n,m,cnt[Z],nxt[N],mod[R],hash1[R],hash2[R],pr[sq][sq],su[sq][sq];
ll ex,ans;
string s[N],t[N];
map<vector<int>,vector<int> > Map;
map<pair<pair<int,int>,pair<int,int> >,int> mark;
void mxp(vector<int> v,int x,int type){
vector<vector<int> > S(Z);
f(i,0,v.size())
S[t[v[i]][x]-'a'].pb(v[i]);
f(i,0,Z){
if(S[i].size()){
f(j,0,i)
f(ai,0,S[i].size())
f(aj,0,S[j].size()){
if(type==0)
pr[S[i][ai]][S[j][aj]]=pr[S[j][aj]][S[i][ai]]=x;
else
su[S[i][ai]][S[j][aj]]=su[S[j][aj]][S[i][ai]]=x;
}
}
}
f(i,0,Z)
if(S[i].size()>1)
mxp(S[i],x+(type==0 ? +1 : -1),type);
}
int calc1(int x,int y){
int l=0,r=m;
while(l<m && t[x][l]==t[y][l]) l++;
while(r && t[x][r-1]==t[y][r-1]) r--;
int okx=1,oky=1;
f(i,l,r-1){
if(t[x][i]>t[x][i+1])
okx=0;
if(t[y][i]>t[y][i+1])
oky=0;
}
if(okx || oky){return 1; }
return 2;
}
void G1(int x){
f(i,0,R)
hash1[i]=0;
nxt[m-1]=m;
f_(i,m-2,0){
nxt[i]=i+1;
if(t[x][i]<=t[x][i+1])
nxt[i]=nxt[i+1];
}
f(i,0,m-1){
f(r,0,R)
hash2[r]=0;
f_(j,m-1,i+1){
if(nxt[i]>j){
mark[mp(mp(hash1[0],hash1[1]),mp(hash2[0],hash2[1]))]++;
}
f(r,0,R)
hash2[r]=(1ll*hash2[r]*base+t[x][j]-'a'+1)%mod[r];
}
f(r,0,R)
hash1[r]=(1ll*hash1[r]*base+t[x][i]-'a'+1)%mod[r];
}
}
void G2(int x){
f(i,0,R)
hash1[i]=0;
f(i,0,m-1){
fill(cnt,cnt+Z,0);
f(r,0,R)
hash2[r]=0;
f(j,i,m)
cnt[t[x][j]-'a']++;
f_(j,m-1,i+1){
int mn=Z,mx=0;
f(k,0,Z)
if(cnt[k]){
maxm(mx,k);
minm(mn,k);
}
if(t[x][i]-'a'!=mn && t[x][j]-'a'!=mx){
ans-=mark[mp(mp(hash1[0],hash1[1]),mp(hash2[0],hash2[1]))];
}
cnt[t[x][j]-'a']--;
f(r,0,R)
hash2[r]=(1ll*hash2[r]*base+t[x][j]-'a'+1)%mod[r];
}
f(r,0,R)
hash1[r]=(1ll*hash1[r]*base+t[x][i]-'a'+1)%mod[r];
}
}
void solve(vector<int> v){
int w=v.size();
mark.clear();
ex+=1ll*v.size()*(n-v.size())*E;
f(i,0,v.size())
t[i]=s[v[i]];
if(n<sq){
vector<vector<int> > nxt(w);
vector<int> v;
f(i,0,w)
v.pb(i);
mxp(v,0,0);
mxp(v,m-1,1);
// f(i,0,w)
// f(j,0,i)
// cout<<j<<" "<<i<<" : "<<pr[i][j]<<" "<<su[i][j]<<endl;
f(i,0,w){
nxt[i].pb(0);
f(j,1,m){
if(t[i][j]>=t[i][j-1])
nxt[i].pb(nxt[i][j-1]);
else
nxt[i].pb(j);
}
}
f(i,0,w)
f(j,0,i){
ans+=1;
if(!(nxt[i][su[i][j]]<=pr[i][j] || nxt[j][su[i][j]]<=pr[i][j])){
ans+=1;
}
}
}
else{
ans+=1ll*v.size()*(v.size()-1);
f(i,0,w)
G1(i);
//cout<<endl;
f(i,0,w)
G2(i);
}
}
int main(){
mod[0]=998244353,mod[1]=1e9+9;
cin>>n;
f(i,0,n){
vector<int> v(Z);
cin>>s[i];
m=s[i].size();
f(j,0,s[i].size())
v[s[i][j]-'a']++;
Map[v].pb(i);
}
for(auto v : Map)
solve(v.S);
cout<<ans+ex/2<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
//======================
//
// Template OleschY
//
// Die M�glichkeiten der deutschen Grammatik k�nnen
// einen, wenn man sich darauf, was man ruhig, wenn
// man m�chte, sollte, einl�sst, �berraschen.
// - @Gedankenbalsam
//
//======================
//======================
// Output/Debug
//======================
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (int i = 0; i < v.size(); ++i)
{
os << v[i];
if (i != v.size() - 1)
os << ", ";//123123
}
os << "]\n";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p)
{
os << "[";
os << p.first;
os << ", ";
os << p.second;
os << "]";
return os;
}
#ifndef ONLINE_JUDGE
#define debug(x) cout << (#x) << " is " << (x) << endl
#else
#define debug(...) 42
#endif
//======================
// Solution Single testcase
//======================
pair<int, int> getlr(const string& st1, const string& st2)
{
int ssize = st1.size();
assert(st1.size() == st2.size());
pair<int, int> borders = {-1, ssize};
for(int l = 0; l < ssize; l++)
{
if(st1[l] == st2[l])
{
borders.first = l;
}
else break;
}
for(int r = ssize - 1; r >= 0; r--)
{
if(st1[r] == st2[r])
{
borders.second = r;
}
else break;
}
borders.first++;
borders.second = ssize - borders.second;
return borders;
}
long long nAll;
vector<pair<string, string>> in;
int solve()
{
for(int i = 0; i < nAll ; ++i)
{
in[i].second = in[i].first;
sort(in[i].second.begin(), in[i].second.end());
}
sort(in.begin(), in.end(), [](pair<string, string> const & a, pair<string, string> const & b)
{
return a.second < b.second || (a.second == b.second && a.first < b.first);
});
vector<vector<string>> strGroups;
for(int i = 0; i < nAll; i++)
{
if (i == 0 || in[i].second != in[i - 1].second) {
strGroups.push_back(vector<string>());
}
strGroups.rbegin()->push_back(in[i].first);
}
long long ans = 0;
long long ans1337 = 0;
long long ansWidthwisePairs = 0;
for(vector<string> Strs : strGroups) {
long long n = Strs.size();
long long ssize = Strs[0].size();
ans1337 += 1337 * n * (nAll - n);
ans += n * ( n - 1 );
if(n >= 6800)
{
auto& strs = Strs;
// check widthwise
sort(strs.begin(), strs.end());
for(string const& str : strs)
{
for(int i = 0; i < ssize; i++)
{
for(int j = i + 1; j < ssize; j++)
{
string temp = str;
sort(temp.begin() + i, temp.begin() + j + 1);
if(temp[i] != str[i])
{
if(temp[j] != str[j])
{
if(binary_search(strs.begin(), strs.end(), temp))
{
ansWidthwisePairs -= 2;
}
}
}
}
}
}
}
else
{
auto strs = Strs;
// check pairwise
for(int i = 0; i < n; i++)
{
for(int j = i + 1; j < n; j++)
{
auto [l, r] = getlr(strs[i], strs[j]);
if(r == ssize)
ans -= 2;
else
{
assert(strs[i].begin() + l <= strs[i].end() - r);
if(is_sorted(strs[i].begin() + l, strs[i].end() - r))
ans -= 1;
assert(strs[j].begin() + l <= strs[j].end() - r);
if(is_sorted(strs[j].begin() + l, strs[j].end() - r))
ans -= 1;
}
}
}
}
}
long long sum = ans1337 / 2 + ans + ansWidthwisePairs / 2 ;
cout << sum << "\n"; /// 123
return 0;
}
void input()
{
cin >> nAll;
in.resize(nAll);
for(int i = 0; i < nAll; ++i)
{
cin >> in[i].first;
}
solve();
}
//======================
// Technical stuff
//======================
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
//freopen("a.out", "w", stdout); // console output is better (in most cases)
#else
// add i/o method of specific testing system
#endif
input();
return 0;
}
|
#include <bits/stdc++.h>
#define fst first
#define snd second
#define fore(i,a,b) for(int i=a,ThxDem=b;i<ThxDem;++i)
#define pb push_back
#define ALL(s) s.begin(),s.end()
#define FIN ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define SZ(s) int(s.size())
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
#define bint __int128
struct Hash {
bint MOD=212345678987654321LL,P=1777771,PI=106955741089659571LL;
vector<bint> h,pi;
Hash(){}
Hash(string& s){
assert((P*PI)%MOD==1);
h.resize(s.size()+1);pi.resize(s.size()+1);
h[0]=0;pi[0]=1;
bint p=1;
fore(i,1,s.size()+1){
h[i]=(h[i-1]+p*s[i-1])%MOD;
pi[i]=(pi[i-1]*PI)%MOD;
p=(p*P)%MOD;
}
}
ll get(int s, int e){
return (((h[e]-h[s]+MOD)%MOD)*pi[s])%MOD;
}
};
ll getsorted(string s){
sort(ALL(s));
return Hash(s).get(0,SZ(s));
}
int sorted(string &s, vector<int> &d, int now){
while(d[now]<SZ(s) && s[now]<s[d[now]]) now=d[now];
return d[now]-1;
}
bool can(string &s, string &t, vector<int> &ds, vector<int> &dt, Hash &hs, Hash &ht){
int l=0,r=SZ(s)-1;
while(l<=r){
int m=(l+r)/2;
if(hs.get(0,m+1)==ht.get(0,m+1)) l=m+1;
else r=m-1;
}
int st=l;
l=0; r=SZ(s)-1;
while(l<=r){
int m=(l+r)/2;
if(hs.get(m,SZ(s)) == ht.get(m,SZ(s))) r=m-1;
else l=m+1;
}
int en=r;
return sorted(s,ds,st)>=en || sorted(t,dt,st)>=en;
}
const int MAXN=2e5+10;
vector<int> df[MAXN];
Hash hs[MAXN];
ll brute(vector<string> &v){
int n=SZ(v);
ll ans=0;
fore(i,0,n) fore(j,i+1,n) ans+=1+(!can(v[i],v[j],df[i],df[j],hs[i],hs[j]));
return ans;
}
vector<ll> mp[510];
vector<pair<ll,int>> mp2[510];
int get(vector<ll> &v, ll x){
return upper_bound(ALL(v),x)-lower_bound(ALL(v),x);
}
int get(vector<pair<ll,int>> &v, pair<ll,int> x){
return upper_bound(ALL(v),x)-lower_bound(ALL(v),x);
}
//prefijo de k, difiere en k+1
ll get(vector<string> &v, int k){
int pos=0,n=SZ(v),me=SZ(v[0]);
ll ans=0;
while(pos<n){
int id=pos;
while(id<n&&hs[pos].get(0,k)==hs[id].get(0,k)) id++;
//ver el rango [pos,id)
fore(i,pos,id){
fore(j,k,me+1){
mp[j].pb(hs[i].get(j,me));
mp2[j].pb({hs[i].get(j,me),v[i][k]});
}
}
fore(j,k,me+1){
sort(ALL(mp[j]));
sort(ALL(mp2[j]));
}
fore(i,pos,id){
int to=sorted(v[i],df[i],k)+1;
ll h=hs[i].get(to,me);
ans+=get(mp[to],h);
ans-=get(mp2[to],{h,v[i][k]});
}
fore(j,k,me+1){
mp[j].clear();
mp2[j].clear();
}
pos=id;
}
//cout<<"for "<<k<<": "<<ans<<endl;
return ans;
}
ll linear(vector<string> &v){
int n=SZ(v),k=SZ(v[0]);
ll ans=0;
fore(i,0,k) ans+=get(v,i);
ans=n*(n-1)-ans;
return ans;
}
void compute(vector<string> &v){
int n=SZ(v);
fore(i,0,n){
hs[i]=Hash(v[i]);
int k=SZ(v[i]);
df[i].resize(k);
int id=k;
for(int j=k-1;j>=0;j--){
if(j==k-1||v[i][j]!=v[i][j+1]) id=j+1;
df[i][j]=id;
}
}
}
int main(){FIN;
int n; cin>>n;
vector<string> v(n);
vector<pair<ll,int>> gr;
fore(i,0,n) cin>>v[i];
sort(ALL(v));
fore(i,0,n) gr.pb({getsorted(v[i]),i});
sort(ALL(gr));
ll bad=0,ans=0;
int pos=0;
while(pos<n){
vector<string> now;
int id=pos;
while(id<n&&gr[pos].fst==gr[id].fst){
now.pb(v[gr[id].snd]);
id++;
}
bad+=1ll*SZ(now)*(n-SZ(now));
compute(now);
if(n<=2000) ans+=brute(now);
else ans+=linear(now);
pos=id;
}
bad/=2;
ans+=bad*1337;
cout<<ans<<"\n";
}
|
#include<bits/stdc++.h>
using namespace std;
//======================
//
// Template OleschY
//
// Die M�glichkeiten der deutschen Grammatik k�nnen
// einen, wenn man sich darauf, was man ruhig, wenn
// man m�chte, sollte, einl�sst, �berraschen.
// - @Gedankenbalsam
//
//======================
//======================
// Output/Debug
//======================
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (int i = 0; i < v.size(); ++i)
{
os << v[i];
if (i != v.size() - 1)
os << ", ";//123123
}
os << "]\n";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p)
{
os << "[";
os << p.first;
os << ", ";
os << p.second;
os << "]";
return os;
}
#ifndef ONLINE_JUDGE
#define debug(x) cout << (#x) << " is " << (x) << endl
#else
#define debug(...) 42
#endif
//======================
// Solution Single testcase
//======================
pair<int, int> getlr(const string& st1, const string& st2)
{
int ssize = st1.size();
assert(st1.size() == st2.size());
pair<int, int> borders = {-1, ssize};
for(int l = 0; l < ssize; l++)
{
if(st1[l] == st2[l])
{
borders.first = l;
}
else break;
}
for(int r = ssize - 1; r >= 0; r--)
{
if(st1[r] == st2[r])
{
borders.second = r;
}
else break;
}
borders.first++;
borders.second = ssize - borders.second;
return borders;
}
long long nAll;
vector<pair<string, string>> in;
int solve()
{
for(int i = 0; i < nAll ; ++i)
{
in[i].second = in[i].first;
sort(in[i].second.begin(), in[i].second.end());
}
sort(in.begin(), in.end(), [](pair<string, string> const & a, pair<string, string> const & b)
{
return a.second < b.second || (a.second == b.second && a.first < b.first);
});
vector<vector<string>> strGroups;
for(int i = 0; i < nAll; i++)
{
if (i == 0 || in[i].second != in[i - 1].second) {
strGroups.push_back(vector<string>());
}
strGroups.rbegin()->push_back(in[i].first);
}
long long ans = 0;
long long ans1337 = 0;
long long ansWidthwisePairs = 0;
for(vector<string> Strs : strGroups) {
long long n = Strs.size();
long long ssize = Strs[0].size();
ans1337 += 1337 * n * (nAll - n);
ans += n * ( n - 1 );
if(n >= 6800)
{ //123 12
auto& strs = Strs;
// check widthwise
sort(strs.begin(), strs.end());
for(string const& str : strs)
{
for(int i = 0; i < ssize; i++)
{
for(int j = i + 1; j < ssize; j++)
{
string temp = str;
sort(temp.begin() + i, temp.begin() + j + 1);
if(temp[i] != str[i])
{
if(temp[j] != str[j])
{
if(binary_search(strs.begin(), strs.end(), temp))
{
ansWidthwisePairs -= 2;
}
}
}
}
}
}
}
else
{
auto strs = Strs; 43;
// check pairwise 123123
for(int i = 0; i < n; i++)
{
for(int j = i + 1; j < n; j++)
{
auto [l, r] = getlr(strs[i], strs[j]);
if(r == ssize)
ans -= 2;
else
{
assert(strs[i].begin() + l <= strs[i].end() - r);
if(is_sorted(strs[i].begin() + l, strs[i].end() - r))
ans -= 1;
assert(strs[j].begin() + l <= strs[j].end() - r);
if(is_sorted(strs[j].begin() + l, strs[j].end() - r))
ans -= 1; ///123 1231
}
}
}
}
}
long long sum = ans1337 / 2 + ans + ansWidthwisePairs / 2 ;
cout << sum << "\n"; /// 123
return 0;
}
void input()
{
cin >> nAll;
in.resize(nAll);
for(int i = 0; i < nAll; ++i)
{
cin >> in[i].first;
}
solve();
}
//======================
// Technical stuff
//======================
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
//freopen("a.out", "w", stdout); // console output is better (in most cases)
#else
// add i/o method of specific testing system
#endif
input();
return 0;
}
|
#define __AVX__ 1
#define __AVX2__ 1
#define __SSE__ 1
#define __SSE2__ 1
#define __SSE2_MATH__ 1
#define __SSE3__ 1
#define __SSE4_1__ 1
#define __SSE4_2__ 1
#define __SSE_MATH__ 1
#define __SSSE3__ 1
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for(auto i=(l);i<=(r);++i)
#define per(i, r, l) for(auto i=(r);i>=(l);--i)
#define N 200020
#define ll long long
const int P1 = 31, D1 = 1000173169, P2 = 61, D2 = 1e9 + 7;
int f1[26][N], f2[26][N];
int pw1[N], pw2[N];
struct pair_hash {
inline size_t operator()(const pair<int, int> &p) const {
auto h1 = hash<int>{}(p.first);
auto h2 = hash<int>{}(p.second);
return h1 ^ h2;
}
};
vector<int> ff1[N], ff2[N];
inline void build(int idx, string &s) {
ff1[idx].resize(s.size() + 1), ff2[idx].resize(s.size() + 1);
ff1[idx][0] = ff2[idx][0] = 0;
rep(i, 1, s.size())ff1[idx][i] = 1ll * (1ll * ff1[idx][i - 1] * P1 + s[i - 1]) % D1;
rep(i, 1, s.size())ff2[idx][i] = 1ll * (1ll * ff2[idx][i - 1] * P2 + s[i - 1]) % D2;
}
inline pair<int, int> hsh(int idx, int l, int r) {
int h1 = 1ll * (ff1[idx][r] - 1ll * ff1[idx][l - 1] * pw1[r - l + 1] % D1 + D1) % D1;
int h2 = 1ll * (ff2[idx][r] - 1ll * ff2[idx][l - 1] * pw2[r - l + 1] % D2 + D2) % D2;
return {h1, h2};
}
struct node {
int ct[26];
string s;
inline void read() {
cin >> s;
for (auto v:s)++ct[v - 97];
}
inline bool operator==(const node &b) const {
rep(i, 0, 25)if (ct[i] != b.ct[i])return 0;
return 1;
}
inline bool operator<(const node &b) const {
rep(i, 0, 25)if (ct[i] != b.ct[i])return ct[i] > b.ct[i];
return 0;
}
} S[N];
int n;
unordered_map<pair<int, int>, int, pair_hash> mp, mmp;
map<node, int> MP;
vector<int> sm[N];
inline void solve() {
cin >> n;
rep(i, 1, n)S[i].read();
int m = S[1].s.size();
pw1[0] = pw2[0] = 1;
rep(i, 1, m + 1)pw1[i] = 1ll * pw1[i - 1] * P1 % D1;
rep(i, 1, m + 1)pw2[i] = 1ll * pw2[i - 1] * P2 % D2;
rep(i, 1, n)build(i, S[i].s);
if (n <= 5000) {
rep(i, 1, n) {
sm[i].resize(m + 1);
sm[i][0] = 0;
rep(j, 1, m) {
sm[i][j] = sm[i][j - 1];
if (j < m)sm[i][j] += S[i].s[j] < S[i].s[j - 1];
}
}
auto f = [&](int &x, node &a, int &y, node &b) {
if (!(a == b))return 1337;
if (hsh(x, 1, m) == hsh(y, 1, m))return 0;
/*int l = 1, r = m;
while (l <= r) {
int m = l + r >> 1;
if (hsh(x, 1, m) == hsh(y, 1, m))l = m + 1;
else r = m - 1;
}
int L = l;
l = 1, r = m;
while (l <= r) {
int mid = l + r >> 1;
if (hsh(x, mid, m) == hsh(y, mid, m))r = mid - 1;
else l = mid + 1;
}
int R = r;*/
int l = 0, r = a.s.size() - 1;
while (l <= r && a.s[l] == b.s[l])++l;
while (l <= r && a.s[r] == b.s[r])--r;
int L = l + 1, R = r + 1;
int res = 0;
if (sm[x][R - 1] - sm[x][L - 1] == 0)++res;
if (sm[y][R - 1] - sm[y][L - 1] == 0)++res;
if (res > 0)return 1;
return 2;
};
ll ans = 0;
rep(i, 1, n)rep(j, i + 1, n)ans += f(i, S[i], j, S[j]);
printf("%lld\n", ans);
return;
}
rep(i, 1, n) {
++mp[hsh(i, 1, S[i].s.size())];
++MP[S[i]];
}
rep(j, 0, 25) {
f1[j][0] = f2[j][0] = 0;
rep(i, 1, N - 1)f1[j][i] = 1ll * (1ll * f1[j][i - 1] * P1 + j + 97) % D1;
rep(i, 1, N - 1)f2[j][i] = 1ll * (1ll * f2[j][i - 1] * P2 + j + 97) % D2;
}
auto mix = [&](int *ct) {
int x = f1[0][ct[0]], y = f2[0][ct[0]];
rep(i, 1, 25) if (ct[i]) {
x = (1ll * x * pw1[ct[i]] % D1 + f1[i][ct[i]]) % D1;
y = (1ll * y * pw2[ct[i]] % D2 + f2[i][ct[i]]) % D2;
}
return pair<int, int>{x, y};
};
ll ans = 0;
ll Ans = 0;
auto hsmix = [&](pair<int, int> l, int len1, pair<int, int> r) {
return pair<int, int>{(1ll * l.first * pw1[len1] % D1 + r.first) % D1,
(1ll * l.second * pw2[len1] % D2 + r.second) % D2};
};
int ct[26];
rep(i, 1, n) {
mmp.clear(), mmp[hsh(i, 1, m)] = 1;
rep(l, 1, m) {
rep(k, 0, 25)ct[k] = 0;
++ct[S[i].s[l - 1] - 97];
int p = l + 1;
while (p <= m && S[i].s[p - 1] >= S[i].s[p - 2])++ct[S[i].s[p - 1] - 97], ++p;
rep(r, p, m) {
++ct[S[i].s[r - 1] - 97];
auto mid = mix(ct);
auto x = hsmix(hsh(i, 1, l - 1), r - l + 1, mid);
x = hsmix(x, m - r, hsh(i, r + 1, m));
if (mmp.count(x))continue;
if (mp.count(x))ans -= mp[x];
mmp[x] = 1;
}
}
ans -= mp[hsh(i, 1, m)];
}
for (auto[u, v]:MP)Ans += 1337ll * v * (n - v), ans += 1ll * v * v;
//printf("%d\n", ans);
printf("%lld\n", ans + Ans / 2);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T = 1;
//scanf("%d",&T);
while (T--)solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int ha = 31;
const int hb = 41;
const int m1 = 1000000007;
const int m2 = 1000000009;
const int B = 2000;
const int maxn = 200200;
int n, len;
char s[maxn], t[maxn];
int ha_p[maxn], iha_p[maxn], hb_p[maxn], ihb_p[maxn];
pair<int, int> H[maxn];
pair<vector<int>, int> f[maxn];
int ri[maxn];
int qpow(int a, int n, int mod) {
int ans = 1;
for ( ; n; n>>=1, a=(ll)a*a%mod) if (n&1) ans=(ll)ans*a%mod;
return ans;
}
void init() {
ha_p[0] = iha_p[0] = hb_p[0] = ihb_p[0] = 1;
ha_p[1] = ha, hb_p[1] = hb;
iha_p[1] = qpow(ha, m1-2, m1);
ihb_p[1] = qpow(hb, m2-2, m2);
for (int i=2; i<maxn; i++) {
ha_p[i] = ha_p[i-1] * (ll)ha % m1;
iha_p[i] = iha_p[i-1] * (ll)iha_p[1] % m1;
hb_p[i] = hb_p[i-1] * (ll)hb % m2;
ihb_p[i] = ihb_p[i-1] * (ll)ihb_p[1] % m2;
}
}
pair<int, int> getH(int i, int l, int r) {
if (l > r) return {-1, -1};
int x = (H[i*len + r].first - (l > 0 ? H[i*len + l - 1].first : 0) + m1) * (ll)iha_p[l] % m1;
int y = (H[i*len + r].second - (l > 0 ? H[i*len + l - 1].second : 0) + m2) * (ll)ihb_p[l] % m2;
return make_pair(x, y);
}
struct hash_table {
static const int maxh = 20020020;
static const int mod = 20000023;
struct node {
pair<pair<int, int>, pair<int, int>> k;
int kl, kr;
int v, nex;
} buf[maxh];
int tot, h[maxh], used[maxh], len;
void clear() {
for (int i=0; i<len; i++) h[used[i]] = 0;
tot = len = 0;
}
void ins(pair<pair<int, int>, pair<int, int>> k, int kl, int kr) {
int p = ((k.first.first + 10) ^ (k.first.second + 9) ^ (k.second.first + 23) ^ (k.second.second + 24) ^ ((kl * 200003ll + kr) % mod)) % mod;
if (h[p] == 0) used[len++] = p;
for (int u = h[p]; u; u=buf[u].nex) {
if (buf[u].k == k && buf[u].kl == kl && buf[u].kr == kr) { buf[u].v++; return ; }
}
buf[++tot] = (node){k, kl, kr, 1, h[p]};
h[p] = tot;
}
int fnd(pair<pair<int, int>, pair<int, int>> k, int kl, int kr) {
int p = ((k.first.first + 10) ^ (k.first.second + 9) ^ (k.second.first + 23) ^ (k.second.second + 24) ^ ((kl * 200003ll + kr) % mod)) % mod;
for (int u = h[p]; u; u=buf[u].nex) {
if (buf[u].k == k && buf[u].kl == kl && buf[u].kr == kr) return buf[u].v;
}
return 0;
}
} hsh;
int main(void) {
//freopen("f.in", "r", stdin);
// freopen("f.out", "w", stdout);
// for (int i=20000000; i<=20000100; i++) {
// int f = 1;
// for (int j=2; j*j<=i; j++) if (i % j == 0) { f = 0; break; }
// if (f) printf("%d\n", i);
// }
init();
scanf("%d", &n);
for (int i=0; i<n; i++) {
scanf("%s", s + len);
len += strlen(s + len);
}
// printf("%s\n", s);
len /= n;
for (int i=0; i<n; i++) {
for (int j=0; j<len; j++) t[j] = s[i * len + j];
pair <int, int> h(0, 0);
f[i].first = vector <int> (26, 0);
f[i].second = i;
for (int j=0; j<len; j++) {
h.first = (h.first + (t[j] - 'a' + 1) * (ll)ha_p[j]) % m1;
h.second = (h.second + (t[j] - 'a' + 1) * (ll)hb_p[j]) % m2;
f[i].first[t[j]-'a']++;
H[i*len + j] = h;
}
}
sort(f, f + n);
ll ans = 0;
for (int i=0; i<n; i++) {
for (int j=1, pj=0; j<=len; j++) {
if (j != len && s[i*len+j-1] <= s[i*len+j]) continue;
for (int k=pj; k<j; k++) ri[i*len+k] = j - 1;
pj = j;
}
}
int pre = 0;
for (int i=1; i<=n; i++) {
if (i == n || f[i].first != f[i-1].first) {
// [pre, i - 1]
// printf("------- [%d, %d]\n", pre, i-1);
ll tmp = 0;
if (n <= B) {
for (int j=pre; j<i; j++) {
for (int k=j+1; k<i; k++) {
int L = -1, R = len;
int l = 0, r = len - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (getH(f[j].second, 0, mid) == getH(f[k].second, 0, mid)) {
L = mid, l = mid + 1;
} else {
r = mid - 1;
}
}
l = 0, r = len - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (getH(f[j].second, mid, len-1) == getH(f[k].second, mid, len-1)) {
R = mid, r = mid - 1;
} else {
l = mid + 1;
}
}
assert(L+1 <= R-1);
if (ri[f[j].second*len+L+1] >= R-1 || ri[f[k].second*len+L+1] >= R-1) {
tmp++;
}
}
}
} else {
hsh.clear();
for (int j=pre; j<i; j++) {
for (int l=0; l<len; l++) {
for (int r=l; r<len; r++) {
auto x = getH(f[j].second, 0, l - 1);
auto y = getH(f[j].second, r + 1, len - 1);
hsh.ins({x, y}, l, r);
}
}
}
for (int j=pre; j<i; j++) {
// printf("j = %d, %d\n", j, f[j].second);
for (int k=1, pk=0; k<=len; k++) {
if (k != len && s[f[j].second * len + k - 1] <= s[f[j].second * len + k])
continue;
int l = pk, r = k - 1;
auto x = getH(f[j].second, 0, l - 1);
auto y = getH(f[j].second, r + 1, len - 1);
int o = hsh.fnd({x, y}, l, r) - 1;
tmp += o;
pk = k;
}
}
}
// printf("tmp = %d\n", tmp);
ans += (i - pre) * (ll)(i - pre - 1) - tmp;
ans += 1337ll * pre * (ll)(i - pre);
pre = i;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
//======================
//
// Template OleschY
//
// Die M�glichkeiten der deutschen Grammatik k�nnen
// einen, wenn man sich darauf, was man ruhig, wenn
// man m�chte, sollte, einl�sst, �berraschen.
// - @Gedankenbalsam
//
//======================
//======================
// Output/Debug
//======================
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (int i = 0; i < v.size(); ++i)
{
os << v[i];
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p)
{
os << "[";
os << p.first;
os << ", ";
os << p.second;
os << "]";
return os;
}
#ifndef ONLINE_JUDGE
#define debug(x) cout << (#x) << " is " << (x) << endl
#else
#define debug(...) 42
#endif
//======================
// Solution Single testcase
//======================
pair<int, int> getlr(const string& st1, const string& st2)
{
int ssize = st1.size();
assert(st1.size() == st2.size());
pair<int, int> borders = {-1, ssize};
for(int l = 0; l < ssize; l++)
{
if(st1[l] == st2[l])
{
borders.first = l;
}
else break;
}
for(int r = ssize - 1; r >= 0; r--)
{
if(st1[r] == st2[r])
{
borders.second = r;
}
else break;
}
borders.first++;
borders.second = ssize - borders.second;
return borders;
}
long long nAll;
vector<pair<string, string>> in;
int solve()
{
for(int i = 0; i < nAll ; ++i)
{
in[i].second = in[i].first;
sort(in[i].second.begin(), in[i].second.end());
}
sort(in.begin(), in.end(), [](pair<string, string> const & a, pair<string, string> const & b)
{
return a.second < b.second || (a.second == b.second && a.first < b.first);
});
vector<vector<string>> strGroups;
for(int i = 0; i < nAll; i++)
{
if (i == 0 || in[i].second != in[i - 1].second) {
strGroups.push_back(vector<string>());
}
strGroups.rbegin()->push_back(in[i].first);
}
long long ans = 0;
long long ans1337 = 0;
long long ansWidthwisePairs = 0;
for(vector<string>& Strs : strGroups) {
long long n = Strs.size();
long long ssize = Strs[0].size();
ans1337 += 1337 * n * (nAll - n);
ans += n * ( n - 1 );
if(n >= 6800)
{
auto strs = Strs;
// check widthwise
sort(strs.begin(), strs.end());
for(string const& str : strs)
{
for(int i = 0; i < ssize; i++)
{
for(int j = i + 1; j < ssize; j++)
{
string temp = str;
assert(i <= j + 1);
sort(temp.begin() + i, temp.begin() + j + 1);
if(temp[i] != str[i])
{
if(temp[j] != str[j])
{
if(binary_search(strs.begin(), strs.end(), temp))
{
ansWidthwisePairs -= 2;
}
}
}
}
}
}
}
else
{
auto& strs = Strs;
// check pairwise
for(int i = 0; i < n; i++)
{
for(int j = i + 1; j < n; j++)
{
auto [l, r] = getlr(strs[i], strs[j]);
if(r == ssize)
ans -= 2;
else
{
assert(strs[i].begin() + l <= strs[i].end() - r);
if(is_sorted(strs[i].begin() + l, strs[i].end() - r))
ans -= 1;
assert(strs[j].begin() + l <= strs[j].end() - r);
if(is_sorted(strs[j].begin() + l, strs[j].end() - r))
ans -= 1;
}
}
}
}
}
long long sum = ans1337 / 2 + ans + ansWidthwisePairs / 2 ;
cout << sum << "\n"; /// 123
return 0;
}
void input()
{
cin >> nAll;
in.resize(nAll);
for(int i = 0; i < nAll; ++i)
{
cin >> in[i].first;
}
solve();
}
//======================
// Technical stuff
//======================
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
//freopen("a.out", "w", stdout); // console output is better (in most cases)
#else
// add i/o method of specific testing system
#endif
input();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n,k;
inline bool ck(int i,int j,string&a,string&b){
int l=0,r=k-1,u=0,v=0;
while(a[l]==b[l])l++;
while(a[r]==b[r])r--;
for(;l<r&&!(u&v);l++)u|=(a[l+1]<a[l]),v|=(b[l+1]<b[l]);
return!(u&v);
}
int main(){
cin>>n;
string s,h;
map<string,vector<string>>mp;
long long m,i,j,c,x=0,y=0,t=n*(n-1LL)/2;
while(n--)cin>>s,k=s.length(),h=s,sort(h.begin(),h.end()),mp[h].push_back(s);
for (auto p:mp){
auto v=p.second;
m=v.size(),sort(v.begin(),v.end());
for(i=c=0;i<m;i++)
for(j=i+1;j<m;j++)
c+=ck(i,j,v[i],v[j]);
x+=c,y+=m*(m-1)/2-c;
}
cout<<1337*(t-x-y)+x+2*y<<"\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long P11 = 90874329411493;
int n,i,j;
string s[200020];
pair < string , int > P[200020];
vector < int > sorted_until[200020];
string q;
vector < long long > pref[200020],suff[200020];
map < long long , vector < int > > all_prefs[200020],all_suffs[200020];
map < long long , int > issorted[200020];
long long ans = 0, res;
long long same = 0;
long long diff = 0;
int main() {
cin>>n;
for (i=1;i<=n;i++) {
cin>>q;
s[i] = q;
int r = 0;
for (j=0;j<int(q.size());j++) {
r=max(j+1,r);
while (r < int(q.size()) && q[r] >= q[r-1]) r++;
sorted_until[i].push_back(r);
}
long long _pref = 0;
long long _suff = 0;
pref[i].push_back(0);
suff[i].push_back(0);
for (j=0;j<int(q.size());j++) {
_pref = (_pref * 29LL + (q[j] - 'a' + 1) ) % P11;
_suff = (_suff * 29LL + (q[q.size() - j - 1] - 'a' + 1) ) % P11;
pref[i].push_back(_pref);
suff[i].push_back(_suff);
}
P[i].first = s[i];
sort(P[i].first.begin(), P[i].first.end());
P[i].second = i;
}
sort(P+1, P+n+1);
for (i=1;i<=n;i++) {
int j = i;
while (j <= n && P[j].first == P[i].first) j++;
j--;
res += (j-i+1) * (j-i);
diff += (j-i+1) * (n-j) * 1337;
vector < pair < string , int > > curr;
for (int k=i;k<=j;k++)
curr.push_back({s[P[k].second], P[k].second});
sort(curr.begin(),curr.end());
int len = curr[0].first.size();
for (int k=0;k<=len;k++)
all_prefs[k].clear(), all_suffs[k].clear(), issorted[k].clear();
for (int k=0; k<curr.size(); k++) {
int real = curr[k].second;
for (int id=0; id<=len; id++) {
all_suffs[id][suff[real][id]].push_back(k);
}
}
int sm = 0;
for (int k=0; k<curr.size(); k++) {
while (sm < curr.size() && curr[sm].first == curr[k].first) sm++;
same += sm-k-1;
int real = curr[k].second;
for (int id=0; id<len; id++) {
if (issorted[id][suff[real][id]])
continue;
issorted[id][suff[real][id]] = true;
sort(all_suffs[id][suff[real][id]].begin(),
all_suffs[id][suff[real][id]].end());
}
}
for (int id=0; id < len; id ++) {
for (int k=0;k<curr.size();k++) {
int x = k;
int y = k;
while (y < curr.size() &&
pref[curr[y].second][id] == pref[curr[x].second][id])
y++;
y--;
for (int l = x; l <= y; l++) {
int st = id;
int real = curr[l].second;
int en = sorted_until[real][id];
// if (y - x > 0) {
// cout<<"first "<<id<<" characters "<<l<<" "<<en<<" "<<suff[real][len - en]<<" "<<all_suffs[len-en][suff[real][len - en]].size()<<endl;
// }
int ll = 0, rr = all_suffs[len-en][suff[real][len - en]].size()-1;
int from = rr+1;
while (ll <= rr) {
int mm = (ll+rr)/2;
if (all_suffs[len-en][suff[real][len - en]][mm] >= x) {
from = mm;
rr = mm - 1;
} else ll = mm + 1;
}
ll = 0; rr = all_suffs[len-en][suff[real][len - en]].size()-1;
int strt = -1;
while (ll <= rr) {
int mm = (ll+rr)/2;
if (all_suffs[len-en][suff[real][len - en]][mm] <= y) {
strt = mm;
ll = mm + 1;
} else rr = mm - 1;
}
// cout<<strt<<" "<<from<<endl;
if (from <= strt &&
(id == 0 || sorted_until[real][id] != sorted_until[real][id-1]))
ans+=strt-from;
}
k = y;
}
}
i=j;
}
// cout<<res<<" "<<ans<<" "<<same<<endl;
cout<<res-ans+diff<<endl;
}
|
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
const int M = 200005;
#define int long long
#define pii pair<int,int>
#define make make_pair
int read()
{
int x=0,f=1;char c;
while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return x*f;
}
int n,m,k,cnt,ans,sum,ch[M][26];
vector<int> id[M],pos[M];map<string,vector<string>>mp;
//tire
void ins(string s,int x)
{
pos[x].clear();
for(int i=0;i<=m;i++) pos[x].push_back(0);
id[1].push_back(x);
pos[x][m]=1;
for(int i=m-1,p=1;i>=0;i--)
{
int c=s[i]-'a';
if(!ch[p][c]) ch[p][c]=++cnt;
p=ch[p][c];
pos[x][i]=p;
id[p].push_back(x);
}
}
int ask(int p,int l,int r)
{
return lower_bound(id[p].begin(),id[p].end(),r)-
lower_bound(id[p].begin(),id[p].end(),l);
}
//solve
int solve(vector<string> a)
{
//init
n=a.size();m=a[0].size();
sort(a.begin(),a.end());
for(int i=0;i<=cnt;i++)
{
for(int j=0;j<26;j++) ch[i][j]=0;
id[i].clear();
}
cnt=1;
for(int i=0;i<n;i++) ins(a[i],i);
//work for ordered subsequence
vector<int> dec[n];
for(int i=0;i<n;i++)
{
for(int j=1;j<m;j++)
if(a[i][j-1]>a[i][j])
dec[i].push_back(j);
dec[i].push_back(m);
}
//work for lcp
vector<int> lcp(n);
for(int i=1;i<n;i++)
{
int j=0;
while(j<m && a[i][j]==a[i-1][j]) j++;
lcp[i]=j;
}
//cal
int res=n*(n-1);
vector<pii> stk;stk.push_back(make(n,-1));
for(int i=n-1;i>=0;i--)
{
for(int j=1;j<stk.size();j++)
{
int l=stk[j].first,r=stk[j-1].first,p=stk[j].second;
p=*upper_bound(dec[i].begin(),dec[i].end(),p);
res-=ask(pos[i][p],l,r);
}
while(stk.back().second>=lcp[i]) stk.pop_back();
stk.push_back(make(i,lcp[i]));
}
return res;
}
signed main()
{
k=read();
for(int i=0;i<k;i++)
{
string s,t;
cin>>s;t=s;
sort(t.begin(),t.end());
mp[t].push_back(s);
}
for(auto it:mp)
{
vector<string> a=it.second;
ans+=1337*a.size()*sum;
ans+=solve(a);
sum+=a.size();
}
printf("%lld\n",ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N=200050;
const long long p=(35ll<<45)+1;
int n;
string s[N],t[N];
int order[N];
long long solve(int l,int r)
{
int len=s[l].length();
if(len>=14)
{
long long ans=0;
for(int i=l;i<=r;++i)
for(int j=i+1;j<=r;++j)
{
int li=0,ri=len-1;
string &s1=s[order[i]],&s2=s[order[j]];
while(s1[li]==s2[li]) ++li;
while(s1[ri]==s2[ri]) --ri;
bool flag=false;
for(int k=li+1;k<=ri;++k)
if(s1[k]<s1[k-1])
{flag=true;break;}
if(flag)
{
flag=false;
for(int k=li+1;k<=ri;++k)
if(s2[k]<s2[k-1])
{flag=true;break;}
}
ans+=1+flag;
}
return ans;
}
else
{
static const vector<long long> q=[&]()
{
vector<long long> v(len,0);
v[0]=1;
for(int i=1;i<len;++i) v[i]=26ll*v[i-1]%p;
return v;
}();
vector<vector<unordered_map<long long,int>>> um(len,vector<unordered_map<long long,int>>(len));
long long ans=0;
for(int i=l;i<=r;++i)
{
string &s1=s[order[i]];
if(i!=l)
{
int last=0;
for(int j=1;j<len;++j)
if(s1[j]<s1[j-1])
{
long long hash=0;
for(int k=0;k<last;++k)
hash=(hash*26ll+(s1[k]-'a'))%p;
for(int k=len-1;k>=j;--k)
hash=(hash*26ll+(s1[k]-'a'))%p;
ans+=um[last][j-1][hash];
last=j;
}
long long hash=0;
for(int k=0;k<last;++k)
hash=(hash*26ll+(s1[k]-'a'))%p;
ans+=um[last][len-1][hash];
}
if(i!=r)
{
vector<long long> v1(len),v2(len);
v1[0]=s1[0]-'a';
for(int i=1;i<len;++i) v1[i]=(v1[i-1]*26ll+s1[i]-'a')%p;
v2[len-1]=s1[len-1]-'a';
for(int i=len-2;i>=0;--i) v2[i]=(v2[i+1]*26ll+s1[i]-'a')%p;
for(int i=0;i<len;++i)
for(int j=i;j<len;++j)
{
long long a=i==0?0:v1[i-1],b=j==len-1?0:v2[j+1];
long long hash=((__int128)a*q[len-1-j]+b)%p;
++um[i][j][hash];
}
}
}
for(auto &u:um)
for(auto &v:u)
v.clear();
for(int i=r;i>=l;--i)
{
string &s1=s[order[i]];
if(i!=r)
{
int last=0;
for(int j=1;j<len;++j)
if(s1[j]<s1[j-1])
{
long long hash=0;
for(int k=0;k<last;++k)
hash=(hash*26ll+(s1[k]-'a'))%p;
for(int k=len-1;k>=j;--k)
hash=(hash*26ll+(s1[k]-'a'))%p;
ans+=um[last][j-1][hash];
last=j;
}
long long hash=0;
for(int k=0;k<last;++k)
hash=(hash*26ll+(s1[k]-'a'))%p;
ans+=um[last][len-1][hash];
}
if(i!=l)
{
vector<long long> v1(len),v2(len);
v1[0]=s1[0]-'a';
for(int i=1;i<len;++i) v1[i]=(v1[i-1]*26ll+s1[i]-'a')%p;
v2[len-1]=s1[len-1]-'a';
for(int i=len-2;i>=0;--i) v2[i]=(v2[i+1]*26ll+s1[i]-'a')%p;
for(int i=0;i<len;++i)
for(int j=i;j<len;++j)
{
long long a=i==0?0:v1[i-1],b=j==len-1?0:v2[j+1];
long long hash=((__int128)a*q[len-1-j]+b)%p;
++um[i][j][hash];
}
}
}
return 1ll*(r-l+1)*(r-l)-ans;
}
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cin>>n;
for(int i=1;i<=n;++i)
{
cin>>s[i];
t[i]=s[i];
sort(t[i].begin(),t[i].end());
order[i]=i;
}
sort(order+1,order+n+1,[&](const int &a,const int &b){return t[a]<t[b];});
int last=1;
long long ans=0;
for(int i=2;i<=n;++i)
if(t[order[i]]!=t[order[i-1]])
{
ans+=solve(last,i-1)+1337ll*(i-last)*(last-1);
last=i;
}
ans+=solve(last,n)+1337ll*(n-last+1)*(last-1);
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
#define arr array
#define pb push_back
#define fs first
#define sc second
#define eb emplace_back
#define vt vector
#define all(x) (x).begin(), (x).end()
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
using namespace std;
typedef long long ll;
const int maxn=1e5;
const ll MAXLL=9223372036854775807;
void solve(){
int N;
cin >> N;
auto solve_pair=[&](string a, string b) -> int{
int len=(int)a.size();
int pref=0, suff=0;
while(a[pref]==b[pref]) pref++;
while(a[len-1-suff]==b[len-1-suff]) suff++;
return (is_sorted(a.begin()+pref, a.end()-suff)||is_sorted(b.begin()+pref, b.end()-suff))?1:2;
};
auto solve=[&](vt<string> group) -> long long{
int n=(int)group.size();
int len=(int)group[0].size();
ll res=0;
if (N<=4000){
rep(i, 0, n)
rep(j, i+1, n){
int tmp=solve_pair(group[i], group[j]);
res+=tmp;
}
return res;
}
res=2*n*(n-1ll)/2;
sort(all(group));
rep(i, 0, n){
string s=group[i];
for (int i=0; i<len; i++)
for (int j=i+2; j<=len; j++){
string other=s;
sort(other.begin()+i, other.begin()+j);
res-=(other[i]!=s[i])&&(other[j-1]!=s[j-1])&&(binary_search(group.begin(), group.end(), other));
}
}
return res;
};
map<string, vt<string>> mp;
rep(i, 0, N){
string s;
cin >> s;
string sorted=s;
sort(all(sorted));
mp[sorted].pb(s);
}
ll ans= 1337*N*(N-1ll)/2;
for (auto gr:mp){
vt<string> v=gr.second;
int n=(int)v.size();
ans-=1337*n*(n-1ll)/2;
ans+=solve(v);
}
cout << ans << endl;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
solve();
}
|
#include<bits/stdc++.h>
typedef int LL;
typedef long long ll;
typedef double dl;
#define opt operator
#define pb push_back
#define pii std::pair<LL,LL>
const LL maxn=2e5+9,mod=998244353,inf=0x3f3f3f3f;
LL Read(){
LL x(0),f(1); char c=getchar();
while(c<'0' || c>'9'){
if(c=='-') f=-1; c=getchar();
}
while(c>='0' && c<='9'){
x=(x<<3ll)+(x<<1ll)+c-'0'; c=getchar();
}return x*f;
}
void Chkmin(LL &x,LL y){
if(y<x) x=y;
}
void Chkmax(LL &x,LL y){
if(y>x) x=y;
}
LL add(LL x,LL y){
return x+=y,x>=mod?x-mod:x;
}
LL dec(LL x,LL y){
return x-=y,x<0?x+mod:x;
}
LL mul(LL x,LL y){
return 1ll*x*y%mod;
}
LL Pow(LL base,LL b){
LL ret(1); while(b){
if(b&1) ret=mul(ret,base); base=mul(base,base); b>>=1;
}return ret;
}
ll ret;
LL n,nod,L;
LL son[maxn][26];
std::string s[maxn];
std::vector<LL> Set[maxn];
std::map<std::vector<LL>,std::vector<std::string> > mp;
std::map<std::vector<LL>,std::vector<std::string> >::iterator it1;
void Init(){
n=Read();
for(LL i=1;i<=n;++i){
std::cin>>s[i];
}
L=s[1].size();
}
void Clear(){
for(LL i=1;i<=nod;++i){
memset(son[i],0,sizeof(son[i]));
std::vector<LL>().swap(Set[i]);
}
}
LL Query(LL nw,LL l,LL r){
LL lt,rt;
if(Set[nw].back()<l) return 0;
lt=std::lower_bound(Set[nw].begin(),Set[nw].end(),l)-Set[nw].begin();
if(Set[nw].back()<=r) rt=Set[nw].size()-1;
else{
rt=std::upper_bound(Set[nw].begin(),Set[nw].end(),r)-Set[nw].begin()-1;
}
return rt-lt+1;
}
void Solve(std::vector<std::string> S){
if(S.size()==1) return;
// puts("#");
// exit(0);
// /*
std::sort(S.begin(),S.end());
// puts("--------------");
// for(LL i=0;i<S.size();++i) std::cout<<S[i]<<std::endl;
nod=1;
static std::vector<LL> Id[maxn];
for(LL i=0;i<S.size();++i){
LL nw(1);
std::vector<LL>().swap(Id[i]);
Id[i].resize(L+1);
Id[i][L]=1;
Set[nw].pb(i);
for(LL j=L-1;j>=0;--j){
LL c(S[i][j]-'a');
if(!son[nw][c]){
son[nw][c]=++nod;
}
nw=son[nw][c];
Id[i][j]=nw;
Set[nw].pb(i);
}
}
for(LL i=1;i<=nod;++i){
std::sort(Set[i].begin(),Set[i].end());
}
LL sz(S.size());
ret+=1ll*sz*(sz-1);
// printf("%lld\n",ret);
std::vector<pii> Lcp;
static LL f[maxn];
for(LL i=sz-2;i>=0;--i){
LL j(-1);
while(j!=(L-1) && S[i][j+1]==S[i+1][j+1]) ++j;
// printf("%d:%d\n",i,j);
LL x(i+1);
while(Lcp.size() && Lcp.back().second>=j){
x=Lcp.back().first;
Lcp.pop_back();
}
Lcp.pb(pii(x,j));
for(LL l=0,r;l<L;l=r+1){
r=l;
while(r^(L-1) && S[i][r]<=S[i][r+1]) ++r;
for(LL j=l;j<=r;++j) f[j]=Id[i][r+1];
}
for(LL j=Lcp.size()-1,l=i+1;j>=0;--j){
// printf("(%d,%d)",l,Lcp[j].first);
ret-=Query(f[Lcp[j].second+1],l,Lcp[j].first);
l=Lcp[j].first+1;
}
// puts("");
}
Clear();
// printf("%lld\n",ret);
// */
}
void Dfs(std::vector<std::string> A){
// exit(0);
}
void Solve(){
for(LL i=1;i<=n;++i){
std::vector<LL> A;
for(LL c=0;c<26;++c){
LL num(0);
for(LL j=0;j<L;++j) num+=(s[i][j]-'a'==c);
A.pb(num);
}
mp[A].pb(s[i]);
}
for(it1=mp.begin();it1!=mp.end();++it1){
// puts("#1");
static std::vector<std::string> S;
S=(it1->second);
// printf("%d\n",(it1->second).size());
// for(LL i=0;i<S.size();++i){
// std::cout<<S[i]<<std::endl;
// }
// Dfs(S);
// puts("#");
Solve(S);
// exit(0);
}
// printf("%lld\n",ret);
LL pre(0);
for(it1=mp.begin();it1!=mp.end();++it1){
ret+=1ll*pre*((it1->second).size())*1337;
pre+=(it1->second).size();
}
printf("%lld\n",ret);
}
int main(){
Init();
Solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define N 400010
typedef long long ll;
typedef unsigned long long ull;
const ull base=1145141;
inline ll read(){
ll x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-')f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
int n,m,d[N];
ll qwq,pvp,qaq,ans; //qwq:<=2 pvp:=1 qaq:<=0
ull pw[N],f[N];
string s[N];
vector<ull> h[N];
map<ull,int> A,B,id;
inline ull Hash(vector<ull> &h,int l,int r){
if(l>r)return 0;
return h[r]-(l==0?0:h[l-1])*pw[r-l+1];
}
inline ull get_hash(string &s){
ull h=0;
for(int i=0;i<(int)s.length();++i){
h=h*base+s[i];
}
return h;
}
int cnt;
map<ull,int> mp[N];
vector<ull> q[N];
struct node{
int ch[26];
}trie[N];
void Merge(map<ull,int> &A,map<ull,int> &B){
if(A.size()<B.size())swap(A,B);
for(auto [h,w]:B)A[h]+=w;
B.clear();
}
void dfs(int u){
for(int c=0;c<26;++c){
int v=trie[u].ch[c];
if(!v)continue;
dfs(v);
Merge(mp[u],mp[v]);
}
for(auto x:q[u]){
pvp+=mp[u][x];
}
}
int main(){
n=read();
for(int i=1;i<=n;++i){
cin>>s[i];
}
m=s[1].length();
for(int i=1;i<=n;++i){
h[i].resize(m);
h[i][0]=s[i][0];
for(int j=1;j<m;++j){
h[i][j]=h[i][j-1]*base+s[i][j];
}
}
pw[0]=1;
for(int i=1;i<=m;++i){
pw[i]=pw[i-1]*base;
}
for(int i=1;i<=n;++i){
string t=s[i];
sort(t.begin(),t.end());
++A[f[i]=get_hash(t)];
++B[h[i][m-1]];
if(!id.count(f[i]))id[f[i]]=++cnt;
}
for(auto [h,w]:A){
qwq+=1LL*w*(w-1)/2;
}
ans=(1LL*n*(n-1)/2-qwq)*1337;
for(int i=1;i<=n;++i){
static set<ull> S;
int las,u;
u=las=id[f[i]];
for(int j=m-1;j>=0;--j){
int c=s[i][j]-'a';
if(!trie[u].ch[c])trie[u].ch[c]=++cnt;
u=trie[u].ch[c];
if(!j||s[i][j]<s[i][j-1]){
q[las].push_back(!j?0ull:h[i][j-1]);
las=u;
++d[i];
}
}
++mp[u][0];
for(int j=0;j<m;++j){
++mp[u][h[i][j]];
}
}
for(int i=1;i<=(int)A.size();++i){
dfs(i);
}
for(int i=1;i<=n;++i){
pvp-=B[h[i][m-1]]*d[i];
}
ans+=pvp;
for(auto [h,w]:B){
qaq+=1LL*w*(w-1)/2;
}
ans+=(qwq-pvp-qaq)*2;
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
#define int long long
#define double long double
//#define endl '\n'
#define st first
#define nd second
#define pb push_back
#define sz(x) (int)(x).size()
using namespace std;
double PI=3.14159265359;
int inf=1000000000000000007;
int mod=1000000007;
int mod1=998244353;
const bool multi=0;
string s[200007];
string s1[200007];
int it=1,n,m;
int fen[400007];
int trie[200007][27];
int pre[200007],post[200007],c=0;
int last[27];
void dfs(int v)
{
pre[v]=++c;
for(int j=0;j<26;j++) if(trie[v][j]>0) dfs(trie[v][j]);
post[v]=c;
}
inline void ins(int x,int val) {while(x<=it) { fen[x]+=val; x+=(x&-x); } }
inline int que(int x) {int res=0; while(x>0) { res+=fen[x]; x-=(x&-x); } return res; }
vector<int> gdzie[200007];
vector<int> mx[200007];
int pairs;
void solve(vector<int> id,int j)
{
if(sz(id)<=1||j>=m) return ;
for(auto x:id) ins(pre[gdzie[x][0]],1);
vector<int>vec[26];
for(auto x:id) vec[s[x][j]-'a'].pb(x);
for(int i=0;i<26;i++)
{
for(auto x:vec[i]) ins(pre[gdzie[x][0]],-1);
for(auto x:vec[i]) pairs+=que(post[gdzie[x][mx[x][j]]])-que(pre[gdzie[x][mx[x][j]]]-1);
for(auto x:vec[i]) ins(pre[gdzie[x][0]],1);
}
for(auto x:id) ins(pre[gdzie[x][0]],-1);
for(int i=0;i<26;i++) solve(vec[i],j+1);
}
map<string,int>mapa;
signed main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt;
if(multi)
cin>>tt;
else tt=1;
while(tt--)
{
cin>>n;
for(int i=1;i<=n;i++) cin>>s[i];
m=sz(s[1]);
for(int i=1;i<=n;i++)
{
for(int j=0;j<=m+1;j++)
{
gdzie[i].pb(0);
mx[i].pb(0);
}
int p=1;
gdzie[i][m]=1;
for(int j=m-1;j>=0;j--)
{
if(trie[p][s[i][j]-'a']==0) trie[p][s[i][j]-'a']=++it;
p=trie[p][s[i][j]-'a'];
gdzie[i][j]=p;
}
}
dfs(1);
for(int i=1;i<=n;i++)
{
for(int j=0;j<26;j++) last[j]=m;
mx[i][m]=m;
for(int j=m-1;j>=0;j--)
{
int xd=mod;
last[s[i][j]-'a']=j;
for(int l=s[i][j]-'a'-1;l>=0;l--) xd=min(xd,last[l]);
mx[i][j]=min(xd,mx[i][j+1]);
}
}
vector<int>act;
for(int i=1;i<=n;i++)
{
s1[i]=s[i];
sort(s1[i].begin(),s1[i].end());
}
vector<pair<string,int>>vec;
for(int i=1;i<=n;i++) vec.pb({s1[i],i});
sort(vec.begin(),vec.end());
act.pb(vec[0].nd);
int ans=0,bad=0,good=0;
for(int i=1;i<=n;i++)
{
good+=mapa[s[i]];
mapa[s[i]]++;
}
for(int i=1;i<n;i++)
{
if(vec[i].st!=vec[i-1].st)
{
pairs=0;
solve(act,0);
ans+=pairs;
ans+=2*(sz(act)*(sz(act)-1)/2-pairs);
bad+=sz(act)*(n-sz(act));
act.clear();
}
act.pb(vec[i].nd);
}
pairs=0;
solve(act,0);
ans+=pairs;
ans+=2*(sz(act)*(sz(act)-1)/2-pairs);
bad+=sz(act)*(n-sz(act));
ans+=bad/2*1337;
ans-=good*2;
cout<<ans<<endl;
}
return 0;
}
|
#define __AVX__ 1
#define __AVX2__ 1
#define __SSE__ 1
#define __SSE2__ 1
#define __SSE2_MATH__ 1
#define __SSE3__ 1
#define __SSE4_1__ 1
#define __SSE4_2__ 1
#define __SSE_MATH__ 1
#define __SSSE3__ 1
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
#include <bits/stdc++.h>
using namespace std;
#define rep(i, l, r) for(auto i=(l);i<=(r);++i)
#define per(i, r, l) for(auto i=(r);i>=(l);--i)
#define N 200020
#define ll long long
const int P1 = 31, D1 = 1000173169, P2 = 61, D2 = 1e9 + 7;
int f1[26][N], f2[26][N];
int pw1[N], pw2[N];
struct pair_hash {
inline size_t operator()(const pair<int, int> &p) const {
auto h1 = hash<int>{}(p.first);
auto h2 = hash<int>{}(p.second);
return h1 ^ h2;
}
};
vector<int> ff1[N], ff2[N];
inline void build(int idx, string &s) {
ff1[idx].resize(s.size() + 1), ff2[idx].resize(s.size() + 1);
ff1[idx][0] = ff2[idx][0] = 0;
rep(i, 1, s.size())ff1[idx][i] = 1ll * (1ll * ff1[idx][i - 1] * P1 + s[i - 1]) % D1;
rep(i, 1, s.size())ff2[idx][i] = 1ll * (1ll * ff2[idx][i - 1] * P2 + s[i - 1]) % D2;
}
inline pair<int, int> hsh(int idx, int l, int r) {
int h1 = 1ll * (ff1[idx][r] - 1ll * ff1[idx][l - 1] * pw1[r - l + 1] % D1 + D1) % D1;
int h2 = 1ll * (ff2[idx][r] - 1ll * ff2[idx][l - 1] * pw2[r - l + 1] % D2 + D2) % D2;
return {h1, h2};
}
struct node {
int ct[26];
string s;
inline void read() {
cin >> s;
for (auto v:s)++ct[v - 97];
}
inline bool operator==(const node &b) const {
rep(i, 0, 25)if (ct[i] != b.ct[i])return 0;
return 1;
}
inline bool operator<(const node &b) const {
rep(i, 0, 25)if (ct[i] != b.ct[i])return ct[i] > b.ct[i];
return 0;
}
} S[N];
int n;
unordered_map<pair<int, int>, int, pair_hash> mp, mmp;
map<node, int> MP;
vector<int> sm[N];
inline void solve() {
cin >> n;
rep(i, 1, n)S[i].read();
int m = S[1].s.size();
pw1[0] = pw2[0] = 1;
rep(i, 1, m + 1)pw1[i] = 1ll * pw1[i - 1] * P1 % D1;
rep(i, 1, m + 1)pw2[i] = 1ll * pw2[i - 1] * P2 % D2;
rep(i, 1, n)build(i, S[i].s);
if (n <= 4000) {
rep(i, 1, n) {
sm[i].resize(m + 1);
sm[i][0] = 0;
rep(j, 1, m) {
sm[i][j] = sm[i][j - 1];
if (j < m)sm[i][j] += S[i].s[j] < S[i].s[j - 1];
}
}
auto f = [&](int &x, node &a, int &y, node &b) {
if (!(a == b))return 1337;
if (hsh(x, 1, m) == hsh(y, 1, m))return 0;
/*int l = 1, r = m;
while (l <= r) {
int m = l + r >> 1;
if (hsh(x, 1, m) == hsh(y, 1, m))l = m + 1;
else r = m - 1;
}
int L = l;
l = 1, r = m;
while (l <= r) {
int mid = l + r >> 1;
if (hsh(x, mid, m) == hsh(y, mid, m))r = mid - 1;
else l = mid + 1;
}
int R = r;*/
//为啥二分过不了，暴力就过了
int l = 0, r = a.s.size() - 1;
while (l <= r && a.s[l] == b.s[l])++l;
while (l <= r && a.s[r] == b.s[r])--r;
int L = l + 1, R = r + 1;
int res = 0;
if (sm[x][R - 1] - sm[x][L - 1] == 0)++res;
if (sm[y][R - 1] - sm[y][L - 1] == 0)++res;
if (res > 0)return 1;
return 2;
};
ll ans = 0;
rep(i, 1, n)rep(j, i + 1, n)ans += f(i, S[i], j, S[j]);
printf("%lld\n", ans);
return;
}
rep(i, 1, n) {
++mp[hsh(i, 1, S[i].s.size())];
++MP[S[i]];
}
rep(j, 0, 25) {
f1[j][0] = f2[j][0] = 0;
rep(i, 1, N - 1)f1[j][i] = 1ll * (1ll * f1[j][i - 1] * P1 + j + 97) % D1;
rep(i, 1, N - 1)f2[j][i] = 1ll * (1ll * f2[j][i - 1] * P2 + j + 97) % D2;
}
auto mix = [&](int *ct) {
int x = f1[0][ct[0]], y = f2[0][ct[0]];
rep(i, 1, 25) if (ct[i]) {
x = (1ll * x * pw1[ct[i]] % D1 + f1[i][ct[i]]) % D1;
y = (1ll * y * pw2[ct[i]] % D2 + f2[i][ct[i]]) % D2;
}
return pair<int, int>{x, y};
};
ll ans = 0;
ll Ans = 0;
auto hsmix = [&](pair<int, int> l, int len1, pair<int, int> r) {
return pair<int, int>{(1ll * l.first * pw1[len1] % D1 + r.first) % D1,
(1ll * l.second * pw2[len1] % D2 + r.second) % D2};
};
int ct[26];
rep(i, 1, n) {
mmp.clear(), mmp[hsh(i, 1, m)] = 1;
rep(l, 1, m) {
rep(k, 0, 25)ct[k] = 0;
++ct[S[i].s[l - 1] - 97];
int p = l + 1;
while (p <= m && S[i].s[p - 1] >= S[i].s[p - 2])++ct[S[i].s[p - 1] - 97], ++p;
rep(r, p, m) {
++ct[S[i].s[r - 1] - 97];
auto mid = mix(ct);
auto x = hsmix(hsh(i, 1, l - 1), r - l + 1, mid);
x = hsmix(x, m - r, hsh(i, r + 1, m));
if (mmp.count(x))continue;
if (mp.count(x))ans -= mp[x];
mmp[x] = 1;
}
}
ans -= mp[hsh(i, 1, m)];
}
for (auto[u, v]:MP)Ans += 1337ll * v * (n - v), ans += 1ll * v * v;
//printf("%d\n", ans);
printf("%lld\n", ans + Ans / 2);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int T = 1;
//scanf("%d",&T);
while (T--)solve();
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pl;
typedef double db;
#define ls(x) ((x)<<1)
#define rs(x) ((x)<<1|1)
#define low(x) ((x)&-(x))
#define all(x) x.begin(),x.end()
#define mp make_pair
#define X first
#define Y second
#ifdef _DEBUG
const int N=1e3+10;
#else
const int N=1e6+10;
#endif
const ll mod=1e9+7;
//const ll mod=998244353;
inline ll gcd(ll a,ll b){return !b?a:gcd(b,a%b);}
inline ll q_pow(ll a,ll x){ll ans=1,tmp=a;while(x){if(x&1)(ans*=tmp)%=mod;(tmp*=tmp)%=mod;x>>=1;}return ans;}
template<typename T> inline void re(T &N){int f=1;char c;while((c=getchar())< '0'||c> '9')if(c=='-')f=-1;N=c-'0';while((c=getchar())>='0'&&c<='9')N=N*10+c-'0';N*=f;}
int m,n,t=1,st,en;
string s[N];
namespace s1{
int c1[30],c2[30];
ll solve()
{
ll ans=0;
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++)
{
memset(c1,0,sizeof(c1));
memset(c2,0,sizeof(c2));
for(int k=0;k< m;k++)
{
c1[s[i][k]-'a']++;
c2[s[j][k]-'a']++;
}
int res=2;
for(int k=0;k< 26;k++)
if(c1[k]!=c2[k]){res=1337;break;}
if(res==1337){ans+=1337;continue;}
int pre=-1,suf=m;
for(int k=0;k< m;k++)
{
if(s[i][k]==s[j][k])pre=k;
else break;
}
for(int k=m-1;k>=0;k--)
{
if(s[i][k]==s[j][k])suf=k;
else break;
}
int ok=3;
for(int k=pre+1;k< suf-1&&ok;k++)
{
if(s[i][k]> s[i][k+1])ok&=2;
if(s[j][k]> s[j][k+1])ok&=1;
}
ans+=res-(ok> 0);
}
return ans;
}
}
namespace s2{
int c1[30],c2[30];
inline int cmp(const string &a,const string &b)
{
memset(c1,0,sizeof(c1));
memset(c2,0,sizeof(c2));
for(int i=0;i< m;i++)
{
c1[a[i]-'a']++;
c2[b[i]-'a']++;
}
for(int i=0;i< 26;i++)
if(c1[i]!=c2[i])return c1[i]< c2[i];
return a< b;
}
inline int check(const string &a,const string &b)
{
memset(c1,0,sizeof(c1));
memset(c2,0,sizeof(c2));
for(int i=0;i< m;i++)
{
c1[a[i]-'a']++;
c2[b[i]-'a']++;
}
for(int i=0;i< 26;i++)
if(c1[i]!=c2[i])return 0;
return 1;
}
ll solve()
{
ll ans=0;
sort(s+1,s+n+1,cmp);
for(int l=1,r=1;l<=n;l=r=r+1)
{
while(r< n&&check(s[l],s[r+1]))r++;
ans+=1337ll*(r-l+1)*(n-r);
int sum=0;
for(int i=0;i< m;i++)
for(int j=i+1;j< m;j++)
for(int k=l;k<=r;k++)
{
string tmp=s[k];
sort(tmp.begin()+i,tmp.begin()+j+1);
if(tmp[i]!=s[k][i]&&tmp[j]!=s[k][j]&&binary_search(s+l,s+r+1,tmp))sum++;
}
ans+=1ll*(r-l+1)*(r-l)-sum;
}
return ans;
}
}
int main()
{
#ifdef _DEBUG
freopen("data.txt","r",stdin);
#endif
ios::sync_with_stdio(0);
cin>>n;
for(int i=1;i<=n;i++)cin>>s[i];
m=s[1].length();
if(n<=7000)cout<<s1::solve()<<'\n';
else cout<<s2::solve()<<'\n';
}
|
#include<bits/stdc++.h>
#define forn(i, n) for (int i = 0; i < (n); i++)
#define forab(i, a, b) for (int i = (a); i <= (b); i++)
#define forba(i, b, a) for (int i = (b); i >= (a); i--)
#define mset(a, x, n) memset(a, x, sizeof(a[0]) * (n))
#define updiv(x, y) (((x) + (y) - 1) / (y)) // y > 0
#define pb(x) push_back(x)
#define eb emplace_back
#define mp(x, y) make_pair(x, y)
#define fi first
#define se second
#define sz(x) ((int)x.size())
#define all(x) (x).begin(), (x).end()
#ifdef hat
#define fast
#define de(x) cerr << #x << '=' << (x) << ' '
#define dee(x) cerr << #x << '=' << (x) << endl
#else
#define endl '\n'
#define fast ios::sync_with_stdio(0), cin.tie(0)
#define de(x) ((void) 0)
#define dee(x) ((void) 0)
#endif
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef pair<int, int> pii;
typedef vector<int> VI;
const int maxn = 3e5 + 5;
const int mod = 998244353;
const int INF = 0x3f3f3f3f;
const ll llINF = 0x3f3f3f3f3f3f3f3f;
ll make_compiler_happy() {return INF & maxn & mod & llINF;}
ll fpow(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
ll inv(ll x) {return fpow(x, mod-2);}
mt19937 gen(chrono::high_resolution_clock::now().time_since_epoch().count());
struct Trie
{
vector<array<int, 26>> ch;
vector<vector<int>> id;
Trie() {ch.push_back({}); id.push_back({});}
vector<int> rev_insert(const string &s, int x)
{
int n = sz(s);
int u = 0;
vector<int> pos;
id[u].pb(x);
pos.pb(u);
forba(i, n - 1, 0)
{
int v = s[i] - 'a';
if(!ch[u][v]) {
ch[u][v] = sz(ch);
ch.push_back({});
id.push_back({});
}
u = ch[u][v];
id[u].pb(x);
pos.pb(u);
}
reverse(all(pos));
return pos;
}
int query(int p, int l, int r)
{
return lower_bound(all(id[p]), r) - lower_bound(all(id[p]), l);
}
};
int main()
{
fast;
int n;
cin >> n;
vector<string> s(n);
map<string, vector<string>> mp;
forn(i, n)
{
cin >> s[i];
string t = s[i];
sort(all(t));
mp[t].push_back(s[i]);
}
int m = sz(s[0]);
ll ans = 0, sumg = 0;
for(auto &t : mp)
{
dee(t.fi);
auto &g = t.se;
ans += (ll)sz(g) * (sz(g) - 1);
ans += sumg * sz(g) * 1337;
sumg += sz(g);
sort(all(g));
Trie trie;
vector<VI> pos(sz(g));
forn(i, sz(g))
{
pos[i] = trie.rev_insert(g[i], i);
}
vector<int> lcp(sz(g));
forab(i, 1, sz(g) - 1)
{
forn(j, m)
{
if(g[i][j] == g[i - 1][j]) lcp[i]++;
else break;
}
}
vector<pii> stk;
stk.eb(sz(g), -1);
forba(i, sz(g) - 1, 0)
{
vector<int> dec;
forn(j, m)
{
if(!j || g[i][j] < g[i][j - 1]) dec.pb(j);
}
dec.pb(m);
forab(j, 1, sz(stk) - 1)
{
auto tt = upper_bound(all(dec), stk[j].se);
int r = *tt;
ans -= trie.query(pos[i][r], stk[j].fi, stk[j - 1].fi);
}
while(stk.back().se >= lcp[i]) stk.pop_back();
stk.eb(i, lcp[i]);
}
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define MAXN 200005
#define lowbit(x) (x&-x)
#define reg register
#define mkpr make_pair
typedef long long LL;
typedef unsigned long long uLL;
const int INF=0x3f3f3f3f;
const int mod1=998244353;
const int mod2=1e9+7;
const int mod3=1e9+9;
const int iv2=5e8+4;
const int lim=1000000;
const int jzm=1e6+7;
const int orG=3,invG=332748118;
const double Pi=acos(-1.0);
typedef pair<int,int> pii;
const double PI=acos(-1.0);
template<typename _T>
_T Fabs(_T x){return x<0?-x:x;}
template<typename _T>
void read(_T &x){
_T f=1;x=0;char s=getchar();
while(s>'9'||s<'0'){if(s=='-')f=-1;s=getchar();}
while('0'<=s&&s<='9'){x=(x<<3)+(x<<1)+(s^48);s=getchar();}
x*=f;
}
template<typename _T>
void print(_T x){if(x<0){x=(~x)+1;putchar('-');}if(x>9)print(x/10);putchar(x%10+'0');}
int gcd(int x,int y){return !y?x:gcd(y,x%y);}
int n,sum,num[30],tot,id[MAXN],n1,root[MAXN];LL ans;
char str[MAXN],ss[10];
struct hashnode{
int fir,sec,tri;
int ask(int dep){
if(dep>=60)return (fir>>dep-60)&1;
if(dep>=30)return (sec>>dep-30)&1;
return (tri>>dep)&1;
}
bool operator == (const hashnode &rhs)const{
return fir==rhs.fir&&sec==rhs.sec&&tri==rhs.tri;
}
}suf[MAXN],pre[MAXN];
struct ming{int st,ed,len,hs;}a[MAXN];
struct node{int ch[2],sum;};
struct node1{int ch[30],sum;};
vector<int>vec[MAXN],tp[30];
map<int,int>mp;
class TrieTree{
public:
int tot;node tr[MAXN*90];
void clear(){tot=0;tr[0].sum=tr[0].ch[0]=tr[0].ch[1]=0;}
void insert(int &now,int las,hashnode val,int dep=89){
if(now==las||!now)tr[now=++tot]=tr[las];
if(dep<0){tr[now].sum++;return ;}
if(val.ask(dep))insert(tr[now].ch[1],tr[las].ch[1],val,dep-1);
else insert(tr[now].ch[0],tr[las].ch[0],val,dep-1);
}
int query(int rt,hashnode val,int dep=89){
if(!rt)return 0;if(dep<0)return tr[rt].sum;
if(val.ask(dep))return query(tr[rt].ch[1],val,dep-1);
return query(tr[rt].ch[0],val,dep-1);
}
}T;
class superTrie{
public:
int tot;node1 tr[MAXN*10];
void clear(){tot=0;tr[0].sum=tr[0].ch[0]=tr[0].ch[1]=0;}
void insert(int &now,int las,int dep){
if(now==las||!now)tr[now=++tot]=tr[las];
if(dep<0){tr[now].sum++;return ;}
insert(tr[now].ch[ss[dep]-'a'],tr[las].ch[ss[dep]-'a'],dep-1);
}
int query(int rt,int dep){
if(!rt)return 0;if(dep<0)return tr[rt].sum;
return query(tr[rt].ch[ss[dep]-'a'],dep-1);
}
}T1;
bool compare(int x,int y,int len){if(!len)return 1;return pre[len+a[x].st-1]==pre[len+a[y].st-1];}
void modify(int i,int l,int r){
if(n1>9)T.insert(root[i],root[i-1],suf[l]);
else{
for(int j=0;j<n1;j++)ss[j]=0;
int sm=0;for(int j=l;j<r;j++)ss[sm++]=str[j];
//printf("insert %s\n",ss);
T1.insert(root[i],root[i-1],sm-1);
}
}
int found(int i,int l,int r){
if(n1>9)return T.query(root[i],suf[l]);
else{
for(int j=0;j<n1;j++)ss[j]=0;
int sm=0;for(int j=l;j<r;j++)ss[sm++]=str[j];
//printf("query %s\n",ss);
return T1.query(root[i],sm-1);
}
}
signed main(){
read(n);
for(int i=1;i<=n;i++){
scanf("\n%s",str+sum);a[i].st=sum;
a[i].len=(int)strlen(str+sum);sum+=a[i].len;n1=a[i].len;a[i].ed=sum;
for(int j=1;j<=26;j++)num[j]=0;
for(int j=0;j<a[i].len;j++)num[str[j+a[i].st]-'a'+1]++;
for(int j=1;j<=26;j++)a[i].hs=(1ll*jzm*a[i].hs+1ll*num[j])%mod1;
if(n1>9)for(int j=n1-1;j>=0;j--)
suf[j+a[i].st].fir=(31ll*suf[j+a[i].st+1].fir+1ll*(str[j+a[i].st]-'a'+1))%mod1,
suf[j+a[i].st].sec=(31ll*suf[j+a[i].st+1].sec+1ll*(str[j+a[i].st]-'a'+1))%mod2,
suf[j+a[i].st].tri=(31ll*suf[j+a[i].st+1].tri+1ll*(str[j+a[i].st]-'a'+1))%mod3;
//printf("%s:%d\n",str+j+a[i].st,suf[j+a[i].st].fir);
pre[a[i].st].fir=pre[a[i].st].sec=pre[a[i].st].tri=str[a[i].st]-'a'+1;
for(int j=1;j<n1;j++)
pre[j+a[i].st].fir=(31ll*pre[j+a[i].st-1].fir+1ll*(str[j+a[i].st]-'a'+1))%mod1,
pre[j+a[i].st].sec=(31ll*pre[j+a[i].st-1].sec+1ll*(str[j+a[i].st]-'a'+1))%mod2,
pre[j+a[i].st].tri=(31ll*pre[j+a[i].st-1].tri+1ll*(str[j+a[i].st]-'a'+1))%mod3;
if(!mp[a[i].hs])mp[a[i].hs]=++tot;vec[mp[a[i].hs]].push_back(i);
}
int pre=0;mp.clear();
for(int i=1;i<=tot;i++){
int siz=vec[i].size();ans+=1ll*siz*(siz-1);ans+=1337ll*siz*pre;pre+=siz;
for(int j=1;j<=siz;j++)id[j]=vec[i][j-1];
for(int j=n1-1;j>=0;j--){
for(int k=1;k<=siz;k++)tp[str[j+a[id[k]].st]-'a'+1].push_back(id[k]);int sum=0;
for(int k=26;k>0;k--){for(int l=0;l<(int)tp[k].size();l++)id[++sum]=tp[k][l];tp[k].clear();}
}
for(int j=2;j<=siz;j++){
//printf("%d %d:%d\n",i,j,id[j]);
int l=1,r=j-1,tmp=j-1;for(int k=0;k<n1;k++)modify(j-1,a[id[j-1]].st+k,a[id[j-1]].ed);//printf("insert %d %d\n",suf[a[id[j]].st+k].fir,a[id[j]].st+k);
if(compare(id[j-1],id[j],n1)){while(l<r){int mid=l+r>>1;if(compare(id[j],id[mid],n1))r=mid;else l=mid+1;}tmp=l-1;}
ans-=2ll*(j-tmp-1);int head=0;if(!tmp)continue;
for(int k=1;k<n1;k++)
if(str[k+a[id[j]].st]<str[k+a[id[j]].st-1]){
l=1,r=tmp;if(!compare(id[tmp],id[j],head)){head=k;continue;}
while(l<r){int mid=l+r>>1;if(compare(id[j],id[mid],head))r=mid;else l=mid+1;}
ans-=1ll*found(tmp,a[id[j]].st+k,a[id[j]].ed)-1ll*found(l-1,a[id[j]].st+k,a[id[j]].ed);head=k;
//printf("%d range %d %d:%lld %d %c %c\n",j,head,k,ans,l,str[k+a[id[j]].st],str[k+a[id[j]].st-1]);
}
if(compare(id[tmp],id[j],head)){l=1,r=tmp;while(l<r){int mid=l+r>>1;if(compare(id[j],id[mid],head))r=mid;else l=mid+1;}ans-=1ll*(tmp-l+1);}
//printf("%d range %d %d:%lld\n",j,head,n1,ans);
}
for(int j=0;j<=siz;j++)root[j]=0;if(n1>9)T.clear();else T1.clear();
}
printf("%lld\n",ans);
return 0;
}
/*
bac
acb
abc
*/
|
#include<bits/stdc++.h>
using namespace std;
//======================
//
// Template OleschY
//
// Die M�glichkeiten der deutschen Grammatik k�nnen
// einen, wenn man sich darauf, was man ruhig, wenn
// man m�chte, sollte, einl�sst, �berraschen.
// - @Gedankenbalsam
//
//======================
//======================
// Output/Debug
//======================
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (int i = 0; i < v.size(); ++i)
{
os << v[i];
if (i != v.size() - 1)
os << ", ";//123123
}
os << "]\n";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p)
{
os << "[";
os << p.first;
os << ", ";
os << p.second;
os << "]";
return os;
}
#ifndef ONLINE_JUDGE
#define debug(x) cout << (#x) << " is " << (x) << endl
#else
#define debug(...) 42
#endif
//======================
// Solution Single testcase
//======================
pair<int, int> getlr(const string& st1, const string& st2)
{
int ssize = st1.size();
assert(st1.size() == st2.size());
pair<int, int> borders = {-1, ssize};
for(int l = 0; l < ssize; l++)
{
if(st1[l] == st2[l])
{
borders.first = l;
}
else break;
}
for(int r = ssize - 1; r >= 0; r--)
{
if(st1[r] == st2[r])
{
borders.second = r;
}
else break;
}
borders.first++;
borders.second = ssize - borders.second;
return borders;
}
long long nAll;
vector<pair<string, string>> in;
int solve()
{
for(int i = 0; i < nAll ; ++i)
{
in[i].second = in[i].first;
sort(in[i].second.begin(), in[i].second.end());
}
sort(in.begin(), in.end(), [](pair<string, string> const & a, pair<string, string> const & b)
{
return a.second < b.second || (a.second == b.second && a.first < b.first);
});
vector<vector<string>> strGroups;
for(int i = 0; i < nAll; i++)
{
if (i == 0 || in[i].second != in[i - 1].second) {
strGroups.push_back(vector<string>());
}
strGroups.rbegin()->push_back(in[i].first);
}
long long ans = 0;
long long ans1337 = 0;
long long ansWidthwisePairs = 0;
for(vector<string> Strs : strGroups) {
long long n = Strs.size();
long long ssize = Strs[0].size();
ans1337 += 1337 * n * (nAll - n);
ans += n * ( n - 1 );
if(n >= 6800)
{
auto& strs = Strs;
// check widthwise
sort(strs.begin(), strs.end());
for(string const& str : strs)
{
for(int i = 0; i < ssize; i++)
{
for(int j = i + 1; j < ssize; j++)
{
string temp = str;
sort(temp.begin() + i, temp.begin() + j + 1);
if(temp[i] != str[i])
{
if(temp[j] != str[j])
{
if(binary_search(strs.begin(), strs.end(), temp))
{
ansWidthwisePairs -= 2;
}
}
}
}
}
}
}
else
{
auto strs = Strs; 43;
// check pairwise 123123
for(int i = 0; i < n; i++)
{
for(int j = i + 1; j < n; j++)
{
auto [l, r] = getlr(strs[i], strs[j]);
if(r == ssize)
ans -= 2;
else
{
assert(strs[i].begin() + l <= strs[i].end() - r);
if(is_sorted(strs[i].begin() + l, strs[i].end() - r))
ans -= 1;
assert(strs[j].begin() + l <= strs[j].end() - r);
if(is_sorted(strs[j].begin() + l, strs[j].end() - r))
ans -= 1; ///123 1231
}
}
}
}
}
long long sum = ans1337 / 2 + ans + ansWidthwisePairs / 2 ;
cout << sum << "\n"; /// 123
return 0;
}
void input()
{
cin >> nAll;
in.resize(nAll);
for(int i = 0; i < nAll; ++i)
{
cin >> in[i].first;
}
solve();
}
//======================
// Technical stuff
//======================
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
//freopen("a.out", "w", stdout); // console output is better (in most cases)
#else
// add i/o method of specific testing system
#endif
input();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define INF 1234567890
#define ll long long
const int pri[2] = {2, 13};
const int mod[2] = {993244853, 1000000009};
int N;
map<string, vector<string> > m;
struct Node {
int l, r, s;
Node() { l = 0; r = 0; s = 0; }
};
vector<Node> seg(1);
map<pair<ll,ll>, int> root[200001][27];
int Update(int idx, int val, int n, int l, int r) // add
{
if (r < idx || idx < l) return n;
if (n == 0)
{
n = (int)seg.size();
seg.emplace_back(Node());
}
seg[n].s += val;
if (l == r) return n;
int mid = l+r>>1;
seg[n].l = Update(idx, val, seg[n].l, l, mid);
seg[n].r = Update(idx, val, seg[n].r, mid+1, r);
return n;
}
int Query(int L, int R, int n, int l, int r) // sum
{
if (n == 0) return 0;
if (r < L || R < l) return 0;
if (L <= l && r <= R) return seg[n].s;
int mid = l+r>>1;
return Query(L, R, seg[n].l, l, mid) + Query(L, R, seg[n].r, mid+1, r);
}
int main()
{
ios::sync_with_stdio(0); cin.tie(0);
cin.exceptions(ios::badbit | ios::failbit);
cin >> N;
for(int i=0; i<N; i++)
{
string s, ss;
cin >> s;
ss = s;
sort(ss.begin(), ss.end());
m[ss].push_back(s);
}
ll diff = 0, res = 0, tot = 0;
for(auto &[tmp,v] : m)
{
diff += (ll)(N - (ll)v.size()) * (ll)v.size();
tot += (ll)v.size() * ((ll)v.size()-1) / 2;
sort(v.begin(), v.end()); // prefix가 같은건 연속적으로 등장
// 전처리
vector<vector<pair<ll, ll> > > w(v.size());
for(int i=0; i<v.size(); i++)
{
string &s = v[i];
// suffix 길이마다 해시값 저장
pair<ll, ll> h = {0, 0};
w[i].push_back(h);
if (root[0][s.back()-'a'].find(h) == root[0][s.back()-'a'].end()) //
{
root[0][s.back()-'a'][h] = (int)seg.size();
seg.emplace_back(Node());
}
Update(i, 1, root[0][s.back()-'a'][h], 0, (int)v.size()-1);
if (root[0][26].find(h) == root[0][26].end())
{
root[0][26][h] = (int)seg.size();
seg.emplace_back(Node());
}
Update(i, 1, root[0][26][h], 0, (int)v.size()-1);
for(int j=(int)s.size()-1; j>=1; j--)
{
h.first = (h.first * pri[0] + (ll)s[j]) % mod[0];
h.second = (h.second * pri[1] + (ll)s[j]) % mod[1];
w[i].push_back(h);
int len = (int)s.size()-j;
if (root[len][s[j-1]-'a'].find(h) == root[len][s[j-1]-'a'].end())
{
root[len][s[j-1]-'a'][h] = (int)seg.size();
seg.emplace_back(Node());
}
Update(i, 1, root[len][s[j-1]-'a'][h], 0, (int)v.size()-1);
if (root[len][26].find(h) == root[len][26].end())
{
root[len][26][h] = (int)seg.size();
seg.emplace_back(Node());
}
Update(i, 1, root[len][26][h], 0, (int)v.size()-1);
}
}
for(int i=0; i<v.size(); i++)
{
string &s = v[i];
int pl = 0, pr = (int)v.size()-1;
vector<int> PL(s.size()), PR(s.size());
for(int j=0; j<s.size(); j++)
{
// [0, j-1] 구간이 prefix인 범위
PL[j] = pl; PR[j] = pr;
while(pl < i && v[pl][j] != s[j]) pl++;
while(pr > i && v[pr][j] != s[j]) pr--;
}
// suffix length 순서대로
int k = (int)s.size();
for(int j=(int)s.size()-1; j>=0; j--)
{
// [k,j]구간이 정렬되어 있다.
while(k > j || (k > 0 && s[k-1] <= s[k])) k--;
// [PL[k], PR[k]] 구간은 prefix가 같다.
// [j+1,s.size()-1] suffix
int len = (int)s.size()-1-j;
auto &h = w[i][len];
// cout << i << " " << k << " " << j << "\n";
// cout << i << " " << k-1 << " : " << PL[k] << " " << PR[k] << "\n";
// 양쪽 다 sorted이면 더블 카운팅되지 않나? pairwise distinct라서 그런 일은 없다.
int tmp = Query(PL[k], PR[k], root[len][26][h], 0, (int)v.size()-1) - Query(PL[k], PR[k], root[len][s[j]-'a'][h], 0, (int)v.size()-1);
// cout << tmp << "\n\n";
res += tmp;
}
}
// clear
seg.clear();
seg.emplace_back(Node());
for(int j=0; j<=(int)v[0].size(); j++)
for(int k=0; k<27; k++)
root[j][k].clear();
}
// cout << diff/2 << " " << res << " " << tot-res << "\n";
cout << 1337LL*(diff/2) + 1*res + 2*(tot-res) << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
//======================
//
// Template OleschY
//
// Die M�glichkeiten der deutschen Grammatik k�nnen
// einen, wenn man sich darauf, was man ruhig, wenn
// man m�chte, sollte, einl�sst, �berraschen.
// - @Gedankenbalsam
//
//======================
//======================
// Output/Debug
//======================
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (int i = 0; i < v.size(); ++i)
{
os << v[i];
if (i != v.size() - 1)
os << ", ";//123123
}
os << "]\n";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p)
{
os << "[";
os << p.first;
os << ", ";
os << p.second;
os << "]";
return os;
}
#ifndef ONLINE_JUDGE
#define debug(x) cout << (#x) << " is " << (x) << endl
#else
#define debug(...) 42
#endif
//======================
// Solution Single testcase
//======================
pair<int, int> getlr(const string& st1, const string& st2)
{
int ssize = st1.size();
assert(st1.size() == st2.size());
pair<int, int> borders = {-1, ssize};
for(int l = 0; l < ssize; l++)
{
if(st1[l] == st2[l])
{
borders.first = l;
}
else break;
}
for(int r = ssize - 1; r >= 0; r--)
{
if(st1[r] == st2[r])
{
borders.second = r;
}
else break;
}
borders.first++;
borders.second = ssize - borders.second;
return borders;
}
long long nAll;
vector<pair<string, string>> in;
int solve()
{
for(int i = 0; i < nAll ; ++i)
{
in[i].second = in[i].first;
sort(in[i].second.begin(), in[i].second.end());
}
sort(in.begin(), in.end(), [](pair<string, string> const & a, pair<string, string> const & b)
{
return a.second < b.second || (a.second == b.second && a.first < b.first);
});
vector<vector<string>> strGroups;
for(int i = 0; i < nAll; i++) {
if (i == 0 || in[i].second != in[i - 1].second) {
strGroups.push_back(vector<string>());
}
strGroups.rbegin()->push_back(in[i].first);
}
long long ans = 0;
long long ans1337 = 0;
long long ansWidthwisePairs = 0;
cerr << strGroups[0][0].capacity() << ' ' << (size_t(strGroups[0][0].data()) & 127) << '\n';
for(vector<string>& strs : strGroups) {
long long n = strs.size();
long long ssize = strs[0].size();
ans1337 += 1337 * n * (nAll - n);
ans += n * ( n - 1 );
if (n >= 6800) {
// check widthwise
sort(strs.begin(), strs.end());
for(string const& str : strs)
{
for(int i = 0; i < ssize; i++)
{
for(int j = i + 1; j < ssize; j++)
{
string temp = str;
sort(temp.begin() + i, temp.begin() + j + 1);
if(temp[i] != str[i])
{
if(temp[j] != str[j])
{
if(binary_search(strs.begin(), strs.end(), temp))
{
ansWidthwisePairs -= 2;
}
}
}
}
}
}
}
else
{
for(int i = 0; i < n; i++)
{
for(int j = i + 1; j < n; j++)
{
auto [l, r] = getlr(strs[i], strs[j]);
if(r == ssize)
ans -= 2;
else
{
assert(strs[i].begin() + l <= strs[i].end() - r);
if(is_sorted(strs[i].begin() + l, strs[i].end() - r))
ans -= 1;
assert(strs[j].begin() + l <= strs[j].end() - r);
if(is_sorted(strs[j].begin() + l, strs[j].end() - r))
ans -= 1; ///123 1231
}
}
}
}
}
long long sum = ans1337 / 2 + ans + ansWidthwisePairs / 2 ;
cout << sum << "\n"; /// 123
return 0;
}
void input()
{
cin >> nAll;
in.resize(nAll);
for(int i = 0; i < nAll; ++i)
{
cin >> in[i].first;
}
solve();
}
//======================
// Technical stuff
//======================
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
//freopen("a.out", "w", stdout); // console output is better (in most cases)
#else
// add i/o method of specific testing system
#endif
input();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
const int inf = 1e9;
const ll inf64 = 1e18;
bool check(string a, string b) {
int n = (int) a.size();
int l = 0, r = 0;
while (l < n && a[l] == b[l]) l++;
while (r < n && a[n - 1 - r] == b[n - 1 - r]) r++;
if (l + r >= n) return true;
int ql = l, qr = n - r - 1;
int oka = 1, okb = 1;
for (int i = ql; i < qr; i++) {
if (a[i] < a[i + 1]) oka = 0;
if (b[i] < b[i + 1]) okb = 0;
}
return oka || okb;
}
ll solveNNS(vector<string> a) {
int n = (int) a.size();
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
int cost = 2;
if (check(a[i], a[j]))
cost = 1;
res += cost;
}
}
return res;
}
const int A = 26;
struct Trie {
struct Node {
vector<int> nxt = vector<int>(A, -1);
int par = -1;
int tin = 0;
int tout = 0;
};
vector<Node> t = {Node()};
int timer = 0;
int add_string(const string& s) {
int v = 0;
for (char c : s) {
c -= 'a';
if (t[v].nxt[c] == -1) {
t[v].nxt[c] = (int) t.size();
t.emplace_back();
t.back().par = v;
}
v = t[v].nxt[c];
}
return v;
}
int get(const string& s) {
int v = 0;
for (char c : s) {
c -= 'a';
v = t[v].nxt[c];
}
return v;
}
void dfs(int v) {
t[v].tin = timer++;
for (int c = 0; c < A; c++) {
int to = t[v].nxt[c];
if (to == -1)
continue;
dfs(to);
}
t[v].tout = timer++;
}
void build() {
dfs(0);
}
};
struct pt {
int x = 0;
int y = 0;
};
struct Node {
Node* l = nullptr;
Node* r = nullptr;
int s = 0;
Node(int value) {
s = value;
}
Node(Node* l_, Node* r_): l(l_), r(r_) {
s = (l ? l->s : 0) + (r ? r->s : 0);
}
};
Node* add(Node* v, int tl, int tr, int pos) {
if (tl == tr) {
return new Node((v ? v->s : 0) + 1);
} else {
int tm = (tl + tr) >> 1;
if (pos <= tm)
return new Node(add(v ? v->l : nullptr, tl, tm, pos), v ? v->r : nullptr);
else
return new Node(v ? v->l : nullptr, add(v ? v->r : nullptr, tm + 1, tr, pos));
}
}
int get(Node* v, int tl, int tr, int l, int r) {
if (l > r || !v) return 0;
if (l <= tl && tr <= r) {
return v->s;
} else {
int tm = (tl + tr) >> 1, res = 0;
if (l <= tm) res += get(v->l, tl, tm, l, r);
if (r > tm) res += get(v->r, tm + 1, tr, l, r);
return res;
}
}
ll solveNSS(vector<string> a) {
sort(a.begin(), a.end());
for (int i = 0; i + 1 < (int) a.size(); i++)
assert(a[i] != a[i + 1]);
if (a.empty()) return 0;
int n = (int) a.size();
int k = (int) a[0].size();
ll res = 1ll * n * (n - 1);
ll cnt = 0;
Trie pref, suff;
vector<string> b = a;
for (int i = 0; i < n; i++) {
pref.add_string(a[i]);
reverse(b[i].begin(), b[i].end());
suff.add_string(b[i]);
}
pref.build();
suff.build();
vector<pt> ps(n);
for (int i = 0; i < n; i++) {
int u = pref.get(a[i]);
int v = suff.get(b[i]);
ps[i].x = pref.t[u].tin;
ps[i].y = suff.t[v].tin;
if (i > 0) assert(ps[i - 1].x <= ps[i].x);
}
vector<tuple<int, int, int, int, int>> recs;
int mx = 2 * (int) suff.t.size() + 5;
vector<Node*> roots(n);
for (int i = 0; i < n; i++) {
Node* r = i > 0 ? roots[i - 1] : nullptr;
roots[i] = add(r, 0, mx, ps[i].y);
}
for (int i = 0; i < n; i++) {
int pv = 0, sv = suff.get(b[i]);
// cout << i << " : \n";
int last_lx = 0;
int last_rx = 0;
for (int r = -1, l = 0; l + 1 < k; pv = pref.t[pv].nxt[a[i][l] - 'a'], l++) {
while (r < l) {
sv = suff.t[sv].par;
r++;
}
while (r + 1 < k && a[i][r] >= a[i][r + 1]) {
sv = suff.t[sv].par;
r++;
}
{
int npv = pref.t[pv].nxt[a[i][l] - 'a'];
int lx = pref.t[pv].tin;
int rx = pref.t[npv].tin;
assert(last_lx <= lx); last_lx = lx;
assert(last_rx <= rx); last_rx = rx;
int ly = suff.t[sv].tin;
int ry = suff.t[sv].tout;
int from = 0, to;
{
int bl = 0, br = i + 1, bm;
while (br - bl > 1) {
bm = (bl + br) >> 1;
if (ps[bm].x <= lx) bl = bm;
else br = bm;
}
from = bl + 1;
while (from > 0 && ps[from - 1].x > lx) from--;
}
{
int bl = -1, br = i, bm;
while (br - bl > 1) {
bm = (bl + br) >> 1;
if (ps[bm].x >= rx) br = bm;
else bl = bm;
}
to = max(0, br - 1);
while (to < i && ps[to].x < rx) to++;
}
if (from < to)
cnt += get(roots[to - 1], 0, mx, ly + 1, ry - 1) -
get(from > 0 ? roots[from - 1] : nullptr, 0, mx, ly + 1, ry - 1);
// for (int j = from; j < to; j++) {
// if (ly < ps[j].y && ps[j].y < ry)
// cnt++;
// }
}
}
}
// cout << "cnt = " << cnt << "\n";
res -= cnt;
return res;
}
const int SQRT = (int) sqrt(2e5);
ll fast(int n, vector<string> a) {
vector<string> b(n);
for (int i = 0; i < n; i++) {
b[i] = a[i];
sort(b[i].begin(), b[i].end());
}
vector<int> perm(n);
for (int i = 0; i < n; i++)
perm[i] = i;
sort(perm.begin(), perm.end(), [&](int i, int j) {
return b[i] < b[j];
});
ll add = 0, res = 0;
for (int it = 0; it < n; it++) {
int jit = it;
vector<string> group;
while (jit < n && b[perm[it]] == b[perm[jit]]) {
group.push_back(a[perm[jit]]);
jit++;
}
jit--;
add += 1ll * (int) group.size() * (n - (int) group.size());
res += n < SQRT ? solveNNS(group) : solveNSS(group);
// res += solveNSS(group);
it = jit;
}
assert(add % 2 == 0);
res += 1337ll * add / 2;
return res;
}
ll slow(int n, vector<string> a) {
sort(a.begin(), a.end());
ll res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
{
string aa = a[i], bb = a[j];
sort(aa.begin(), aa.end());
sort(bb.begin(), bb.end());
if (aa != bb) {
res += 1337;
continue;
}
}
int l = 0, r = 0;
int sz = (int) a[i].size();
while (l < sz && a[i][l] == a[j][l]) l++;
while (r < sz && a[i][sz - 1 - r] == a[j][sz - 1 - r]) r++;
assert(l + r < sz);
int ql = l, qr = sz - r - 1;
int ok = 1;
for (int q = ql; q < qr; q++) {
if (a[i][q] < a[i][q + 1]) ok = 0;
}
if (ok) res++;
else res += 2;
}
}
return res;
}
void work() {
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
for (char& c : a[i])
c = 25 - (c - 'a') + 'a';
}
ll res = fast(n, a);
cout << res << "\n";
}
string gen_string(mt19937& rnd, int len, const int MAXC) {
string res(len, '?');
for (char& c : res)
c = rnd() % MAXC + 'a';
return res;
}
void test() {
mt19937 rnd(42);
const int MAXN = 10;
const int MAXL = 5;
const int MAXC = 3;
while (1) {
int n = rnd() % MAXN + 1;
int m = rnd() % MAXL + 1;
vector<string> a(n);
for (int i = 0; i < n; i++) {
if (i == 0 || rnd() % 2)
a[i] = gen_string(rnd, m, MAXC);
else {
a[i] = a[rnd() % i];
shuffle(a[i].begin(), a[i].end(), rnd);
}
}
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
n = (int) a.size();
shuffle(a.begin(), a.end(), rnd);
ll fs = fast(n, a);
ll sl = slow(n, a);
if (fs == sl) {
cout << "OK(" << fs << ")" << endl;
} else {
cout << "WA\n";
cout << "exp = " << sl << "\n";
cout << "fnd = " << fs << "\n";
cout << n << "\n";
for (int i = 0; i < n; i++)
cout << a[i] << "\n";
break;
}
}
}
int main() {
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
work();
// test();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;int main(){string s,h;map<string,vector<string>>mp;int t,m,n,k,i,j,l,r,a,b,x=0,y=0;cin>>n;t=n*(n-1LL)/2;while(n--)cin>>s,k=s.length(),h=s,sort(h.begin(),h.end()),mp[h].push_back(s);for(auto p:mp){auto v=p.second;m=v.size(),sort(v.begin(),v.end());for(i=0;i<m;i++)for(j=i+1;j<m;j++){l=a=b=0,r=k-1;while(v[i][l]==v[j][l])l++;while(v[i][r]==v[j][r])r--;for(;l<r&&!(a&b);l++)a|=(v[i][l+1]<v[i][l]),b|=(v[j][l+1]<v[j][l]);x+=!(a&b),y+=(a&b);}}cout<<1337LL*(t-x-y)+x+2*y;}
|
#include <bits/stdc++.h>
#define fst first
#define snd second
#define fore(i,a,b) for(int i=a,ThxDem=b;i<ThxDem;++i)
#define pb push_back
#define ALL(s) s.begin(),s.end()
#define FIN ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define SZ(s) int(s.size())
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
#define bint __int128
struct Hash {
bint MOD=212345678987654321LL,P=1777771,PI=106955741089659571LL;
vector<bint> h,pi;
Hash(){}
Hash(string& s){
assert((P*PI)%MOD==1);
h.resize(s.size()+1);pi.resize(s.size()+1);
h[0]=0;pi[0]=1;
bint p=1;
fore(i,1,s.size()+1){
h[i]=(h[i-1]+p*s[i-1])%MOD;
pi[i]=(pi[i-1]*PI)%MOD;
p=(p*P)%MOD;
}
}
ll get(int s, int e){
return (((h[e]-h[s]+MOD)%MOD)*pi[s])%MOD;
}
};
ll getsorted(string s){
sort(ALL(s));
return Hash(s).get(0,SZ(s));
}
int sorted(string &s, vector<int> &d, int now){
while(d[now]<SZ(s) && s[now]<s[d[now]]) now=d[now];
return d[now]-1;
}
bool can(string &s, string &t, vector<int> &ds, vector<int> &dt, Hash &hs, Hash &ht){
int l=0,r=SZ(s)-1;
while(l<=r){
int m=(l+r)/2;
if(hs.get(0,m+1)==ht.get(0,m+1)) l=m+1;
else r=m-1;
}
int st=l;
l=0; r=SZ(s)-1;
while(l<=r){
int m=(l+r)/2;
if(hs.get(m,SZ(s)) == ht.get(m,SZ(s))) r=m-1;
else l=m+1;
}
int en=r;
return sorted(s,ds,st)>=en || sorted(t,dt,st)>=en;
}
const int MAXN=2e5+10;
vector<int> df[MAXN];
Hash hs[MAXN];
ll brute(vector<string> &v){
int n=SZ(v);
ll ans=0;
fore(i,0,n) fore(j,i+1,n) ans+=1+(!can(v[i],v[j],df[i],df[j],hs[i],hs[j]));
return ans;
}
vector<ll> mp[510];
vector<pair<ll,int>> mp2[510];
int get(vector<ll> &v, ll x){
return upper_bound(ALL(v),x)-lower_bound(ALL(v),x);
}
int get(vector<pair<ll,int>> &v, pair<ll,int> x){
return upper_bound(ALL(v),x)-lower_bound(ALL(v),x);
}
//prefijo de k, difiere en k+1
ll get(vector<string> &v, int k){
int pos=0,n=SZ(v),me=SZ(v[0]);
ll ans=0;
while(pos<n){
int id=pos;
while(id<n&&hs[pos].get(0,k)==hs[id].get(0,k)) id++;
//ver el rango [pos,id)
fore(i,pos,id){
fore(j,k,me+1){
mp[j].pb(hs[i].get(j,me));
mp2[j].pb({hs[i].get(j,me),v[i][k]});
}
}
fore(j,k,me+1){
sort(ALL(mp[j]));
sort(ALL(mp2[j]));
}
fore(i,pos,id){
int to=sorted(v[i],df[i],k)+1;
ll h=hs[i].get(to,me);
ans+=get(mp[to],h);
ans-=get(mp2[to],{h,v[i][k]});
}
fore(j,k,me+1){
mp[j].clear();
mp2[j].clear();
}
pos=id;
}
//cout<<"for "<<k<<": "<<ans<<endl;
return ans;
}
ll linear(vector<string> &v){
int n=SZ(v),k=SZ(v[0]);
ll ans=0;
fore(i,0,k) ans+=get(v,i);
ans=n*(n-1)-ans;
return ans;
}
void compute(vector<string> &v){
int n=SZ(v);
fore(i,0,n){
hs[i]=Hash(v[i]);
int k=SZ(v[i]);
df[i].resize(k);
int id=k;
for(int j=k-1;j>=0;j--){
if(j==k-1||v[i][j]!=v[i][j+1]) id=j+1;
df[i][j]=id;
}
}
}
int main(){FIN;
int n; cin>>n;
vector<string> v(n);
vector<pair<ll,int>> gr;
fore(i,0,n) cin>>v[i];
sort(ALL(v));
fore(i,0,n) gr.pb({getsorted(v[i]),i});
sort(ALL(gr));
ll bad=0,ans=0;
int pos=0;
while(pos<n){
vector<string> now;
int id=pos;
while(id<n&&gr[pos].fst==gr[id].fst){
now.pb(v[gr[id].snd]);
id++;
}
bad+=1ll*SZ(now)*(n-SZ(now));
compute(now);
if(n<=1000) ans+=brute(now);
else ans+=linear(now);
pos=id;
}
bad/=2;
ans+=bad*1337;
cout<<ans<<"\n";
}
|
// Author: wlzhouzhuan
#pragma GCC optimize(2, 3, "Ofast")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fir first
#define sec second
#define rep(i, l, r) for (int i = l; i <= r; i++)
#define per(i, l, r) for (int i = l; i >= r; i--)
#define mset(s, t) memset(s, t, sizeof(s))
#define mcpy(s, t) memcpy(s, t, sizeof(t))
#define poly vector<int>
#define SZ(x) (int(x.size()))
template<typename T1, typename T2> void ckmin(T1 &a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> void ckmax(T1 &a, T2 b) { if (a < b) a = b; }
int read() {
int x = 0, f = 0; char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = 10 * x + ch - '0', ch = getchar();
return f ? -x : x;
}
template<typename T> void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template<typename T> void print(T x, char let) {
print(x), putchar(let);
}
const int N = 500005;
const int mod = 998244353;
int lg[N];
int base1 = 117, base2 = 137;
struct node {
pii hsh;
int id;
} a[N];
ll ans;
string s[N], t[N];
int n;
pii getHash(string s) {
static int cnt[26]; mset(cnt, 0);
int res1 = 0, res2 = 0;
for (auto v: s) cnt[v - 'a']++;
for (int i = 0; i < 26; i++) {
res1 = (1ll * res1 * base1 + cnt[i] + 1) % mod;
res2 = (1ll * res2 * base2 + cnt[i] + 1) % mod;
}
return make_pair(res1, res2);
}
struct SA {
int cnt[N], x[N], y[N], sa[N], rk[N];
char _a[N];
int _n;
void mysort(int m) {
m = max(m, 255);
for (int i = 1; i <= m; i++) cnt[i] = 0;
for (int i = 1; i <= _n; i++) cnt[x[i]]++;
for (int i = 1; i <= m; i++) cnt[i] += cnt[i - 1];
for (int i = _n; i >= 1; i--) sa[cnt[x[y[i]]]--] = y[i];
}
void build(char a[], int n) {
_n = n;
for (int i = 1; i <= _n; i++) _a[i] = a[i];
for (int i = 1; i <= _n; i++) x[i] = a[i], y[i] = i;
mysort(n);
for (int k = 1; k <= n; k <<= 1) {
int cur = 0, p;
for (int i = n - k + 1; i <= _n; i++) y[++cur] = i;
for (int i = 1; i <= _n; i++) if (sa[i] > k) y[++cur] = sa[i] - k;
mysort(n);
for (int i = 1; i <= _n; i++) swap(x[i], y[i]);
x[sa[1]] = 1, p = 1;
for (int i = 2; i <= _n; i++) {
x[sa[i]] = (y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k] ? p : ++p);
}
if (p == _n) break;
}
memcpy(rk, x, 4 * (_n + 1));
}
int height[N], LCP[N][18];
void getHeight(int n) {
for (int i = 1, k = 0; i <= n; i++) {
if (rk[i] == 1) continue;
if (k) --k;
int j = sa[rk[i] - 1];
while (i + k <= n && j + k <= n && _a[i + k] == _a[j + k]) k++;
height[rk[i]] = k;
}
for (int i = 1; i <= n; i++) LCP[i][0] = height[i];
for (int j = 1; j <= lg[n]; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
LCP[i][j] = min(LCP[i][j - 1], LCP[i + (1 << j - 1)][j - 1]);
}
}
}
int lcp(int x, int y) {
if (x == y) return _n - x + 1;
x = rk[x], y = rk[y];
if (x > y) swap(x, y);
x++;
int len = lg[y - x];
return min(LCP[x][len], LCP[y - (1 << len) + 1][len]);
}
// addition
pii range(int x, int k) {
x = rk[x];
int l = x, r = x;
for (int i = lg[l - 1]; i >= 0; i--) {
if (l - (1 << i) >= 1 && LCP[l - (1 << i) + 1][i] >= k) l -= 1 << i;
}
for (int i = lg[_n - r]; i >= 0; i--) {
if (r + (1 << i) <= _n && LCP[r + 1][i] >= k) r += 1 << i;
}
return make_pair(l, r);
}
} pre, suf;
struct Count {
int n;
struct Fenwick {
int c[N], _n;
void clear(int n) {
_n = n;
memset(c, 0, 4 * (n + 1));
}
void add(int x, int dlt) {
// printf("add %d %d\n", x, dlt);
while (x <= _n) c[x] += dlt, x += x & -x;
// printf("!\n");
}
int qry(int x) {
int ret = 0;
// printf("qry %d\n", x);
while (x > 0) ret += c[x], x ^= x & -x;
// printf("!\n");
return ret;
}
int qry(int l, int r) {
if (l > r) return 0;
else return qry(r) - qry(l - 1);
}
} bit;
vector<int> dot[N];
struct Item { int l, r, opt; };
vector<Item> qry[N];
void clear(int _n) {
n = _n;
bit.clear(n);
for (int i = 0; i <= n; i++) dot[i].clear(), qry[i].clear();
}
void pushdot(int x, int y) {
// printf("pushdot %d %d\n", x, y);
dot[x].pb(y);
}
void pushqry(int xl, int xr, int yl, int yr) {
// printf("pushqry %d %d %d %d\n", xl, xr, yl, yr);
qry[xl - 1].pb({yl, yr, -1});
qry[xr].pb({yl, yr, 1});
}
ll getans() {
ll res = 0;
for (int i = 1; i <= n; i++) {
for (auto v: dot[i]) bit.add(v, 1);
for (auto v: qry[i]) res += v.opt * bit.qry(v.l, v.r);
}
return res;
}
} counter;
char prea[N], sufa[N];
int bga[N], bgb[N];
void solve(string a[], int n) {
int tot = 0;
for (int i = 1; i <= n; i++) {
bga[i] = tot + 1;
for (int j = 0; j < SZ(a[i]); j++) prea[++tot] = a[i][j];
}
prea[tot + 1] = 0;
tot = 0;
for (int i = 1; i <= n; i++) {
bgb[i] = tot + 1;
for (int j = SZ(a[i]) - 1; j >= 0; j--) sufa[++tot] = a[i][j];
}
sufa[tot + 1] = 0;
pre.build(prea, tot), pre.getHeight(tot);
suf.build(sufa, tot), suf.getHeight(tot);
// cerr << "!\n";
// printf("tot = %d\n", tot);
// for (int i = 1; i <= tot; i++) printf("%c", prea[i]); puts("");
// for (int i = 1; i <= tot; i++) printf("rk[%d] = %d\n", i, pre.rk[i]);
counter.clear(tot);
for (int i = 1; i <= n; i++) counter.pushdot(pre.rk[bga[i]], suf.rk[bgb[i]]);
// cerr << "!!!\n";
ll res = 0;
for (int i = 1; i <= n; i++) {
for (int l = 0, r = 0; l < SZ(a[i]); l = r) {
r = l + 1;
while (r < SZ(a[i]) && a[i][r - 1] <= a[i][r]) r++;
// printf("l = %d, r = %d\n", l, r);
res--;
pii rngL = pre.range(bga[i], l);
pii rngR = suf.range(bgb[i], SZ(a[i]) - r);
// printf("??? %d %d %d %d\n", rngL.fir, rngL.sec, rngR.fir, rngR.sec);
counter.pushqry(rngL.fir, rngL.sec, rngR.fir, rngR.sec);
}
}
// cerr << "!\n";
res += counter.getans();
// cerr << "?\n";
// printf("res = %lld\n", res);
ans += res + 2ll * (1ll * n * (n - 1) / 2 - res);
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
lg[1] = 0;
for (int i = 2; i < N; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n; i++) {
cin >> s[i];
a[i] = {getHash(s[i]), i};
}
sort(a + 1, a + n + 1, [&](node x, node y) {
return x.hsh < y.hsh;
});
for (int i = 1; i <= n; i++) t[i] = s[a[i].id];
for (int i = 1, j = 1; i <= n; i = j) {
while (a[i].hsh == a[j].hsh) j++;
// cerr << "i = " << i << ", j = " << j << '\n';
ans += 1337ll * (j - i) * (i - 1);
solve(t + i - 1, j - i);
}
cout << ans << '\n';
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pl;
typedef double db;
#define ls(x) ((x)<<1)
#define rs(x) ((x)<<1|1)
#define low(x) ((x)&-(x))
#define all(x) x.begin(),x.end()
#define mp make_pair
#define X first
#define Y second
#ifdef _DEBUG
const int N=1e3+10;
#else
const int N=1e6+10;
#endif
const ll mod=1e9+7;
//const ll mod=998244353;
inline ll gcd(ll a,ll b){return !b?a:gcd(b,a%b);}
inline ll q_pow(ll a,ll x){ll ans=1,tmp=a;while(x){if(x&1)(ans*=tmp)%=mod;(tmp*=tmp)%=mod;x>>=1;}return ans;}
template<typename T> inline void re(T &N){int f=1;char c;while((c=getchar())< '0'||c> '9')if(c=='-')f=-1;N=c-'0';while((c=getchar())>='0'&&c<='9')N=N*10+c-'0';N*=f;}
int m,n,t=1,st,en;
string s[N];
namespace s1{
int c1[30],c2[30];
ll solve()
{
ll ans=0;
for(int i=1;i<=n;i++)
for(int j=i+1;j<=n;j++)
{
memset(c1,0,sizeof(c1));
memset(c2,0,sizeof(c2));
for(int k=0;k< m;k++)
{
c1[s[i][k]-'a']++;
c2[s[j][k]-'a']++;
}
int res=2;
for(int k=0;k< 26;k++)
if(c1[k]!=c2[k]){res=1337;break;}
if(res==1337){ans+=1337;continue;}
int pre=-1,suf=m;
for(int k=0;k< m;k++)
{
if(s[i][k]==s[j][k])pre=k;
else break;
}
for(int k=m-1;k>=0;k--)
{
if(s[i][k]==s[j][k])suf=k;
else break;
}
int ok=3;
for(int k=pre+1;k< suf-1&&ok;k++)
{
if(s[i][k]> s[i][k+1])ok&=2;
if(s[j][k]> s[j][k+1])ok&=1;
}
ans+=res-(ok> 0);
}
return ans;
}
}
namespace s2{
int c1[30],c2[30];
inline int cmp(const string &a,const string &b)
{
memset(c1,0,sizeof(c1));
memset(c2,0,sizeof(c2));
for(int i=0;i< m;i++)
{
c1[a[i]-'a']++;
c2[b[i]-'a']++;
}
for(int i=0;i< 26;i++)
if(c1[i]!=c2[i])return c1[i]< c2[i];
return a< b;
}
inline int check(const string &a,const string &b)
{
memset(c1,0,sizeof(c1));
memset(c2,0,sizeof(c2));
for(int i=0;i< m;i++)
{
c1[a[i]-'a']++;
c2[b[i]-'a']++;
}
for(int i=0;i< 26;i++)
if(c1[i]!=c2[i])return 0;
return 1;
}
ll solve()
{
ll ans=0;
sort(s+1,s+n+1,cmp);
for(int l=1,r=1;l<=n;l=r=r+1)
{
while(r< n&&check(s[l],s[r+1]))r++;
ans+=1337ll*(r-l+1)*(n-r);
int sum=0;
for(int i=0;i< m;i++)
for(int j=i+1;j< m;j++)
for(int k=l;k<=r;k++)
{
string tmp=s[k];
sort(tmp.begin()+i,tmp.begin()+j+1);
if(tmp[i]!=s[k][i]&&tmp[j]!=s[k][j]&&binary_search(s+l,s+r+1,tmp))sum++;
}
ans+=1ll*(r-l+1)*(r-l)-sum;
}
return ans;
}
}
int main()
{
#ifdef _DEBUG
freopen("data.txt","r",stdin);
#endif
ios::sync_with_stdio(0);
cin>>n;
for(int i=1;i<=n;i++)cin>>s[i];
m=s[1].length();
if(n<=5000)cout<<s1::solve()<<'\n';
else cout<<s2::solve()<<'\n';
}
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
int n; cin >> n;
vector<string> a(n);
map<int, set<string>> srt;
int gop = 53, mod = 2654435761;
for(int i = 0; i < n; ++i){
cin >> a[i];
vector<int> cnt(26);
for(auto&j:a[i]){
++cnt[j - 'a'];
}
int val = 7;
for(int j = 0; j < (int)cnt.size(); ++j){
val += cnt[j]; val %= mod;
val *= gop; val %= mod;
}
srt[val].insert(a[i]);
}
a.clear();
for(auto&i:srt){
for(auto&j:i.second){
a.push_back(j);
}
}
int ans = 0;
vector<int> gr;
for(int rep = 0; rep < 2; ++rep){
reverse(a.begin(), a.end());
vector<vector<int>> ha(n, vector<int>((int)a[0].size() + 1));
for(int i = 0; i < n; ++i){
int val = 7;
for(int j = (int)a[0].size() - 1; j >= 0; --j){
val += (a[i][j] - '0'); val %= mod;
val *= gop; val %= mod;
ha[i][j] = val;
}
}
vector<vector<int>> haf(n, vector<int>((int)a[0].size() + 1));
for(int i = 0; i < n; ++i){
int val = 7;
for(int j = 0; j < (int)a[0].size(); ++j){
val += (a[i][j] - '0'); val %= mod;
val *= gop; val %= mod;
haf[i][j] = val;
}
}
vector<map<int, int>> mp((int)a[0].size() + 1);
int last = -1;
vector<vector<pair<int, int>>> minu(n), plu(n);
for(int i = 0; i < n;){
vector<int> cnt(26);
for(auto&j:a[i]){
++cnt[j - 'a'];
}
int j = i + 1;
while(j < n){
vector<int> cnt2(26);
for(auto&k:a[j]){
++cnt2[k - 'a'];
}
if(cnt != cnt2){
break;
}
++j;
}
for(int k = i; k < j; ++k){
int y = (int)a[k].size() - 1;
for(int x = (int)a[k].size() - 1; x >= 0; --x){
if(x < (int)a[k].size() - 1 && a[k][x] > a[k][x + 1]){
y = x;
}
int l = last + 1, r = k, mid;
while(l < r){
mid = (l + r) >> 1;
if(!x || haf[mid][x - 1] == haf[k][x - 1]){
r = mid;
}
else{
l = mid + 1;
}
}
if(haf[l][x] != haf[k][x]){
if(l > last + 1) minu[l - 1].push_back({y + 1, ha[k][y + 1]});
for(int bit = 20; bit >= 0; --bit){
if(l + (1 << bit) <= k && haf[l + (1 << bit)][x] != haf[k][x]){
l += (1 << bit);
}
}
plu[l].push_back({y + 1, ha[k][y + 1]});
}
}
for(int x = 0; x <= (int)a[k].size(); ++x){
++mp[x][ha[k][x]];
}
}
if(rep) gr.push_back(j - i);
i = j; last = j - 1;
for(int r = 0; r <= (int)a[0].size(); ++r) mp[r].clear();
}
for(int i = 0; i < n; ){
vector<int> cnt(26);
for(auto&j:a[i]){
++cnt[j - 'a'];
}
int j = i + 1;
while(j < n){
vector<int> cnt2(26);
for(auto&k:a[j]){
++cnt2[k - 'a'];
}
if(cnt != cnt2){
break;
}
++j;
}
for(int k = i; k < j; ++k){
for(int x = 0; x <= (int)a[k].size(); ++x){
++mp[x][ha[k][x]];
}
for(auto&r:minu[k]){
ans -= mp[r.first][r.second];
}
for(auto&r:plu[k]){
ans += mp[r.first][r.second];
}
}
i = j;
for(int r = 0; r <= (int)a[0].size(); ++r) mp[r].clear();
}
}
int ans3 = 0;
for(auto&i:gr){
ans3 += i * (i - 1) / 2;
}
ans += (ans3 - ans) * 2;
int ans2 = 0;
for(auto&i:gr){
ans2 += 1337 * i * (n - i);
}
ans += ans2 / 2;
cout << ans << '\n';
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
//======================
//
// Template OleschY
//
// Die M�glichkeiten der deutschen Grammatik k�nnen
// einen, wenn man sich darauf, was man ruhig, wenn
// man m�chte, sollte, einl�sst, �berraschen.
// - @Gedankenbalsam
//
//======================
//======================
// Output/Debug
//======================
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (int i = 0; i < v.size(); ++i)
{
os << v[i];
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p)
{
os << "[";
os << p.first;
os << ", ";
os << p.second;
os << "]";
return os;
}
#ifndef ONLINE_JUDGE
#define debug(x) cout << (#x) << " is " << (x) << endl
#else
#define debug(...) 42
#endif
//======================
// Solution Single testcase
//======================
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
pair<int, int> getlr(const string& st1, const string& st2)
{
int ssize = st1.size();
pair<int, int> borders = {-1, ssize};
for(int l = 0; l < ssize; l++)
{
if(st1[l] == st2[l])
{
borders.first = l;
}
else break;
}
for(int r = ssize - 1; r >= 0; r--)
{
if(st1[r] == st2[r])
{
borders.second = r;
}
else break;
}
borders.first++;
borders.second = ssize - borders.second;
return borders;
}
long long nAll;
vector<pair<string, string>> in(nAll);
int solve()
{
for(int i = 0; i < nAll ; ++i)
{
in[i].second = in[i].first;
sort(in[i].second.begin(), in[i].second.end());
}
sort(in.begin(), in.end(), [](pair<string, string> const & a, pair<string, string> const & b)
{
return a.second < b.second;
});
vector<vector<string>> strGroups;
for(int i = 0; i < nAll; i++)
{
if(i == 0 || in[i].second != in[i - 1].second)
{
strGroups.push_back(vector<string>(0));
}
strGroups.rbegin()->push_back(in[i].first);
}
long long ans = 0;
long long ans1337 = 0;
long long ansWidthwisePairs = 0;
for(vector<string>& strs : strGroups)
{
long long n = strs.size();
long long ssize = strs[0].size();
ans1337 += 1337 * n * (nAll - n);
ans += n * ( n - 1 );
if(n >= 6800)
{
// check widthwise
sort(strs.begin(), strs.end());
for(string const& str : strs)
{
for(int i = 0; i < ssize; i++)
{
for(int j = i + 1; j < ssize; j++)
{
string temp = str;
sort(temp.begin() + i, temp.begin() + j + 1);
if(temp[i] != str[i])
{
if(temp[j] != str[j])
{
if(binary_search(strs.begin(), strs.end(), temp))
{
ansWidthwisePairs -= 2;
}
}
}
}
}
}
}
else
{
// check pairwise
for(int i = 0; i < n; i++)
{
for(int j = i + 1; j < n; j++)
{
auto [l, r] = getlr(strs[i], strs[j]);
if(r == ssize)
ans -= 2;
else
{
if(is_sorted(strs[i].begin() + l, strs[i].end() - r))
ans -= 1;
if(is_sorted(strs[j].begin() + l, strs[j].end() - r))
ans -= 1;
}
}
}
}
}
long long sum = ans1337 / 2 + ans + ansWidthwisePairs / 2 ;
cout << sum << "\n";
return 0;
}
void input()
{
cin >> nAll;
in.resize(nAll);
for(int i = 0; i < nAll; ++i)
{
cin >> in[i].first;
}
solve();
}
//======================
// Technical stuff
//======================
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
//freopen("a.out", "w", stdout); // console output is better (in most cases)
#else
// add i/o method of specific testing system
#endif
input();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fr(i,n) for(int i = 0; i<n; i++)
#define sz(v) (int)(v.size())
#define prin(a) cout << #a << " = " << a << endl
#define prinv(v) cout << #v << " = "; for(auto it : v) cout << it << ", "; cout << endl
#define all(v) (v).begin(),(v).end()
typedef long long ll;
#define rmin(a,b) a = min<ll>(a,b)
#define rmax(a,b) a = max<ll>(a,b)
#define fi first
#define se second
const int N = 2e5+10;
typedef unsigned long long ull;
ull fp2(ull base, ull exp){
if(exp==0) return 1;
ull mid = fp2(base,exp/2);
if(exp%2) return mid*mid*base;
return mid*mid;
}
mt19937 rng(time(0));
vector<int> perm;
ull p27[N];
ull inv27[N];
void init_hash(int n){
fr(i,26) perm.push_back(i+1);
shuffle(all(perm),rng);
p27[0] = inv27[0] = 1;
for(int i = 1; i<n; i++){
p27[i] = 27*p27[i-1];
inv27[i] = fp2(p27[i],((ull)0)-1);
}
}
/*
Calcula hash de intervalos da string
primeira letra é digito menos significativo
string de lowercase english letters
Base 27 é usado, cada letra é mapeada para [1,26], nao tem 0
Modulo é (1<<64) - unsigned long long
*/
struct meuhash{
vector<ull> pref;
meuhash(){}
meuhash(string &s){
assert(sz(s)<N);
assert(p27[1]*inv27[1]==1);
pref.resize(sz(s));
ull cur = 0;
fr(i,sz(s)){
cur = cur + p27[i]*perm[s[i]-'a'];
pref[i] = cur;
}
}
//intervalo fechado [l,r]
ull gethash(int l, int r){
assert(l<=r and l>=0 and l<sz(pref) and r>=0 and r<sz(pref));
l--;
ull ans = pref[r];
if(l>=0){
ans -= pref[l];
ans *= inv27[l+1];
}
return ans;
}
};
vector<ull> mat[610][610];
int fcnt(ull cur, int l, int r){
return upper_bound(all(mat[l][r]),cur)-lower_bound(all(mat[l][r]),cur);
}
int main(){
ios::sync_with_stdio(0); cin.tie(0);
init_hash(N);
ll n; cin >> n;
map<string,vector<string>> mp;
fr(i,n){
string s; cin >> s;
string aux = s;
sort(all(aux));
mp[aux].push_back(s);
}
ll ans = n*(n-1)/2*1337;
for(auto &[s_sort,v] : mp){
ans -= (ll)sz(v)*(sz(v)-1)/2*1335;
int tam = sz(v[0]);
if(sz(v)<=600){
fr(i,sz(v)) fr(j,i){
if(i==j) continue;
int l = 0, r = tam-1;
while(l<tam and v[i][l]==v[j][l]) l++;
while(r>=0 and v[i][r]==v[j][r]) r--;
int ok = 0;
for(int k = l+1; k<=r; k++){
if(v[i][k]<v[i][k-1]) break;
if(k==r) ok = 1;
}
if(!ok) for(int k = l+1; k<=r; k++){
if(v[j][k]<v[j][k-1]) break;
if(k==r) ok = 1;
}
if(ok) ans--;
}
} else{
vector<meuhash> hashes(sz(v));
fr(i,sz(v)) hashes[i] = meuhash(v[i]);
fr(r,tam) fr(l,r+1) mat[l][r].clear();
fr(i,sz(v)){
fr(r,tam) fr(l,r+1){
ull cur = 0;
if(l) cur = hashes[i].gethash(0,l-1);
if(r<tam-1) cur += p27[l]*hashes[i].gethash(r+1,tam-1);
mat[l][r].push_back(cur);
}
}
fr(r,tam) fr(l,r+1) sort(all(mat[l][r]));
fr(i,sz(v)){
int l = 0;
while(l<tam){
int r = l;
while(r+1<tam and v[i][r+1]>=v[i][r]) r++;
ull cur = 0;
if(l) cur = hashes[i].gethash(0,l-1);
if(r<tam-1) cur += p27[l]*hashes[i].gethash(r+1,tam-1);
ans-=fcnt(cur,l,r)-1;
l = r+1;
}
}
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct binary_indexed_tree{
int N;
vector<T> BIT;
binary_indexed_tree(int N): N(N), BIT(N + 1, 0){
}
void add(int i, T x){
i++;
while (i <= N){
BIT[i] += x;
i += i & -i;
}
}
T sum(int i){
T ans = 0;
while (i > 0){
ans += BIT[i];
i -= i & -i;
}
return ans;
}
T sum(int L, int R){
return sum(R) - sum(L);
}
};
int main(){
int n;
cin >> n;
vector<string> s(n);
for (int i = 0; i < n; i++){
cin >> s[i];
}
int m = s[0].size();
map<array<int, 26>, vector<int>> mp;
for (int i = 0; i < n; i++){
array<int, 26> cnt;
for (int j = 0; j < 26; j++){
cnt[j] = 0;
}
for (int j = 0; j < m; j++){
cnt[s[i][j] - 'a']++;
}
mp[cnt].push_back(i);
}
long long ans = 0;
int cnt = 0;
for (auto P : mp){
int n2 = P.second.size();
vector<string> s2(n2);
for (int i = 0; i < n2; i++){
s2[i] = s[P.second[i]];
}
ans += (long long) cnt * n2 * 1337;
ans += (long long) n2 * (n2 - 1);
sort(s2.begin(), s2.end());
vector<pair<string, int>> P2(n2);
for (int i = 0; i < n2; i++){
P2[i] = make_pair(s2[i], i);
reverse(P2[i].first.begin(), P2[i].first.end());
}
sort(P2.begin(), P2.end());
vector<string> s3(n2);
for (int i = 0; i < n2; i++){
s3[i] = P2[i].first;
}
vector<int> spos(n2);
for (int i = 0; i < n2; i++){
spos[P2[i].second] = i;
}
vector<vector<int>> prel(m + 1, vector<int>(n2, -1));
vector<vector<int>> prer(m + 1, vector<int>(n2, -1));
for (int i = 0; i < n2; i++){
prel[0][i] = 0;
prer[0][i] = n2;
}
for (int i = 1; i <= m; i++){
for (int j = 0; j < n2; j++){
if (prel[i][j] == -1){
int t = j;
while (true){
t++;
if (t == prer[i - 1][j]){
break;
}
if (s2[j][i - 1] != s2[t][i - 1]){
break;
}
}
for (int k = j; k < t; k++){
prel[i][k] = j;
prer[i][k] = t;
}
}
}
}
vector<vector<int>> sufl(m + 1, vector<int>(n2, -1));
vector<vector<int>> sufr(m + 1, vector<int>(n2, -1));
for (int i = 0; i < n2; i++){
sufl[0][i] = 0;
sufr[0][i] = n2;
}
for (int i = 1; i <= m; i++){
for (int j = 0; j < n2; j++){
if (sufl[i][j] == -1){
int t = j;
while (true){
t++;
if (t == sufr[i - 1][j]){
break;
}
if (s3[j][i - 1] != s3[t][i - 1]){
break;
}
}
for (int k = j; k < t; k++){
sufl[i][k] = j;
sufr[i][k] = t;
}
}
}
}
vector<vector<pair<int, int>>> query_add(n2 + 1);
vector<vector<pair<int, int>>> query_sub(n2 + 1);
for (int i = 0; i < n2; i++){
vector<int> w;
w.push_back(0);
for (int j = 0; j < m - 1; j++){
if (s2[i][j] > s2[i][j + 1]){
w.push_back(j + 1);
}
}
w.push_back(m);
int k = w.size();
for (int j = 0; j < k - 1; j++){
int L = w[j];
int R = m - w[j + 1];
query_sub[sufl[R][spos[i]]].push_back(make_pair(prel[L][i], prer[L][i]));
query_add[sufr[R][spos[i]]].push_back(make_pair(prel[L][i], prer[L][i]));
ans++;
}
}
binary_indexed_tree<int> BIT(n2);
for (int i = 0; i <= n2; i++){
int cnt1 = query_add[i].size();
for (int j = 0; j < cnt1; j++){
int l = query_add[i][j].first;
int r = query_add[i][j].second;
ans -= BIT.sum(l, r);
}
int cnt2 = query_sub[i].size();
for (int j = 0; j < cnt2; j++){
int l = query_sub[i][j].first;
int r = query_sub[i][j].second;
ans += BIT.sum(l, r);
}
if (i < n2){
BIT.add(P2[i].second, 1);
}
}
cnt += n2;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
const int inf = 1e9;
const ll inf64 = 1e18;
bool check(string a, string b) {
int n = (int) a.size();
int l = 0, r = 0;
while (l < n && a[l] == b[l]) l++;
while (r < n && a[n - 1 - r] == b[n - 1 - r]) r++;
if (l + r >= n) return true;
int ql = l, qr = n - r - 1;
int oka = 1, okb = 1;
for (int i = ql; i < qr; i++) {
if (a[i] < a[i + 1]) oka = 0;
if (b[i] < b[i + 1]) okb = 0;
}
return oka || okb;
}
ll solveNNS(vector<string> a) {
int n = (int) a.size();
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
int cost = 2;
if (check(a[i], a[j]))
cost = 1;
res += cost;
}
}
return res;
}
const int A = 26;
struct Trie {
struct Node {
vector<int> nxt = vector<int>(A, -1);
int par = -1;
int tin = 0;
int tout = 0;
};
vector<Node> t = {Node()};
int timer = 0;
int add_string(const string& s) {
int v = 0;
for (char c : s) {
c -= 'a';
if (t[v].nxt[c] == -1) {
t[v].nxt[c] = (int) t.size();
t.emplace_back();
t.back().par = v;
}
v = t[v].nxt[c];
}
return v;
}
int get(const string& s) {
int v = 0;
for (char c : s) {
c -= 'a';
v = t[v].nxt[c];
}
return v;
}
void dfs(int v) {
t[v].tin = timer++;
for (int c = 0; c < A; c++) {
int to = t[v].nxt[c];
if (to == -1)
continue;
dfs(to);
}
t[v].tout = timer++;
}
void build() {
dfs(0);
}
};
struct pt {
int x = 0;
int y = 0;
};
ll solveNSS(vector<string> a) {
sort(a.begin(), a.end());
for (int i = 0; i + 1 < (int) a.size(); i++)
assert(a[i] != a[i + 1]);
if (a.empty()) return 0;
int n = (int) a.size();
int k = (int) a[0].size();
ll res = 1ll * n * (n - 1);
ll cnt = 0;
Trie pref, suff;
vector<string> b = a;
for (int i = 0; i < n; i++) {
pref.add_string(a[i]);
reverse(b[i].begin(), b[i].end());
suff.add_string(b[i]);
}
pref.build();
suff.build();
vector<pt> ps(n);
for (int i = 0; i < n; i++) {
int u = pref.get(a[i]);
int v = suff.get(b[i]);
ps[i].x = pref.t[u].tin;
ps[i].y = suff.t[v].tin;
if (i > 0) assert(ps[i - 1].x <= ps[i].x);
}
vector<tuple<int, int, int, int, int>> recs;
for (int i = 0; i < n; i++) {
int pv = 0, sv = suff.get(b[i]);
// cout << i << " : \n";
int last_lx = 0;
int last_rx = 0;
for (int from = 0, r = -1, l = 0; l + 1 < k; pv = pref.t[pv].nxt[a[i][l] - 'a'], l++) {
while (r < l) {
sv = suff.t[sv].par;
r++;
}
while (r + 1 < k && a[i][r] >= a[i][r + 1]) {
sv = suff.t[sv].par;
r++;
}
{
int npv = pref.t[pv].nxt[a[i][l] - 'a'];
int lx = pref.t[pv].tin;
int rx = pref.t[npv].tin;
assert(last_lx <= lx); last_lx = lx;
assert(last_rx <= rx); last_rx = rx;
int ly = suff.t[sv].tin;
int ry = suff.t[sv].tout;
while (from < i && ps[from].x <= lx) from++;
for (int j = from; j < i; j++) {
if (lx < ps[j].x && ps[j].x < rx && ly < ps[j].y && ps[j].y < ry)
cnt++;
}
}
}
}
// cout << "cnt = " << cnt << "\n";
res -= cnt;
return res;
}
const int SQRT = (int) sqrt(2e5);
ll fast(int n, vector<string> a) {
vector<string> b(n);
for (int i = 0; i < n; i++) {
b[i] = a[i];
sort(b[i].begin(), b[i].end());
}
vector<int> perm(n);
for (int i = 0; i < n; i++)
perm[i] = i;
sort(perm.begin(), perm.end(), [&](int i, int j) {
return b[i] < b[j];
});
ll add = 0, res = 0;
for (int it = 0; it < n; it++) {
int jit = it;
vector<string> group;
while (jit < n && b[perm[it]] == b[perm[jit]]) {
group.push_back(a[perm[jit]]);
jit++;
}
jit--;
add += 1ll * (int) group.size() * (n - (int) group.size());
res += n < SQRT ? solveNNS(group) : solveNSS(group);
// res += solveNSS(group);
it = jit;
}
assert(add % 2 == 0);
res += 1337ll * add / 2;
return res;
}
ll slow(int n, vector<string> a) {
sort(a.begin(), a.end());
ll res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
{
string aa = a[i], bb = a[j];
sort(aa.begin(), aa.end());
sort(bb.begin(), bb.end());
if (aa != bb) {
res += 1337;
continue;
}
}
int l = 0, r = 0;
int sz = (int) a[i].size();
while (l < sz && a[i][l] == a[j][l]) l++;
while (r < sz && a[i][sz - 1 - r] == a[j][sz - 1 - r]) r++;
assert(l + r < sz);
int ql = l, qr = sz - r - 1;
int ok = 1;
for (int q = ql; q < qr; q++) {
if (a[i][q] < a[i][q + 1]) ok = 0;
}
if (ok) res++;
else res += 2;
}
}
return res;
}
void work() {
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
for (char& c : a[i])
c = 25 - (c - 'a') + 'a';
}
ll res = fast(n, a);
cout << res << "\n";
}
string gen_string(mt19937& rnd, int len, const int MAXC) {
string res(len, '?');
for (char& c : res)
c = rnd() % MAXC + 'a';
return res;
}
void test() {
mt19937 rnd(42);
const int MAXN = 10;
const int MAXL = 5;
const int MAXC = 3;
while (1) {
int n = rnd() % MAXN + 1;
int m = rnd() % MAXL + 1;
vector<string> a(n);
for (int i = 0; i < n; i++) {
if (i == 0 || rnd() % 2)
a[i] = gen_string(rnd, m, MAXC);
else {
a[i] = a[rnd() % i];
shuffle(a[i].begin(), a[i].end(), rnd);
}
}
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
n = (int) a.size();
shuffle(a.begin(), a.end(), rnd);
ll fs = fast(n, a);
ll sl = slow(n, a);
if (fs == sl) {
cout << "OK(" << fs << ")" << endl;
} else {
cout << "WA\n";
cout << "exp = " << sl << "\n";
cout << "fnd = " << fs << "\n";
cout << n << "\n";
for (int i = 0; i < n; i++)
cout << a[i] << "\n";
break;
}
}
}
int main() {
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
work();
// test();
return 0;
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=2e5+5;
int read()
{
int s=0;
char c=getchar(),lc='+';
while (c<'0'||'9'<c) lc=c,c=getchar();
while ('0'<=c&&c<='9') s=s*10+c-'0',c=getchar();
return lc=='-'?-s:s;
}
void write(int x)
{
if (x<0) putchar('-'),x=-x;
if (x<10) putchar(x+'0');
else write(x/10),putchar(x%10+'0');
}
void print(int x=-1,char c='\n')
{
write(x);
putchar(c);
}
string s,tmp,a[N];
map<string,vector<string>>mp;
int lcp[N],ri[N],ans=0;
struct stk
{
int l,r,lcp;
}st[N];
struct trie
{
int cnt;
vector<int>w[N];
struct node
{
int son[26];
vector<int>pos;
}t[N];
void insert(int m,int pos,string &s)
{
w[pos].resize(m+1);
int now=0;
t[0].pos.push_back(-pos);
#define to t[now].son[s[i]-'a']
for (int i=m;i>=1;i--)
{
if (!to) to=++cnt;
now=to;
t[now].pos.push_back(-pos);
w[pos][i]=now;
}
#undef to
}
int query(int pos,int m,int x,int l,int r)
{
int now=0;
if (x<=m) now=w[pos][x];
// for (int i:t[now].pos) print(i,'.');puts("");
int L=lower_bound(t[now].pos.begin(),t[now].pos.end(),-r)-t[now].pos.begin();
int R=upper_bound(t[now].pos.begin(),t[now].pos.end(),-l)-t[now].pos.begin();
return R-L;
}
void clear(int n)
{
for (int i=1;i<=n;i++) w[i].clear();
for (int i=0;i<=cnt;i++) for (int j=0;j<26;j++) t[i].son[j]=0;
for (int i=0;i<=cnt;i++) t[i].pos.clear();
cnt=0;
}
}t;
void solve(int n)
{
int tot0=0,tot1=0,top=0,m=a[1].size()-1;
sort(a+1,a+1+n);
for (int i=1;i<n;i++) lcp[i]=0;
for (int i=1;i<n;i++)
for (int j=1;j<=m;j++)
if (a[i][j]==a[i+1][j]) lcp[i]=j;
else break;
st[0]=(stk){n+1,n,m};
st[++top]=(stk){n,n,m};
t.insert(m,n,a[n]);
for (int i=n-1;i>=1;i--)
{
while (top&&st[top].lcp>=lcp[i]) top--;
top++;
st[top]=(stk){i+1,st[top-1].l-1,lcp[i]};
t.insert(m,i,a[i]);
ri[m]=m;
for (int j=m-1;j>=1;j--)
if (a[i][j]<=a[i][j+1])
ri[j]=ri[j+1];
else ri[j]=j;
// print(i,' ');print(top);
for (int j=1;j<=top;j++)
{
int x=st[j].lcp;
// print(i,',');print(ri[x+1]);
if (x==m) tot0+=st[j].r-st[j].l+1;
else tot1+=t.query(i,m,ri[x+1]+1,st[j].l,st[j].r);
}
st[++top]=(stk){i,i,m};
}
int tot2=n*(n-1)/2-tot0-tot1;
ans+=tot1+tot2*2;
t.clear(n);
// cout<<a[1]<<endl;
// print(tot0);
// print(tot1);
// print(tot2);
}
signed main(signed Recall,char *_902_[])
{
(void)Recall,(void)_902_;
int n=read(),tot=n*(n-1)/2;
for (int i=1;i<=n;i++)
{
cin>>s;
tmp=s;
sort(tmp.begin(),tmp.end());
mp[tmp].push_back(s);
}
for (auto x:mp)
{
int m=0;
for (string i:x.second) a[++m]=" "+i;
solve(m);
tot-=1LL*m*(m-1)/2;
}
ans+=tot*1337;
print(ans);
return 0;
}
//.................... .. . . . .. . .........
//................... ....,]]]]]]`. . . . .,@@@@@@`.. . ........
//................... ,@@@@@@@@@@@@@@@@@@\].,]]]]]`,@@@@@@@@@@@. . ........
//....................@^...[@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@` .......
//...................,@`......\@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@`. .......
//...................=@......../@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@`. .......
//...................=@....../@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@. .......
//...................=@....=@@@@@@/[[[[[@@@@@@@@@@@@@@@@@/`...[@@@@^ .......
//...................=@.../@@@/`...........\@@@@@@@@@@@`........,@@@. . ........
//......,/@@@@@@@O\]`.@`.=@@@`...............\@@@@@@@@`...........@@^ ........
//....,@^........,/@@@@^,@@/..................,@@@@@@^............,@@. .........
//....//......,/@[=OOOOO=@@....................,@@@@@...]O@@]......=@^ .........
//....@`....]@OO^.=OOO/@@@^.../@@@@@@@`.........=@@@@.=@@@@@@@@....=@^ .........
//...=@...,@OOO/.......=@@^.,@@@@@@@@@@@........=@@@@,@@@@@@@@@@...=@^ ..........
//...=@..=@`............\@^,@@@@@@@@@@@@@........@@@@=@@@@@@@@@@^..=@. .............
//...=@.=@@OO@@]........@@@=@@@@@@@@@@@@@^......=@@@@O@@@@@@@@@@^..//. ............
//...=@,@`. .,\@`....=@\@@@@@@@@@@@@@@@^......O@@@@@@@@@@@@@@@..=@. ...... . . ....... .............
//...=@@/ ........\@`..=@.\@@@@@@@@@@@@@@^.....=@@@@@@@@@@@@@@@^./@`...,/@O[[...[[[O@@/.=/ . ...... ...............
//....@@^ /@OOOO@@@\.=@ =@@@@@@@@@@@@@...../@@@@@@@@@@@@@@/]/@/...,@`...............[@@[[O@\`,[[@]...............
//....\@^ =@OOOOOOOO@\.@. OO@@@@@@@@@@/...,@@@@@@@@@@@@@@@@@@@@` .,@`.......,^...........,`...,\@`..,@.............
//....,@^ .=OOOOOOOOOO@\O^.\OOOO@@@@@@@@@@@@@@@@@@@@@@@@@@@@@/... ,@........=/..../@/[............\@...@`...........
//.....=@. =@OOOOOOOOOO@/@.,@OOOO@@@@@@@@@@@@@@@@@@@@@@@/[... .@`...........,@`.................,@..=O...........
//......@\..\OOOOOOOOOO@^=@.,@OO@@@@@@@@@@@@@@@@@@@@@^ . .O......@O@^.,@....................=\..@*..........
//.......\@..\@OOOOOOOO@O.,@`..@@@@@@@@@@@@@@@@@@@@@@O . .,O......=@@`.=^.....................@..@@@]`.......
//........,@\..\@@OOOO@@^...\@@@@@@@@@@@@@@@@@@@@@@@@@. ..,/@@@@@@..=@`......=O.........../^........@]@@O\*,O@`....
//..........,O@O]....,/@......@@@@@@@@@@@@@@@@@@@@@@@@^../@`*****=@@/@[....,[@`\@.......,@` .......,@/*********@\...
//..............,[\O@@@@@@@O@@@@@@@@@@@@@@@@@@@@@@@@@@@.=O*******[[[[O@@O]`]]]/@`@@@O@@O[[[***[[[\@@`*********,O@^..
//.................**O@...../@@@@@@@@@@@@@@@@@@@@@@@@@@@`*****************,\@*****[[`**************************=@...
//................****,@@@@@/*,@@@@@@@@@@@@@@@@@@@@@@@@O*******************************************************O/*..
//...................************[[\OO@@@@@@O/[[[[[[[*,@@\]**************************************************,@@*...
//..............................**********************.***[[@@O]]`***************************************]]@@[**....
//..........................................................*****,[[[OOOOOOOOOOOOOO@@@@@@@@@@@@O@OOOOO[[[****.......
//................................................................................******************................
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define ull long long
#define pll pair<ll,ll>
#define ff first
#define ss second
#define pb push_back
//#define endl "\n"
const ll maxn =2e5+5;
const ll mod=988642507;
const ll base=317;
/// ngay 1 Nhat quoc gia
ll val[maxn];
map<ll,vector<string>> adj1;
map<ll,ll> mp;
vector<ll> pos[maxn];
vector<ll> fwt[maxn];
void update_fwt(ll t,ll l, ll d)
{
for (int p = l; p <= pos[t].size(); p += p & -p)
fwt[t][p] = (fwt[t][p] + d) ;
}
ll get_fwt(ll t, ll l,ll r)
{
l=max(l,1ll);
r=min(r,(ll)pos[t].size());
if (l>r) return 0;
ll ret = 0;
for (int p=r; p; p -= p & -p)
ret = (ret + fwt[t][p]) ;
for (int p=l-1; p; p -= p & -p )
ret=(ret-fwt[t][p]);
return ret;
}
ll find_pos(ll t,ll val)
{
return lower_bound(pos[t].begin(),pos[t].end(),val)-pos[t].begin()+1;
}
vector<pll> adj[maxn];
vector<ll> nxt[maxn];
ll cntnw=0;
ll pre[maxn];
ull mu[maxn];
vector<ull> f[maxn];
ull get(ll t,ll i,ll j)
{
return (f[t][j]-f[t][i-1]*mu[j-i+1]);
}
void add(ll val,ll h)
{
if (!mp.count(val))
{
cntnw++;
mp[val]=cntnw;
}
pos[mp[val]].pb(h);
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
if (fopen("test.inp","r"))
{
freopen("test.inp","r",stdin);
freopen("test.out","w",stdout);
}
mt19937_64 rd(time(NULL));
mu[0]=1;
for (int i=1; i<maxn; i++)
mu[i]=(mu[i-1]*base);
for (int i=1; i<=26; i++)
{
val[i]=abs((ll)rd());
// cout <<val[i]<<endl;
}
ll n;
cin>>n ;
for (int i=1; i<=n; i++)
{
string s;
cin>> s;
ll p=0;
for (auto to:s)
{
p+=val[to-'a'+1];
}
adj1[p].pb(s);
// cout <<p<<" "<<s<<endl;
}
ll pre_pre=0;
ll ans=0;
for (auto to:adj1)
{
vector<string> vt=to.ss;
sort(vt.begin(),vt.end());
ans+=vt.size()*pre_pre*1337;
pre_pre+=vt.size();
ll lennw;
for (int i=1; i<=vt.size(); i++)
{
// cout<<vt[i-1]<<" "<<pre_pre<<endl;
string h=vt[i-1];
ll len=h.length();
f[i]=vector<ull> (len+2,0);
nxt[i]=vector<ll> (len+2,0);
nxt[i][len]=len;
h=" "+h;
for (int j=len-1; j>=1; j--)
{
nxt[i][j]=j;
if (h[j]<=h[j+1])
nxt[i][j]=nxt[i][j+1];
}
for (int j=1; j<=len; j++)
{
f[i][j]=(f[i][j-1]*base+val[h[j]-'a'+1]);
}
// cout <<vt[i-1]<<endl;
}
// cout <<"DB"<<endl;
for (int i=1; i<=vt.size(); i++)
{
// cout <<vt[i-1]<<endl;
// cout <<i<<" "<<pre_pre<<endl;
ll pre=0;
ll pre1=1;
lennw=vt[i-1].length();
while (1)
{
ll l=pre1,h=i;
while (l<=h)
{
ll mid=(l+h)/2;
if (get(mid,1,pre+1)==get(i,1,pre+1))
h=mid-1;
else
l=mid+1;
}
ll pos=l;
l=1,h= lennw;
while (l<=h)
{
ll mid=(l+h)/2;
if (get(pos,1,mid)==get(i,1,mid))
l=mid+1;
else
h=mid-1;
}
adj[pos].pb(make_pair(i,h));
// if (i==19) cout <<i<<" "<<h<<" "<<pos<<endl;
pre1=pos+1;
pre=h;
if (pre==lennw||pre1>i)
break;
}
// if (i==19) cout <<i<<" "<<pre_pre<<" "<<vt[i-1]<<endl;
pre1=i+1;
pre=lennw;
/*if (i==3&&pre_pre==3)
{
cout <<pre1<<" "<<pre<<endl;
}*/
while (pre1<=vt.size()&&pre>0)
{
ll l=pre1,h=vt.size();
while (l<=h)
{
ll mid=(l+h)/2;
if (get(mid,1,pre)!=get(i,1,pre))
h=mid-1;
else
l=mid+1;
}
ll pos=l;
if (l>vt.size()) break;
l=1,h= lennw;
while (l<=h)
{
ll mid=(l+h)/2;
if (get(pos,1,mid)==get(i,1,mid))
l=mid+1;
else
h=mid-1;
}
//if (i==19) cout <<pos<<" "<<i<<" "<<h<<" kt"<<endl;
adj[pos].pb(make_pair(i,h));
pre1=pos+1;
pre=h;
if (pre==0||pre1>vt.size())
break;
}
// cout <<i<<" "<<pre_pre<<endl;
}
for (int i=1; i<=vt.size(); i++)
{
for (int j=0; j<lennw; j++)
{
ll t=nxt[i][j+1];
// cout <<get(i,t+1,lennw)<<" "<<t+1<<" "<<lennw<<" "<<i<<endl;
add(get(i,t+1,lennw),j);
}
}
for (int i=1; i<=cntnw; i++)
{
sort(pos[i].begin(),pos[i].end());
pos[i].resize(unique(pos[i].begin(),pos[i].end())-pos[i].begin());
fwt[i]=vector<ll> (pos[i].size()+2,0);
}
for (int i=1; i<=vt.size(); i++)
{
ll t=nxt[i][1];
pre[i]=0;
update_fwt(mp[get(i,t+1,lennw)],find_pos(mp[get(i,t+1,lennw)],pre[i]),1);
}
ll cnt_0=0;
ll cnt_1=0;
ll cnt_2=0;
ll cnt_p=0;
for (int i=1; i<=vt.size(); i++)
{
for (auto p:adj[i])
{
if (pre[p.ff]!=lennw)
{
ll t=nxt[p.ff][pre[p.ff]+1];
update_fwt(mp[get(p.ff,t+1,lennw)],find_pos(mp[get(p.ff,t+1,lennw)],pre[p.ff]),-1);
}
pre[p.ff]=p.ss;
if (pre[p.ff]!=lennw)
{
ll t=nxt[p.ff][pre[p.ff]+1];
update_fwt(mp[get(p.ff,t+1,lennw)],find_pos(mp[get(p.ff,t+1,lennw)],pre[p.ff]),1);
}
}
for (int j=1; j<=lennw; j++)
{
ll st_ed=j+1;
ll id=mp[get(i,st_ed,lennw)];
ll l=1, h=lennw;
while (l<=h)
{
ll mid=(l+h)/2;
if (nxt[i][mid]>j)
h=mid-1;
else
l=mid+1;
}
// if (i==1&&j==2) cout <<id<<" "<<get(i,st_ed,lennw)<<endl;
if (h-1>=0)
{
ll pos_id=upper_bound(pos[id].begin(),pos[id].end(),h-1)-pos[id].begin()-1+1;
cnt_1+=get_fwt(id,1,pos_id);
if (nxt[i][h]==j)
{
ll t1=0,t2=h;
while (t1<=t2)
{
ll mid=(t1+t2)/2;
if (nxt[i][mid]==nxt[i][h]) t2=mid-1;
else t1=mid+1;
}
ll pos_id1=lower_bound(pos[id].begin(),pos[id].end(),t1)-pos[id].begin()+1;
cnt_p+=get_fwt(id,pos_id1,pos_id);
}
}
// cout <<cnt_0<<" "<<cnt_1<<" "<<cnt_2<<" "<<cnt_p<<endl;
}
}
cnt_1-=(cnt_p/2);
for (int i=1;i<=vt.size();i++)
{
ll j=i;
while (j<=vt.size()&&vt[j-1]==vt[i-1]) j++;
j--;
cnt_0+=(j-i+1)*(j-i)/2;
i=j;
}
cnt_2=vt.size()*(vt.size()-1)/2-cnt_1-cnt_0;
ans+=2*cnt_2+cnt_1;
// cout <<cnt_0<<" "<<cnt_1<<" "<<cnt_2<<" "<<cnt_p<<" "<<ans<<endl;
for (int i=1;i<=vt.size();i++) adj[i].clear();
for (int i=1; i<=cntnw; i++)
fwt[i].clear(),pos[i].clear();
mp.clear();
cntnw=0;
}
cout <<ans;
}
|
#include<bits/stdc++.h>
using namespace std;
//======================
//
// Template OleschY
//
// Die M�glichkeiten der deutschen Grammatik k�nnen
// einen, wenn man sich darauf, was man ruhig, wenn
// man m�chte, sollte, einl�sst, �berraschen.
// - @Gedankenbalsam
//
//======================
//======================
// Output/Debug
//======================
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
os << "[";
for (int i = 0; i < v.size(); ++i)
{
os << v[i];
if (i != v.size() - 1)
os << ", ";
}
os << "]\n";
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p)
{
os << "[";
os << p.first;
os << ", ";
os << p.second;
os << "]";
return os;
}
#ifndef ONLINE_JUDGE
#define debug(x) cout << (#x) << " is " << (x) << endl
#else
#define debug(...) 42
#endif
//======================
// Solution Single testcase
//======================
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
pair<int, int> getlr(const string& st1, const string& st2)
{
int ssize = st1.size();
pair<int, int> borders = {-1, ssize};
for(int l = 0; l < ssize; l++)
{
if(st1[l] == st2[l])
{
borders.first = l;
}
else break;
}
for(int r = ssize - 1; r >= 0; r--)
{
if(st1[r] == st2[r])
{
borders.second = r;
}
else break;
}
borders.first++;
borders.second = ssize - borders.second;
return borders;
}
long long nAll;
vector<pair<string, string>> in(nAll);
int solve(int forceSol = -1)
{
for(int i = 0; i < nAll ; ++i)
{
in[i].second = in[i].first;
sort(in[i].second.begin(), in[i].second.end());
}
sort(in.begin(), in.end(), [](pair<string, string> const & a, pair<string, string> const & b)
{
return a.second < b.second;
});
vector<vector<string>> strGroups;
for(int i = 0; i < nAll; i++)
{
if(i == 0 || in[i].second != in[i - 1].second)
{
strGroups.push_back(vector<string>(0));
}
strGroups[strGroups.size() - 1].push_back(in[i].first);
}
long long ans = 0;
long long ans1337 = 0;
long long ansWidthwisePairs = 0;
for(vector<string>& strs : strGroups)
{
long long n = strs.size();
long long ssize = strs[0].size();
ans1337 += 1337 * n * (nAll - n);
ans += n * ( n - 1 );
sort(strs.begin(), strs.end());
int dbgcnt = 0;
if(forceSol == 1 || n >= 6800 && forceSol != 2)
{
// check widthwise
for(string const& str : strs)
{
//debug(dbgcnt++);
for(int i = 0; i < ssize; i++)
{
for(int j = i + 1; j < ssize; j++)
{
string temp = str;
sort(temp.begin() + i, temp.begin() + j + 1);
if(temp[i] != str[i])
{
if(temp[j] != str[j])
{
if(binary_search(strs.begin(), strs.end(), temp))
{
ansWidthwisePairs -= 2;
}
}
}
}
}
}
}
else
{
// check pairwise
for(int i = 0; i < n; i++)
{
for(int j = i + 1; j < n; j++)
{
auto [l, r] = getlr(strs[i], strs[j]);
if(r == ssize)
ans -= 2;
else
{
if(is_sorted(strs[i].begin() + l, strs[i].end() - r))
ans -= 1;
if(is_sorted(strs[j].begin() + l, strs[j].end() - r))
ans -= 1;
}
}
}
}
}
cout << ans1337 / 2 + ans + ansWidthwisePairs / 2 << "\n";
return 0;
}
void input(bool create)
{
if(!create)
{
cin >> nAll;
in.resize(nAll);
for(int i = 0; i < nAll; ++i)
{
cin >> in[i].first;
}
solve();
}
else
{
for(nAll = 11000; nAll <= 11500; nAll += 1)
{
nAll = uniform_int_distribution<int>(11100, 11450)(rng);
for(int force = 1; force <= 1; force++)
{
string s = "";
for(int j = 0; j < 200000 / nAll; j++)
{
s.push_back((char)uniform_int_distribution<int>('a', 'h')(rng));
}
set<string> strs;
while(strs.size() < nAll)
{
shuffle(s.begin(), s.end(), rng);
strs.insert(s);
}
in.clear();
for(string s : strs)
{
in.push_back({s, s});
}
shuffle(in.begin(), in.end(), rng);
//output
/*cout << nAll << "\n";
for(auto s : in)
{
cout << s.first << "\n";
}
return;*/
// outputt //
clock_t time_req;
time_req = clock();
solve(force);
time_req = clock() - time_req;
cout << " nAll: " << nAll << " StringSize: " << s.size() << " solution: " << force << " Time: " << (float)time_req / CLOCKS_PER_SEC << " seconds" << endl;
}
}
}
}
//======================
// Technical stuff
//======================
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
//freopen("a.out", "w", stdout); // console output is better (in most cases)
#else
// add i/o method of specific testing system
#endif
int ntest = 1;
//cin >> ntest;
for(int test = 0; test < ntest; ++test)
{
#ifndef ONLINE_JUDGE
input(true);
#else
input(false);
#endif
}
return 0;
}
|
#include<iostream>
#include<cstring>
#include<cstdio>
#include<climits>
#include<algorithm>
#include<queue>
#include<vector>
#define int long long
#define mod1 998244353
#define mod2 100000007
#define mod3 20050329
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define fi first
#define se second
using namespace std;
inline int read(){
int f=1,ans=0; char c=getchar();
while(c<'0'||c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0'&&c<='9'){ans=ans*10+c-'0';c=getchar();}
return f*ans;
}
const int MAXN=2e5+11;
int N,M,A[MAXN],cnt0,cnt1,cnt2,Ans,rnk[MAXN]; char S[MAXN];
vector<int> vec[MAXN];
struct node{
int h1,h2,h3,id;
}tp[MAXN];
bool cmp(node x1,node x2){
if(x1.h1!=x2.h1) return x1.h1<x2.h1;
if(x1.h2!=x2.h2) return x1.h2<x2.h2;
return x1.h3<x2.h3;
}
vector<int> Buc;
struct Trie{
int ch[MAXN][27],tot,siz[MAXN],Id[MAXN]; vector<int> cyf;
int Liml[MAXN],Limr[MAXN];
void init(){
memset(Liml,127/3,sizeof(Liml)),memset(Limr,-127/3,sizeof(Limr));
}
void clear(){
cyf.clear(); for(int i=1;i<=tot;i++){siz[i]=0,Id[i]=0; Liml[i]=Liml[0],Limr[i]=Limr[0]; for(int j=0;j<26;j++) ch[i][j]=0;}
tot=1; return;
}
void ins(int id){
int u=1; siz[u]++; Liml[u]=min(Liml[u],id),Limr[u]=max(Limr[u],id);
for(auto c:Buc){
if(!ch[u][c]) ch[u][c]=++tot; u=ch[u][c]; siz[u]++;
Liml[u]=min(Liml[u],id),Limr[u]=max(Limr[u],id);
}
Id[u]=id; return;
}
void dfs(int u){
if(Id[u]) cyf.pb(Id[u]);
for(int i=0;i<26;i++) if(ch[u][i]) dfs(ch[u][i]);
return;
}
}T1;
bool F(int x,int y){
int psl=0,psr=M-1;
while(vec[rnk[x]][psl]==vec[rnk[y]][psl]) psl++;
while(vec[rnk[x]][psr]==vec[rnk[y]][psr]) psr--;
bool ff=1;
for(int i=psl+1;i<=psr;i++) ff&=(vec[rnk[x]][i-1]<=vec[rnk[x]][i]);
if(ff) return 1;
ff=1;
for(int i=psl+1;i<=psr;i++) ff&=(vec[rnk[y]][i-1]<=vec[rnk[y]][i]);
if(ff) return 1;
return 0;
}
struct Query{int opt; vector<int> vec;};
vector<Query> Vec[MAXN];
void calc(int L,int R){
T1.clear();
for(int i=L;i<=R;i++){
Buc.clear(); for(auto c:vec[rnk[i]]) Buc.pb(c);
T1.ins(rnk[i]);
}
T1.dfs(1);
for(int i=0;i<R-L+1;i++) rnk[L+i]=T1.cyf[i];
T1.clear();
for(int i=L;i<=R;i++){
Buc.clear(); for(auto c:vec[rnk[i]]) Buc.pb(c);
T1.ins(i);
}
for(int i=L;i<=R;i++){
//for(auto v:vec[rnk[i]]) cerr<<v;cerr<<endl;
int u=1;
for(int l=0;l<M;l++){
int psl=T1.Liml[u],psr=T1.Limr[u];
int r=l; while(r<M-1&&vec[rnk[i]][r]<=vec[rnk[i]][r+1]) ++r;
if(psl<=i-1){
Query GG; GG.vec.clear();
GG.opt=1; for(int c=M-1;c>=r+1;c--) GG.vec.pb(vec[rnk[i]][c]); Vec[i-1].pb(GG);
GG.opt=-1; Vec[psl-1].pb(GG);
}
if(i+1<=psr){
Query GG; GG.vec.clear();
GG.opt=1; for(int c=M-1;c>=r+1;c--) GG.vec.pb(vec[rnk[i]][c]); Vec[psr].pb(GG);
GG.opt=-1; Vec[i].pb(GG);
}
for(int j=l;j<=r;j++) u=T1.ch[u][vec[rnk[i]][j]];
l=r;
}
}
T1.clear();
for(int i=L;i<=R;i++){
//cerr<<"Ins:"<<endl;
//for(auto c:vec[rnk[i]]) cerr<<c<<" ";cerr<<endl;
Buc.clear(); for(int j=M-1;j>=0;j--) Buc.pb(vec[rnk[i]][j]);
T1.ins(i);
for(auto pp:Vec[i]){
//cerr<<"Find:"<<endl;
int u=1; for(auto c:pp.vec) u=T1.ch[u][c];
cnt1+=pp.opt*T1.siz[u];
//cerr<<"opt:"<<pp.opt<<"===>";
//for(auto c:pp.vec) cerr<<c<<" ";
//cerr<<endl;
//cerr<<"Ans:"<<T1.siz[u]<<endl;
}
}
//cerr<<"cnt1:"<<cnt1<<endl; exit(0);
//for(int i=L;i<=R;i++) for(int j=i+1;j<=R;j++) if(F(i,j)) cnt1++;
return;
}
signed main(){
//freopen("4.in","r",stdin);
N=read();
for(int i=1;i<=N;i++){
scanf("%s",S+1); M=strlen(S+1);
for(int j=1;j<=M;j++) A[j]=S[j]-'a',vec[i].pb(A[j]);
sort(A+1,A+M+1);
int res1=0,res2=0,res3=0;
for(int j=1;j<=M;j++) res1=(res1*27+A[j])%mod1,res2=(res2*27+A[j])%mod2,res3=(res3*27+A[j])%mod3;
tp[i].h1=res1,tp[i].h2=res2,tp[i].h3=res3; tp[i].id=i;
} sort(tp+1,tp+N+1,cmp); cnt0=N*N;
T1.init();
for(int i=1;i<=N;i++) rnk[i]=tp[i].id;
for(int l=1;l<=N;l++){
int r=l; while(tp[r+1].h1==tp[l].h1&&tp[r+1].h2==tp[l].h2&&tp[r+1].h3==tp[l].h3&&r<N) ++r;
cnt0-=(r-l+1)*(r-l+1); calc(l,r);
l=r;
} cnt0/=2; cnt2=N*(N-1)/2-cnt0-cnt1;
//cerr<<"cnt0:"<<cnt0<<" cnt1:"<<cnt1<<" cnt2:"<<cnt2<<endl;
printf("%lld\n",cnt0*1337+cnt1+cnt2*2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long P11 = 90874329411493;
int n,i,j;
string s[200020];
pair < string , int > P[200020];
vector < int > sorted_until[200020];
string q;
vector < long long > pref[200020],suff[200020];
map < long long , vector < int > > all_prefs[200020],all_suffs[200020];
map < long long , int > issorted[200020];
long long ans = 0, res;
long long same = 0;
long long diff = 0;
int main() {
cin>>n;
for (i=1;i<=n;i++) {
cin>>q;
s[i] = q;
int r = 0;
for (j=0;j<int(q.size());j++) {
r=max(j+1,r);
while (r < int(q.size()) && q[r] >= q[r-1]) r++;
sorted_until[i].push_back(r);
}
long long _pref = 0;
long long _suff = 0;
pref[i].push_back(0);
suff[i].push_back(0);
for (j=0;j<int(q.size());j++) {
_pref = (_pref * 29LL + (q[j] - 'a' + 1) ) % P11;
_suff = (_suff * 29LL + (q[q.size() - j - 1] - 'a' + 1) ) % P11;
pref[i].push_back(_pref);
suff[i].push_back(_suff);
}
P[i].first = s[i];
sort(P[i].first.begin(), P[i].first.end());
P[i].second = i;
}
sort(P+1, P+n+1);
for (i=1;i<=n;i++) {
int j = i;
while (j <= n && P[j].first == P[i].first) j++;
j--;
res += (long long)(j-i+1) * (j-i);
diff += (long long)(j-i+1) * (n-j) * 1337LL;
vector < pair < string , int > > curr;
for (int k=i;k<=j;k++)
curr.push_back({s[P[k].second], P[k].second});
sort(curr.begin(),curr.end());
int len = curr[0].first.size();
for (int k=0;k<=len;k++)
all_prefs[k].clear(), all_suffs[k].clear(), issorted[k].clear();
for (int k=0; k<curr.size(); k++) {
int real = curr[k].second;
for (int id=0; id<=len; id++) {
all_suffs[id][suff[real][id]].push_back(k);
}
}
int sm = 0;
for (int k=0; k<curr.size(); k++) {
while (sm < curr.size() && curr[sm].first == curr[k].first) sm++;
same += sm-k-1;
int real = curr[k].second;
for (int id=0; id<len; id++) {
if (issorted[id][suff[real][id]])
continue;
issorted[id][suff[real][id]] = true;
sort(all_suffs[id][suff[real][id]].begin(),
all_suffs[id][suff[real][id]].end());
}
}
for (int id=0; id < len; id ++) {
for (int k=0;k<curr.size();k++) {
int x = k;
int y = k;
while (y < curr.size() &&
pref[curr[y].second][id] == pref[curr[x].second][id])
y++;
y--;
for (int l = x; l <= y; l++) {
int st = id;
int real = curr[l].second;
int en = sorted_until[real][id];
// if (y - x > 0) {
// cout<<"first "<<id<<" characters "<<l<<" "<<en<<" "<<suff[real][len - en]<<" "<<all_suffs[len-en][suff[real][len - en]].size()<<endl;
// }
int ll = 0, rr = all_suffs[len-en][suff[real][len - en]].size()-1;
int from = rr+1;
while (ll <= rr) {
int mm = (ll+rr)/2;
if (all_suffs[len-en][suff[real][len - en]][mm] >= x) {
from = mm;
rr = mm - 1;
} else ll = mm + 1;
}
ll = 0; rr = all_suffs[len-en][suff[real][len - en]].size()-1;
int strt = -1;
while (ll <= rr) {
int mm = (ll+rr)/2;
if (all_suffs[len-en][suff[real][len - en]][mm] <= y) {
strt = mm;
ll = mm + 1;
} else rr = mm - 1;
}
// cout<<strt<<" "<<from<<endl;
if (from <= strt &&
(id == 0 || sorted_until[real][id] != sorted_until[real][id-1]))
ans+=strt-from;
}
k = y;
}
}
i=j;
}
// cout<<res<<" "<<ans<<" "<<same<<endl;
cout<<res-ans+diff<<endl;
}
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 2e5;
const int P = 557;
const int mod = 1e9 + 11;
vector<int> p(maxn + 1);
vector<int> calc(string s) {
vector<int> ans(s.size());
ans[s.size() - 1] = s.size() - 1;
for (int i = (int) s.size() - 2; i >= 0; --i) {
if (s[i] <= s[i + 1]) {
ans[i] = ans[i + 1];
} else {
ans[i] = i;
}
}
return ans;
}
int solve_short(vector<string> a) {
map<pair<pair<int, int>, int>, int> mp;
vector<vector<int>> eq;
vector<vector<int>> hashs;
for (int i = 0; i < a.size(); ++i) {
eq.push_back(calc(a[i]));
vector<int> h(a[i].size() + 1);
h[0] = 0;
for (int j = 1; j < a[i].size() + 1; ++j) {
h[j] = h[j - 1] * P + a[i][j - 1] - 'a' + 1;
h[j] %= mod;
}
hashs.push_back(h);
}
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < a[i].size(); ++j) {
int hash = 0;
for (int k = j; k <= eq[i][j]; ++k) {
hash += p[a[i][k] - 'a' + 1];
hash %= mod;
int h1 = hashs[i][j];
int h2 = (hashs[i].back() - hashs[i][k + 1] * p[a[i].size() - k - 1] % mod + mod) % mod;
if (((j == 0 || (a[i][j] < a[i][j - 1])) && (k == a[i].size() - 1 || a[i][k] > a[i][k + 1])))
mp[{{h1, h2}, hash}]++;
}
}
}
int ans = 0;
for (int i = 0; i < a.size(); ++i) {
for (int j = 0; j < a[i].size(); ++j) {
int hash = 0;
for (int k = j; k < a[i].size(); ++k) {
hash += p[a[i][k] - 'a' + 1];
hash %= mod;
int h1 = hashs[i][j];
int h2 = (hashs[i].back() - hashs[i][k + 1] * p[a[i].size() - k - 1] % mod + mod) % mod;
ans += mp[{{h1, h2}, hash}];
if (eq[i][j] >= k &&
((j == 0 || (a[i][j] < a[i][j - 1])) && (k == a[i].size() - 1 || a[i][k] > a[i][k + 1])))
ans--;
}
}
}
return ans + ((a.size() * (a.size() - 1) / 2 - ans) * 2);
}
int solve_long(vector<string> a) {
int ans = 0;
vector<vector<int>> hashs;
vector<vector<int>> hashs2(a.size());
vector<vector<int>> eq;
for (int i = 0; i < a.size(); ++i) {
eq.push_back(calc(a[i]));
vector<int> h(a[i].size() + 1);
h[0] = 0;
for (int j = 1; j < a[i].size() + 1; ++j) {
h[j] = h[j - 1] * P + a[i][j - 1] - 'a' + 1;
h[j] %= mod;
}
hashs.push_back(h);
for (int mid = 0; mid < a[i].size(); ++mid) {
hashs2[i].push_back((hashs[i].back() - hashs[i][mid] * p[a[i].size() - mid] % mod + mod) % mod);
}
}
for (int j = 0; j < a.size(); ++j) {
for (int i = j + 1; i < a.size(); ++i) {
int l = -1;
int r = a[j].size();
while (l + 1 != r) {
int mid = (l + r) >> 1;
if (hashs[j][mid + 1] == hashs[i][mid + 1]) {
l = mid;
} else {
r = mid;
}
}
int pref = l;
l = -1;
r = a[j].size();
while (l + 1 != r) {
int mid = (l + r) >> 1;
if (hashs2[j][mid] == hashs2[i][mid]) {
r = mid;
} else {
l = mid;
}
}
int suf = r;
pref++;
suf--;
if (eq[j][pref] >= suf || eq[i][pref] >= suf) {
ans += 1;
} else {
ans += 2;
}
}
}
return ans;
}
int solve(vector<string> a) {
if (a.size() <= 6000) {
return solve_long(a);
} else {
return solve_short(a);
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
#ifdef foo
freopen("input.txt", "r", stdin);
#endif
int n;
cin >> n;
p[0] = 1;
for (int j = 1; j <= maxn; ++j) {
p[j] = p[j - 1] * P % mod;
}
int ans = 0;
map<string, vector<string>> mp;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
string t = s;
sort(s.begin(), s.end());
mp[s].push_back(t);
}
int sum = 0;
for (auto x :mp) {
ans += sum * x.second.size() * 1337 + solve(x.second);
sum += x.second.size();
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
string s,h;
map<string,vector<string>>mp;
long long m,n,k,i,j,c,l,r,a,b,x=0,y=0,t;
cin>>n;
t=n*(n-1LL)/2;
while(n--)cin>>s,k=s.length(),h=s,sort(h.begin(),h.end()),mp[h].push_back(s);
for(auto p:mp){
auto v=p.second;
m=v.size(),sort(v.begin(),v.end());
for(i=c=0;i<m;i++)
for(j=i+1;j<m;j++){
l=a=b=0,r=k-1;
while(v[i][l]==v[j][l])l++;
while(v[i][r]==v[j][r])r--;
for(;l<r&&!(a&b);l++)a|=(v[i][l+1]<v[i][l]),b|=(v[j][l+1]<v[j][l]);
c+=!(a&b);
}
x+=c,y+=m*(m-1)/2-c;
}
cout<<1337*(t-x-y)+x+2*y<<"\n";
}
|
#pragma GCC optimize("O3","Ofast")
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int maxn=2e5+5;
string s[maxn];
int has[maxn];
mt19937_64 rnd;
int arr1[26];
int arr[maxn][26];
int getrnd()
{
return (abs((int) rnd()));
}
int gethas1(string s)
{
int ans=0;
for(int i=0;i<s.size();++i)
{
ans+=arr[i][s[i]-'a'];
}
return ans;
}
int f(string s1,string s2)
{
assert(s1.size()==s2.size());
int n=s1.size();
int pref=0;
int suf=(n-1);
for(int i=0;i<n;++i)
{
if(s1[i]!=s2[i]) {pref=i;break;}
}
for(int i=(n-1);i>=0;--i)
{
if(s1[i]!=s2[i]) {suf=i;break;}
}
bool ok1=1,ok2=1;
for(int i=pref;i<=(suf-1);++i)
{
ok1=(ok1 && s1[i+1]>=s1[i]);
ok2=(ok2 && s2[i+1]>=s2[i]);
}
if(ok1 || ok2) return 1;
else return 2;
}
set <int> okhas;
set <pair<int,int> > d;
int slv(vector <int> v)
{
int sz=s[v[0]].size();
okhas.clear();
d.clear();
if(sz>=50)
{
int ans=0;
for(int i=0;i<v.size();++i)
{
for(int j=(i+1);j<v.size();++j)
{
ans+=f(s[v[i]],s[v[j]]);
}
}
return ans;
}
for(int i=0;i<v.size();++i) okhas.insert(gethas1(s[v[i]]));
for(int i=0;i<v.size();++i)
{
string t=s[v[i]];
int ha=gethas1(s[v[i]]);
for(int i=0;i<t.size();++i)
{
string t1=t;
for(int j=(i+2);j<=t.size();++j)
{
int curr=(j-1);
while(curr>i && t1[curr]<t1[curr-1]) {swap(t1[curr-1],t1[curr]);curr--;}
int o=gethas1(t1);
if(okhas.count(o) && o!=ha)
{
d.insert({min(ha,o),max(ha,o)});
}
}
}
}
return v.size()*(v.size()-1)-d.size();
}
int32_t main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
rnd.seed(time(NULL));
for(int i=0;i<26;++i) arr1[i]=getrnd();
for(int i=0;i<maxn;++i) for(int j=0;j<26;++j) arr[i][j]=getrnd();
int n;
cin>>n;
int o[n][26];
for(int i=0;i<n;++i) for(int j=0;j<26;++j) o[i][j]=0;
map <int,vector <int> > u;
vector <int> keys;
for(int i=0;i<n;++i)
{
cin>>s[i];
has[i]=0;
for(auto h:s[i])
{
o[i][h-'a']++;
has[i]+=arr1[h-'a'];
}
if(!u.count(has[i]))
{
keys.push_back(has[i]);
u[has[i]]={i};
}
else
{
u[has[i]].push_back(i);
}
}
int ans=(n*(n-1)/2)*1337;
for(auto h:keys)
{
int cnt=u[h].size();
ans-=(cnt*(cnt-1)/2)*1337;
ans+=slv(u[h]);
}
cout<<ans;
return 0;
}
|
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#include<bits/stdc++.h>
using namespace std;
const int N=200005,M=505;
struct st
{
string s;
int c[30];
void rd()
{
cin>>s;
for(int i=0;i<26;i++)
c[i]=0;
for(int i=0;i<s.size();i++)
c[s[i]-'a']++;
}
bool operator<(const st k)const
{
for(int i=0;i<26;i++)
if(c[i]!=k.c[i])
return c[i]<k.c[i];
return s<k.s;
}
}a[N];
string s[N];
int ok(int x,int y)
{
for(int i=0;i<26;i++)
if(a[x].c[i]!=a[y].c[i])
return 0;
return 1;
}
int n,m;
long long ans;
int main()
{
ios::sync_with_stdio(0);
cin>>n;
for(int i=1;i<=n;i++)
a[i].rd();
m=a[1].s.size();
sort(a+1,a+n+1);
for(int i=1;i<=n;i++)
s[i]=a[i].s;
if(n<=4000)
{
for(int l=1;l<=n;)
{
int r=l;
while(r<=n&&ok(l,r))
r++;
ans+=1337ll*(r-l)*(n-r+1);
r--;
for(int i=l;i<=r;i++)
{
for(int j=i+1;j<=r;j++)
{
int x=m,y=1,f1=1,f2=1;
for(int k=0;k<m;k++)
if(s[i][k]!=s[j][k])
x=min(x,k),y=max(y,k);
for(int k=x;k<y;k++)
{
if(s[i][k]>s[i][k+1])
f1=0;
if(s[j][k]>s[j][k+1])
f2=0;
}
if(f1||f2)
ans++;
else
ans+=2;
}
}
l=r+1;
}
}
else
{
for(int l=1;l<=n;)
{
int r=l;
while(r<=n&&ok(l,r))
r++;
ans+=1337ll*(r-l)*(n-r+1);
r--;
ans+=1ll*(r-l+1)*(r-l);
for(int i=0;i<m;i++)
{
for(int j=i+1;j<m;j++)
{
for(int p=l;p<=r;p++)
{
string t=s[p];
sort(t.begin()+i,t.begin()+j+1);
if(t[i]!=s[p][i]&&t[j]!=s[p][j]&&binary_search(s+l,s+r+1,t))
ans--;
}
}
}
l=r+1;
}
}
printf("%lld\n",ans);
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,m;
ll ans=0,sum;
int p[200009];
string s,h;
map<string ,vector<string>>mp;
int main(){
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
cin>>n;
for(int i=1;i<=n;++i){
cin>>s;
m=s.length();
h=s;
sort(h.begin(),h.end());
mp[h].push_back(s);
}
for(auto o:mp){
auto v=o.second;
int S=v.size();
sort(v.begin(),v.end());
for(int i=0;i<S;++i){
for(int j=m-2;j>=0;--j)p[j]=v[i][j]<=v[i][j+1]?p[j+1]+1:0;
for(int j=i+1;j<S;++j){
int l=0,r=m-1;
while(v[i][l]==v[j][l])l++;
while(v[i][r]==v[j][r])r--;
if(l+p[l]>=r)ans++;
else ans+=2;
}
}
ans+=1337ll*S*sum;
sum+=S;
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int XXX = 1337;
struct BIT {
int N;
int T[202020];
void init(int n) {
N = n;
for(int i = 1; i <= N; i++) T[i] = 0;
}
void upd(int x, int v) {
for(int i = x; i <= N; i += i&-i) T[i] += v;
}
int get(int x) {
int ret = 0;
for(int i = x; i; i -= i&-i) ret += T[i];
return ret;
}
int query(int l, int r) {
return get(r) - get(l - 1);
}
}bit;
struct Strings {
string s, r, sorted;
int cnt;
int sx, rx;
vector<int> su, sd, ru, rd;
}A[202020];
struct Query {
int y1, y2, c;
Query(int _y1, int _y2, int _c) : y1(_y1), y2(_y2), c(_c) {}
};
int N, M;
string S[202020];
vector<Query> q[202020];
vector<pii> U[202020];
int main() {
scanf("%d", &N);
for(int i = 1; i <= N; i++) cin >> S[i];
M = S[1].size();
sort(S + 1, S + N + 1);
int id = 0;
for(int i = 1; i <= N; i++) {
if(S[i] == S[i - 1]) {
A[id].cnt++;
}
else {
id++;
A[id].s = S[i];
A[id].r = A[id].sorted = A[id].s;
reverse(A[id].r.begin(), A[id].r.end());
sort(A[id].sorted.begin(), A[id].sorted.end());
A[id].cnt = 1;
}
}
N = id;
sort(A + 1, A + N + 1, [&](Strings& a, Strings& b) {
return a.sorted < b.sorted;
});
ll ans = 0;
ll tot = 0;
int l = 1, r;
for(int i = 2; i <= N + 1; i++) {
if(A[i].sorted != A[i - 1].sorted) {
r = i - 1;
// printf("%d %d\n", l, r);
sort(A + l, A + r + 1, [&](Strings a, Strings b) {
return a.s < b.s;
});
for(int j = l; j <= r; j++) A[j].sx = j - l + 1;
for(int j = 0; j < M; j++) {
for(int k = l; k <= r; k++) {
int t = 1;
if(k == l || A[k].s[j] != A[k - 1].s[j]) t = k - l + 1;
else {
if(j) t = A[k].su[j - 1];
t = max(t, A[k - 1].su[j]);
}
A[k].su.push_back(t);
}
for(int k = r; k >= l; k--) {
int t = r - l + 1;
if(k == r || A[k].s[j] != A[k + 1].s[j]) t = k - l + 1;
else {
if(j) t = A[k].sd[j - 1];
t = min(t, A[k + 1].sd[j]);
}
A[k].sd.push_back(t);
}
}
sort(A + l, A + r + 1, [&](Strings a, Strings b) {
return a.r < b.r;
});
for(int j = l; j <= r; j++) A[j].rx = j - l + 1;
for(int j = 0; j < M; j++) {
for(int k = l; k <= r; k++) {
int t = 1;
if(k == l || A[k].r[j] != A[k - 1].r[j]) t = k - l + 1;
else {
if(j) t = A[k].ru[j - 1];
t = max(t, A[k - 1].ru[j]);
}
A[k].ru.push_back(t);
}
for(int k = r; k >= l; k--) {
int t = r - l + 1;
if(k == r || A[k].r[j] != A[k + 1].r[j]) t = k - l + 1;
else {
if(j) t = A[k].rd[j - 1];
t = min(t, A[k + 1].rd[j]);
}
A[k].rd.push_back(t);
}
}
for(int j = l; j <= r; j++) {
reverse(A[j].ru.begin(), A[j].ru.end());
reverse(A[j].rd.begin(), A[j].rd.end());
}
for(int j = 1; j <= r - l + 1; j++) U[j].clear();
for(int j = l; j <= r; j++) U[A[j].sx].emplace_back(A[j].rx, A[j].cnt);
ll sum = 0, zero = 0;
for(int j = l; j <= r; j++) {
sum += A[j].cnt;
zero += (ll)A[j].cnt * (A[j].cnt - 1) / 2;
}
ll cnt = 0;
for(int j = 1; j <= r - l + 1; j++) q[j].clear();
for(int j = l; j <= r; j++) {
int lft = 0;
A[j].s.push_back(0);
// printf("%s\n", A[j].s.c_str());
for(int k = 1; k <= M; k++) {
if(A[j].s[k - 1] > A[j].s[k]) {
int x1, y1, x2, y2;
if(lft == 0) { x1 = 1; x2 = r - l + 1; }
else { x1 = A[j].su[lft - 1]; x2 = A[j].sd[lft - 1]; }
if(k == M) { y1 = 1; y2 = r - l + 1; }
else { y1 = A[j].ru[k]; y2 = A[j].rd[k]; }
cnt -= (ll)A[j].cnt * A[j].cnt;
if(x1 > 1) q[x1 - 1].emplace_back(y1, y2, -A[j].cnt);
q[x2].emplace_back(y1, y2, A[j].cnt);
// printf("%d %d : %d %d %d %d\n", lft, k - 1, x1, y1, x2, y2);
// printf("%lld\n", cnt);
lft = k;
}
}
}
bit.init(r - l + 1);
for(int j = 1; j <= r - l + 1; j++) {
for(pii k : U[j]) {
// printf("upd %d %d\n", k.first, k.second);
bit.upd(k.first, k.second);
}
for(auto& k : q[j]) {
// printf("query %d %d %d\n", k.y1, k.y2, k.c);
cnt += (ll)k.c * bit.query(k.y1, k.y2);
}
}
// printf("%lld %lld %lld\n", sum, cnt, zero);
ll s12 = (ll)sum * (sum - 1) / 2 - zero;
ans += 2 * s12 - cnt;
ans += tot * sum * XXX;
tot += sum;
sum = 0;
l = i;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include<cstdio>
#include<cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn=2e5+10;
int n,len;
string str[maxn];
int lg[maxn];
struct longest_common_prefix{
int height[maxn];
vector<string> v;
bool ___;
void ddd(){ ___=true;}
void set(vector<string> _v){ v=_v;}
inline int _lcp(string a,string b){
int ans=0;
while(a[ans]==b[ans]) ans++;
return ans;
}
void get_height(){
for(int i=1;i<n;i++) height[i]=_lcp(v[i-1],v[i]);
}
int f[maxn][19];
void init_st(){
for(int i=0;i<n;i++) f[i][0]=height[i];
int t=lg[n+1]+1;
for(int j=1;j<t;j++)
for(int i=0;i<=n-(1<<j);i++)
f[i][j]=min(f[i][j-1],f[i+(1<<j-1)][j-1]);
// if(___) printf(">>>>%d<<<<",f[3][0]);
}
inline int query_st(int l,int r){
int k=lg[r-l+1];
// if(___&&l==1&&r==3) printf("f[%d][%d] = %d, f[%d][%d] = %d<<<",l,k,f[l][k],r-(1<<k)+1,k,f[r-(1<<k)-1][k]);
return min(f[l][k],f[r-(1<<k)+1][k]);
}
inline int lcp(int x,int y){
if(x>y) swap(x,y);
int tmp=query_st(x+1,y)-1; //printf("%d ",tmp);
// if(___) printf("lcp(%d, %d) = %d\n",x,y,tmp);
return tmp;
}
void debug(){
cout<<"height : "; for(int i=0;i<n;i++) cout<<height[i]<<" "; cout<<endl;
}
}v1,v2;
int pos[maxn],pos_[maxn];
vector<int> s[maxn];
inline int lsp(int x,int y){
int tmp=len-v2.lcp(pos[x],pos[y])-1;
// printf("lsp(%d, %d) = %d\n",x,y,tmp);
return tmp;
}
ll calc1(vector<string> v){
ll ans=0;
for(int i=1;i<n;i++)
for(int j=0;j<i;j++){
int p=v1.lcp(i,j),q=lsp(i,j);//puts("???");
// printf("(%d, %d) : p = %d, q = %d\n",i,j,p,q);
// printf("s[%d][%d] = %d, s[%d][%d] = %d\n",i,p+1,s[j][p+1],i,q-1,s[j][q-1]);
if(s[j][p+1]==s[j][q-1]) ans+=1;
else ans+=2;
}
return ans;
}
int mn[maxn],mx[maxn];
inline int findl(int p,int lcp_){
int l=0,r=p;
while(l<r){
int mid=l+r>>1;
if(v1.lcp(mid,p)>=lcp_) r=mid;
else l=mid+1;
}
return l;
}
inline int findr(int p,int lcp_){
int l=p,r=n-1;
while(l<r){
int mid=l+r+1>>1;
// printf("v1.lcp(%d, %d) = %d\n",mid,p,v1.lcp(mid,p));
if(v1.lcp(mid,p)>=lcp_) l=mid;
else r=mid-1;
}
return l;
}
inline int findl_(int p,int lsp_){
int l=0,r=p;
while(l<r){
int mid=l+r>>1;
if(len-v2.lcp(mid,p)-1<=lsp_) r=mid;
else l=mid+1;
}
return l;
}
inline int findr_(int p,int lsp_){
int l=p,r=n-1;
while(l<r){
int mid=l+r+1>>1;
if(len-v2.lcp(mid,p)-1<=lsp_) l=mid;
else r=mid-1;
}
return l;
}
struct SegTree{ int lc,rc,dat;}tr[maxn*4];
int rt[maxn],tot;
int build(int l,int r){
int p=++tot;
if(l==r) return tr[p].dat=tr[p].lc=tr[p].rc=0,p;
int mid=l+r>>1;
tr[p].lc=build(l,mid);
tr[p].rc=build(mid+1,r);
return p;
}
int modify(int now,int l,int r,int pos,int val){
int p=++tot; tr[p]=tr[now];
if(l==r) return tr[p].dat=val,p;
int mid=l+r>>1;
if(pos<=mid) tr[p].lc=modify(tr[now].lc,l,mid,pos,val);
else tr[p].rc=modify(tr[now].rc,mid+1,r,pos,val);
tr[p].dat=tr[tr[p].lc].dat+tr[tr[p].rc].dat;
return p;
}
int ask(int p,int q,int l,int r,int ql,int qr){
if(ql<=l&&qr>=r) return tr[q].dat-tr[p].dat;
int mid=l+r>>1,res=0;
if(ql<=mid) res=ask(tr[p].lc,tr[q].lc,l,mid,ql,qr);
if(qr>mid) res+=ask(tr[p].rc,tr[q].rc,mid+1,r,ql,qr);
return res;
}
ll calc2(vector<string> v){
ll ans=0;
for(int i=0;i<len-1;i++){
for(int k=0;k<n;k++) mn[k]=mx[k]=v[k][i];
for(int j=i+1;j<len;j++){
// printf("i = %d, j = %d\n",i,j);
for(int k=0;k<n;k++){
mn[k]=min(mn[k],(int)v[k][j]);
mx[k]=max(mx[k],(int)v[k][j]);
}
tot=0; rt[0]=build(0,n);
for(int k=0;k<n;k++) rt[k+1]=modify(rt[k],0,n,pos[k],s[k][i]==s[k][j]);
for(int k=0;k<n;k++){
// if(i==0&&j==1) printf("%d %d %d %d\n",v[k][i],mn[k],v[k][j],mx[k]);
if(v[k][i]==mn[k]||v[k][j]==mx[k]) continue;
int l=findl(k,i-1),r=findr(k,i-1);
int l_=findl_(pos[k],j+1),r_=findr_(pos[k],j+1);
// printf("k = %d : l = %d, r = %d, l_ = %d, r_ = %d\n",k,l,r,l_,r_);
// printf("ans += %d\n",l?ss[r]-ss[l-1]:ss[r]);
// ans+=l?ss[r]-ss[l-1]:ss[r];
ans+=ask(rt[l],rt[r+1],0,n,l_,r_);
// printf("ask(%d, %d, %d, %d, %d, %d) = %d\n",l,r+1,0,n,l_,r_,ask(rt[l],rt[r+1],0,n,l_,r_));
}
// exit(0);
}
}
return (ll)n*(n-1)-ans;
}
ll calc(vector<string> v){
n=v.size();
// printf("n = %d, len = %d\n",n,len);
sort(v.begin(),v.end());
v1.set(v),v1.get_height(),v1.init_st();
vector<string> rv=v;
map<string,int> mp;
for(int i=0;i<n;i++){
reverse(rv[i].begin(),rv[i].end());
mp[rv[i]]=i;
}
sort(rv.begin(),rv.end());
for(int i=0;i<n;i++) pos[mp[rv[i]]]=i;
// for(int i=0;i<n;i++) pos_[pos[i]]=i;
// cout<<"pos : "; for(int i=0;i<n;i++) cout<<pos[i]<<" "; cout<<endl;
// cout<<"pos_ : "; for(int i=0;i<n;i++) cout<<pos_[i]<<" "; cout<<endl;
//v2.ddd();
v2.set(rv),v2.get_height(),v2.init_st();
/* puts("v :");
for(int i=0;i<n;i++) cout<<i<<" : "<<v[i]<<endl;
puts("rv :");
for(int i=0;i<n;i++) cout<<i<<" : "<<rv[i]<<endl;
v2.debug();*/
for(int i=0;i<n;i++){
s[i].resize(len);
s[i][0]=0;
for(int j=1;j<len;j++)
if(v[i][j]<v[i][j-1]) s[i][j]=s[i][j-1]+1;
else s[i][j]=s[i][j-1];
}
// cout<<"s[0] : "; for(int i=0;i<len;i++) cout<<s[0][i]<<" "; cout<<endl;
return n<=10000?calc1(v):calc2(v);
//return calc2(v);
}
int main(){
// freopen("in.in","r",stdin);
int n; cin>>n;
for(int i=0;i<18;i++) lg[1<<i]=i;
for(int i=3;i<=n+1;i++) if(!lg[i]) lg[i]=lg[i-1];
// for(int i=0;i<maxn;i++) printf("lg[%d] = %d, ",i,lg[i]); puts("");
map<vector<int>,vector<string> > mp;
for(int i=1;i<=n;i++){
cin>>str[i];
vector<int> c(26);
for(auto j:str[i]) c[j-'a']++;
mp[c].push_back(str[i]);
}
len=str[1].length();
int tot=0; ll ans=0;
for(map<vector<int>,vector<string> >::iterator
it=mp.begin();it!=mp.end();it++){
ans+=calc(it->second);
ans+=(ll)tot*it->second.size()*1337;
tot+=it->second.size();
}
cout<<ans<<endl;
return 0;
}
/*
6
abc
acb
bac
bca
cab
cba
*/
|
#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#include<bits/stdc++.h>
#define X first
#define Y second
#define sz(a) (int)a.size()
#define ll long long
using namespace std;
const int mod1 = 1e9 + 7;
const int mod2 = 998244353;
const int N = 2e5 + 100;
struct node{
int tin, tout;
int go_to[26];
node(){fill(go_to, go_to + 26, -1);};
};
string s[N];
int pow1[N], pow2[N];
node nodes[N];
ll ans = 0;
ll cnt = 0;
vector <pair <int, int> > suf[N];
map <pair <pair <int, int>, int>, int> Tree[4 * N];
int iter = 0;
int timer = 0;
void go_to_all(int v)
{
for(int j = 0; j < 26; j++)
{
if(nodes[v].go_to[j] != -1)
{
go_to_all(nodes[v].go_to[j]);
}
nodes[v].go_to[j] = -1;
}
}
void f1(int v, int ind, int i)
{
if(i == sz(s[ind]))
{
return;
}
if(nodes[v].go_to[s[ind][i] - 'a'] == -1)
{
nodes[v].go_to[s[ind][i] - 'a'] = iter++;
}
f1(nodes[v].go_to[s[ind][i] - 'a'], ind, i + 1);
}
void f2(int v)
{
nodes[v].tin = timer++;
for(int i = 0; i < 26; i++)
{
if(nodes[v].go_to[i] != -1)
{
f2(nodes[v].go_to[i]);
}
}
nodes[v].tout = timer - 1;
// cout << v << " " << nodes[v].tin << " " << nodes[v].tout << "\n";
}
void add(int v, int l, int r, int idx, pair <pair <int, int>, int> hs)
{
Tree[v][hs]++;
if(l == r)
{
return;
}
if(idx <= (r + l) / 2)
{
add(v * 2, l, (r + l) / 2, idx, hs);
}
else
{
add(v * 2 + 1, (r + l) / 2 + 1, r, idx, hs);
}
}
int cp(int v, int l, int r, int al, int ar, pair <pair <int, int>, int> hs)
{
if(l >= al && r <= ar)
{
return Tree[v][hs];
}
if(l <= ar && r >= al)
{
return cp(v * 2, l, (r + l) / 2, al, ar, hs) + cp(v * 2 + 1, (r + l) / 2 + 1, r, al, ar, hs);
}
return 0;
}
int go_to_idx(int v, int ind, int i)
{
if(i == sz(s[ind]))
{
return v;
}
return go_to_idx(nodes[v].go_to[s[ind][i] - 'a'], ind, i + 1);
}
void solve(vector <int> x)
{
// cout << "A\n";
timer = 0;
iter = 1;
cnt += 1LL * sz(x) * (sz(x) - 1) / 2;
for(auto i : x)
{
f1(0, i, 0);
}
f2(0);
for(auto i : x)
{
int idx = go_to_idx(0, i, 0);
pair <int, int> hs = {0, 0};
add(1, 0, nodes[0].tout, nodes[idx].tin, make_pair(make_pair(0, 0), 0));
for(int j = 1; j <= sz(s[i]); j++)
{
hs.X = (1LL * hs.X * 27 + s[i][sz(s[i]) - j] - 'a' + 1) % mod1;
hs.Y = (1LL * hs.Y * 27 + s[i][sz(s[i]) - j] - 'a' + 1) % mod2;
add(1, 0, nodes[0].tout, nodes[idx].tin, make_pair(hs, j));
}
}
for(auto i : x)
{
int idx = 0;
for(int j = 0; j < sz(s[i]); j++)
{
int k = j;
while(k + 1 < sz(s[i]) && s[i][k + 1] >= s[i][k])
{
k++;
}
ans += cp(1, 0, nodes[0].tout, nodes[idx].tin, nodes[idx].tout, {suf[i][k + 1], sz(s[i]) - 1 - k}) - 1;
for(int p = j; p <= k; p++)
{
idx = nodes[idx].go_to[s[i][p] - 'a'];
}
j = k;
}
}
for(int j = 0; j < 4 * (1 + nodes[0].tout); j++)
{
Tree[j].clear();
}
go_to_all(0);
}
signed main()
{
// ifstream cin("rt.txt.txt");
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
pow1[0] = 1;
pow2[0] = 1;
for(int i = 1; i < N; i++)
{
pow1[i] = 1LL * pow1[i - 1] * 27 % mod1;
pow2[i] = 1LL * pow2[i - 1] * 27 % mod2;
}
map <vector <int>, vector <int> > mp;
for(int i = 0; i < n; i++)
{
vector <int> cnt(26);
cin >> s[i];
suf[i].resize(sz(s[i]) + 1);
suf[i][sz(s[i])] = {0, 0};
for(int j = sz(s[i]) - 1; j >= 0; j--)
{
suf[i][j].X = (1LL * suf[i][j + 1].X * 27 + s[i][j] - 'a' + 1) % mod1;
suf[i][j].Y = (1LL * suf[i][j + 1].Y * 27 + s[i][j] - 'a' + 1) % mod2;
}
for(int j = 0; j < sz(s[i]); j++)
{
cnt[s[i][j] - 'a']++;
}
mp[cnt].push_back(i);
}
for(auto p : mp)
{
solve(p.Y);
}
cout << (cnt - ans) * 2 + ans + ((n - 1) * n / 2 - cnt) * 1337;
return 0;
}
|
#include <map>
#include <string>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
typedef long long ll;
const int Maxn=200000;
int n,m;
std::map<std::string,std::vector<std::string> > mp_S;
int ch[Maxn+5][26];
std::vector<int> node_lis[Maxn+5],cur_lis[Maxn+5];
int id_tot;
int calc_num(int pos,int l,int r){
return std::lower_bound(node_lis[pos].begin(),node_lis[pos].end(),r)-std::lower_bound(node_lis[pos].begin(),node_lis[pos].end(),l);
}
ll solve(std::vector<std::string> str_lis){
std::sort(str_lis.begin(),str_lis.end());
int n=(int)str_lis.size(),m=str_lis.front().size();
while(id_tot>0){
memset(ch[id_tot],0,sizeof ch[id_tot]);
node_lis[id_tot].clear();
id_tot--;
}
id_tot++;
for(int i=0;i<n;i++){
cur_lis[i].resize(m+1);
cur_lis[i][m]=1;
int u=1;
node_lis[u].push_back(i);
for(int j=m-1;j>=0;j--){
if(ch[u][str_lis[i][j]-'a']==0){
ch[u][str_lis[i][j]-'a']=++id_tot;
}
u=ch[u][str_lis[i][j]-'a'];
cur_lis[i][j]=u;
node_lis[u].push_back(i);
}
}
ll ans=1ll*n*(n-1);
std::vector<std::pair<int,int> > st;
st.push_back(std::make_pair(n,-1));
for(int i=n-2;i>=0;i--){
int lcp=0;
while(lcp<m&&str_lis[i][lcp]==str_lis[i+1][lcp]){
lcp++;
}
while(st.back().second>=lcp){
st.pop_back();
}
st.push_back(std::make_pair(i+1,lcp));
std::vector<int> unord_lis;
for(int j=1;j<m;j++){
if(str_lis[i][j]<str_lis[i][j-1]){
unord_lis.push_back(j);
}
}
unord_lis.push_back(m);
for(int j=1;j<(int)st.size();j++){
int l=st[j].first,r=st[j-1].first;
lcp=st[j].second;
if(lcp<m){
lcp=*std::upper_bound(unord_lis.begin(),unord_lis.end(),lcp);
}
ans-=calc_num(cur_lis[i][lcp],l,r);
}
}
return ans;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
static char s[Maxn+5],t[Maxn+5];
scanf("%s",s);
m=0;
while(s[m++]!='\0');
m--;
for(int i=0;i<m;i++){
t[i]=s[i];
}
std::sort(t,t+m);
mp_S[t].push_back(s);
}
ll ans=0;
std::map<std::string,std::vector<std::string> >::iterator it;
it=mp_S.begin();
int sum=0;
while(it!=mp_S.end()){
ans+=solve(it->second);
ans+=1337ll*sum*((it->second).size());
sum+=(it->second).size();
it++;
}
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5+10;
const int P1 = 876756319, B1 = 991;
const int P2 = 799898821, B2 = 2333;
int n, m, fac1[N], fac2[N], f1[N], f2[N], p1[N], p2[N];
string s[N];
pair<int,int> Hash(int l, int r) {
int x = (f1[r]-f1[l-1]*(int64_t)fac1[r-l+1])%P1;
int y = (f2[r]-f2[l-1]*(int64_t)fac2[r-l+1])%P2;
if (x<0) x+=P1; if (y<0) y+=P2;
return pair<int,int>(x,y);
}
int chk(int id, int l, int r) {
for (int i=l+1; i<=r; ++i) if (s[id][i]<s[id][i-1]) return 0;
return 1;
}
int solve(int i, int j) {
int cnt[26]{};
for (int x=0; x<m; ++x) {
++cnt[s[i][x]];
--cnt[s[j][x]];
}
for (int i=0; i<26; ++i) if (cnt[i]) return 1337;
int L = 0, R = m-1;
while (s[i][L]==s[j][L]) ++L;
while (s[i][R]==s[j][R]) --R;
if (chk(i,L,R)) return 1;
if (chk(j,L,R)) return 1;
return 2;
}
int main() {
fac1[0] = fac2[0] = 1;
for (int i=1; i<N; ++i) {
fac1[i] = fac1[i-1]*(int64_t)B1%P1;
fac2[i] = fac2[i-1]*(int64_t)B2%P2;
p1[i] = (p1[i-1]*(int64_t)B1+1)%P1;
p2[i] = (p2[i-1]*(int64_t)B2+1)%P2;
}
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i=1; i<=n; ++i) {
cin >> s[i];
m = s[i].size();
for (int j=0; j<m; ++j) s[i][j] -= 'a';
}
int64_t ans = 0;
int64_t L = n*(int64_t)n*m, R = n*(int64_t)m*m*100;
if (L<R) {
for (int i=1; i<=n; ++i) {
for (int j=i+1; j<=n; ++j) {
ans += solve(i,j);
}
}
}
else {
map<pair<int,int>,int> mp,mp2;
for (int i=1; i<=n; ++i) {
for (int j=0; j<m; ++j) {
f1[j+1] = (f1[j]*(int64_t)B1+s[i][j]+1)%P1;
f2[j+1] = (f2[j]*(int64_t)B2+s[i][j]+1)%P2;
}
++mp[Hash(1,m)];
}
for (int i=1; i<=n; ++i) {
for (int j=0; j<m; ++j) {
f1[j+1] = (f1[j]*(int64_t)B1+s[i][j]+1)%P1;
f2[j+1] = (f2[j]*(int64_t)B2+s[i][j]+1)%P2;
}
auto now = Hash(1,m);
set<pair<int,int>> ss;
for (int j=0; j<m; ++j) {
int cnt[26]{};
for (int k=j; k<m; ++k) {
++cnt[s[i][k]];
pair<int,int> u;
for (int t=0; t<26; ++t) if (cnt[t]) {
u.first = (u.first*(int64_t)fac1[cnt[t]]+p1[cnt[t]]*(t+1ll))%P1;
u.second = (u.second*(int64_t)fac2[cnt[t]]+p2[cnt[t]]*(t+1ll))%P2;
}
if (j) {
auto tmp = Hash(1,j);
u.first = (tmp.first*(int64_t)fac1[k-j+1]+u.first)%P1;
u.second = (tmp.second*(int64_t)fac2[k-j+1]+u.second)%P2;
}
if (k!=m-1) {
auto tmp = Hash(k+2,m);
u.first = (u.first*(int64_t)fac1[m-k-1]+tmp.first)%P1;
u.second = (u.second*(int64_t)fac2[m-k-1]+tmp.second)%P2;
}
if (u!=now&&mp.count(u)&&!ss.count(u)) {
ss.insert(u);
ans += mp[u];
}
if (j==0&&k==m-1) ++mp2[u];
}
}
}
int64_t w = 0;
for (auto &t:mp2) w += t.second*(t.second-1ll)/2;
ans = ans+(w-ans)*2+(n*(n-1ll)/2-w)*1337;
}
printf("%lld\n", ans);
}
|
#include<bits/stdc++.h>
#define ull unsigned long long
#define ll long long
#define pk push_back
#define pii pair<int,int>
#define mk make_pair
#define fi first
#define se second
#define sz(x) ((int)x.size())
#define vt vector<string>
const int maxn=2e5+5;
using namespace std;
int rd(){
int x=0,f=1;char c=getchar();
while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
while(isdigit(c))x=(x<<3)+(x<<1)+c-'0',c=getchar();
return x*f;
}
int n,len,all,lg[maxn];
struct LCS_LCP{
int height[maxn],f[maxn][19];
int lcp(string a,string b){
int LCP=0;
while(a[LCP]==b[LCP])++LCP;
return LCP;
}
void init(vt vec){
for(int i=1;i<n;i++)height[i]=lcp(vec[i-1],vec[i]);
}
void init_st(){
for(int i=0;i<n;i++)f[i][0]=height[i];
for(int j=1;j<=18;j++)
for(int i=0;i<=n-(1<<j);i++)
f[i][j]=min(f[i][j-1],f[i+(1<<(j-1))][j-1]);
}
int query(int l,int r){
int s=lg[r-l+1];
return min(f[l][s],f[r-(1<<s)+1][s]);
}
int _lcp(int x,int y){
if(x>y)swap(x,y);
return query(x+1,y)-1;
}
}v1,v2;
struct Segment_tree{
#define mid ((l+r)>>1)
int rt[maxn],ls[maxn*20],rs[maxn*20],sum[maxn*20],tot;
void build(int &p,int l,int r){
sum[p]=ls[p]=rs[p]=0;
if(l==r)return;build(ls[p],l,mid);build(rs[p],mid+1,r);
}
void modify(int &p,int pre,int l,int r,int x,int v){
p=++tot;sum[p]=sum[pre]+v;ls[p]=ls[pre];rs[p]=rs[pre];
if(l==r)return;
if(x<=mid)modify(ls[p],ls[pre],l,mid,x,v);
else modify(rs[p],rs[pre],mid+1,r,x,v);
}
int query(int p,int pre,int l,int r,int sl,int sr){
if(sl<=l&&r<=sr)return sum[p]-sum[pre];int res=0;
if(sl<=mid)res=query(ls[p],ls[pre],l,mid,sl,sr);
if(mid<sr)res+=query(rs[p],rs[pre],mid+1,r,sl,sr);
return res;
}
#undef mid
}T;
int pos[maxn],mx[maxn],mi[maxn];
string str[maxn];
map<vector<int>,vt >Mp;
vector<int>S[maxn];
ll ans;
int lcs(int i,int j){return len-v2._lcp(pos[i],pos[j])-1;}
ll calc_min(){
ll res=0;
for(int i=0;i<n;i++)
for(int j=0;j<i;j++){
int p=v1._lcp(i,j),q=lcs(i,j);
if(S[j][p+1]==S[j][q-1])res++;
else res+=2;
}
return res;
}
int findl(int ed,int LCP){
int l=0,r=ed;
while(l<r){
int mid=(l+r)>>1;
if(v1._lcp(mid,ed)>=LCP)r=mid;
else l=mid+1;
}
return l;
}
int findr(int st,int LCP){
int l=st,r=n-1;
while(l<r){
int mid=(l+r+1)>>1;
if(v1._lcp(st,mid)>=LCP)l=mid;
else r=mid-1;
}
return l;
}
int find_l(int ed,int LCS){
int l=0,r=ed;
while(l<r){
int mid=(l+r)>>1;
if(len-v2._lcp(mid,ed)-1<=LCS)r=mid;
else l=mid+1;
}
return l;
}
int find_r(int st,int LCS){
int l=st,r=n-1;
while(l<r){
int mid=(l+r+1)>>1;
if(len-v2._lcp(st,mid)-1<=LCS)l=mid;
else r=mid-1;
}
return l;
}
ll calc_max(vt vec){
ll res=0;
for(int i=0;i<len-1;i++){
for(int k=0;k<n;k++)mx[k]=mi[k]=vec[k][i]-'a'+1;
for(int j=i+1;j<len;j++){
for(int k=0;k<n;k++){
mx[k]=max(mx[k],vec[k][j]-'a'+1);
mi[k]=min(mi[k],vec[k][j]-'a'+1);
}
T.tot=0;T.build(T.rt[0],0,n);
for(int k=0;k<n;k++)T.modify(T.rt[k+1],T.rt[k],0,n,pos[k],(S[k][i]==S[k][j])?1:0);
for(int k=0;k<n;k++){
if(mx[k]==vec[k][j]-'a'+1||mi[k]==vec[k][i]-'a'+1)continue;
int l=findl(k,i-1),r=findr(k,i-1);
int _l=find_l(pos[k],j+1),_r=find_r(pos[k],j+1);
res+=T.query(T.rt[r+1],T.rt[l],0,n,_l,_r);
}
}
}
return 1LL*n*(n-1)-res;
}
ll calc(vt vec){n=vec.size();
sort(vec.begin(),vec.end());
v1.init(vec);v1.init_st();
vt tmp=vec;map<string,int>mp;
for(int i=0;i<n;i++){
reverse(tmp[i].begin(),tmp[i].end());
mp[tmp[i]]=i;
}sort(tmp.begin(),tmp.end());
for(int i=0;i<n;i++)pos[mp[tmp[i]]]=i;
v2.init(tmp);v2.init_st();
for(int i=0;i<n;i++){
S[i].resize(len);S[i][0]=0;
for(int j=1;j<len;j++)
S[i][j]=S[i][j-1]+(vec[i][j-1]>vec[i][j]);
}
return n<=10000?calc_min():calc_max(vec);
}
int main(){
n=rd();lg[0]=-1;for(int i=1;i<=2e5;i++)lg[i]=lg[i>>1]+1;
for(int i=1;i<=n;i++){
cin>>str[i];len=str[i].size();
vector<int>c(26);
for(int j=0;j<len;j++)c[str[i][j]-'a']++;
Mp[c].pk(str[i]);
}
for(map<vector<int>,vt >::iterator it=Mp.begin();it!=Mp.end();++it){
ans+=calc(it->second);
ans+=1LL*all*it->second.size()*1337;
all+=it->second.size();
}
printf("%lld\n",ans);
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__);fflush(stderr);
#else
#define eprintf(...) 42
#endif
using ll = long long;
using ld = long double;
using uint = unsigned int;
using ull = unsigned long long;
template<typename T>
using pair2 = pair<T, T>;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
return (ull)rng() % B;
}
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
clock_t startTime;
double getCurrentTime() {
return (double)(clock() - startTime) / CLOCKS_PER_SEC;
}
const ll INF = 1337;
const int N = 200200;
const int A = 26;
map<string, vector<string>> mapchik;
int go[N][A];
vector<int> inTrie[N];
vector<int> myV[N];
int k;
int calcInV(int v, int l, int r) {
return lower_bound(all(inTrie[v]), r) - lower_bound(all(inTrie[v]), l);
}
ll solve(vector<string> a) {
sort(all(a));
int n = (int)a.size();
int m = (int)a[0].size();
while(k > 0) {
k--;
for (int c = 0; c < A; c++)
go[k][c] = 0;
inTrie[k].clear();
}
k++;
for (int i = 0; i < n; i++) {
myV[i] = vector<int>(m + 1, 0);
int v = 0;
inTrie[v].push_back(i);
for (int j = m - 1; j >= 0; j--) {
int c = (int)(a[i][j] - 'a');
if (go[v][c] == 0) go[v][c] = k++;
v = go[v][c];
inTrie[v].push_back(i);
myV[i][j] = v;
}
}
ll ans = (ll)n * (n - 1);
int l = 0;
while(l < n) {
int r = l;
while(r < n && a[l] == a[r]) r++;
ans -= (ll)(r - l) * (r - l - 1) / 2;
l = r;
}
vector<pii> st;
st.push_back(mp(n, -1));
for (int i = n - 2; i >= 0; i--) {
int lcp = 0;
while(lcp < m && a[i][lcp] == a[i + 1][lcp]) lcp++;
while(st.back().second >= lcp) st.pop_back();
st.push_back(mp(i + 1, lcp));
vector<int> notSorted;
for (int j = 1; j < m; j++)
if (a[i][j] < a[i][j - 1])
notSorted.push_back(j);
notSorted.push_back(m);
for (int j = 1; j < (int)st.size(); j++) {
int l = st[j].first, r = st[j - 1].first;
int lcp = st[j].second;
if (lcp < m)
lcp = *upper_bound(all(notSorted), lcp);
ans -= calcInV(myV[i][lcp], l, r);
}
}
return ans;
}
int main()
{
startTime = clock();
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s, p;
while(n--) {
cin >> s;
p = s;
sort(all(p));
mapchik[p].push_back(s);
}
n = 0;
ll ans = 0;
for (auto t : mapchik) {
ans += solve(t.second);
ans += INF * n * (int)t.second.size();
n += (int)t.second.size();
}
cout << ans << endl;
return 0;
}
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
constexpr long long int MOD = 1000000007;
//constexpr int MOD = 1000000007;
//constexpr int MOD = 998244353;
//constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-12;
//int N, M, K, T, H, W, L, R;
long long int N, M, K, T, H, W, L, R;
struct RollingHash {
unsigned long long int mod61 = (1LL << 61) - 1;
unsigned long long int Mul61(unsigned long long int a, unsigned long long int b) {
unsigned long long int au = a >> 31;
unsigned long long int ad = a ^ (au << 31);
unsigned long long int bu = b >> 31;
unsigned long long int bd = b ^ (bu << 31);
unsigned long long int ret = au * bu * 2;
ret += ad * bd;
unsigned long long int mid = ad * bu + au * bd;
unsigned long long int midu = mid >> 30;
unsigned long long int midd = mid & ((1 << 30) - 1);
ret += midu + (midd << 31);
return ret;
}
unsigned long long int CalcMod61(unsigned long long int num) {
return num % mod61;
}
int num;
vector<unsigned long long int>h;
vector<unsigned long long int>by;
RollingHash(string s, unsigned int base = 10007) {
num = s.size();
h.resize(s.size() + 1);
by.resize(s.size() + 1, 1);
for (int i = 1; i <= num; i++) {
by[i] = CalcMod61(Mul61(by[i - 1], base));
h[i] = CalcMod61(Mul61(h[i - 1], base) + s[i - 1]);
}
}
unsigned long long int Get(int l, int r) {
return CalcMod61(h[r] + mod61 * 4 - Mul61(h[l], by[r - l]));
}
};
void Solve() {
cin >> K;
map<string, vector<string>>mp;
for (int i = 0; i < K; i++) {
string s;
cin >> s;
auto t = s;
sort(t.begin(), t.end());
mp[t].push_back(s);
}
long long int ans = 0;
for (auto& i : mp) {
sort(i.second.begin(), i.second.end());
ans += i.second.size() * (K - i.second.size()) * 1337;
}
ans /= 2;
vector<int>lst(333333, -1);
int cnt = 0;
for (auto &i : mp) {
cnt++;
if (i.second.size() <= 2500) {
for (int j = 0; j < i.second.size(); j++) {
for (int k = j + 1; k < i.second.size(); k++) {
int add = 1;
int l = MOD;
int r = -MOD;
for (int p = 0; p < i.first.size(); p++) {
if (i.second[k][p] != i.second[j][p]) {
l = min(l, p);
r = max(r, p);
}
}
for (int p = l + 1; p <= r; p++) {
if (i.second[j][p] < i.second[j][p - 1]) {
add = 2;
break;
}
}
ans += add;
}
}
}
else {
map<pair<unsigned long long int, unsigned long long int>, int>box;
for (int j = 0; j < i.second.size(); j++) {
cnt++;
ans += j * 2;
RollingHash rh(i.second[j]);
for (int p = 0; p < i.first.size(); p++) {
for (int q = 0; p + q < i.first.size(); q++) {
auto a = rh.Get(0, p);
auto b = rh.Get(i.first.size() - q, i.first.size());
if (box.find({ a,b }) != box.end()) {
if (lst[box[{a, b}]] != cnt) {
ans--;
lst[box[{a, b}]] = cnt;
}
}
}
}
for (int p = 0; p < i.first.size(); p++) {
int q = p;
while (q + 1 < i.first.size() && i.second[j][q] <= i.second[j][q+1]) {
q++;
box[{rh.Get(0, p), rh.Get(q + 1, i.first.size())}] = j;
}
}
}
}
}
cout << ans << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
T = 1;
//cin >> T;
while (T--) {
Solve();
}
}
|
#include<bits/stdc++.h>
#define fi first
#define se second
#define len(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define pb push_back
typedef long long ll;
typedef long double ld;
using namespace std;
const int N = (int)2e5 + 10;
const int LG = 18;
int lcp[N], lcp_st[N], sparse[N][LG];
int fen[N];
void modify(int x , int pl){
x++;
for(; x < N; x += x & -x)
fen[x] += pl;
}
int get_pref(int x){
x++;
int ans = 0;
for(; x >0 ; x -= x & -x)
ans += fen[x];
return ans;
}
int get_line(int l , int r){
return get_pref(r) - get_pref(l - 1);
}
int get_mn(int l , int r){
if(r < l)
return 1e9;
int bt = 31 - __builtin_clz(r - l + 1);
return min(sparse[l][bt], sparse[r - (1 << bt) + 1][bt]);
}
void solve_for_class(vector < string > st , ll &answer){
int n = len(st);
sort(all(st));
ll zero=0,one=0;
int len_eq = 1;
vector < string > uniq;
vector < int > cnt;
uniq.pb(st[0]), cnt.pb(1);
for(int x = 1; x < n; ++x){
if(st[x] != st[x - 1]){
zero += 1ll * len_eq * (len_eq - 1) / 2;
len_eq = 1;
uniq.pb(st[x]);
cnt.pb(1);
}else
len_eq++, cnt.back()++;
}
zero += (1ll * len_eq * (len_eq - 1) / 2);
st = uniq;
n = len(st);
/// we need to build lcp array on reversed sorted strings, and also we need to keep id of this strings
/// let's build lcp
vector < pair < string , int > > rev(len(st));
for(int i = 0; i < len(st); ++i){
string rv = st[i];reverse(all(rv));
rev[i] = {rv, i};
}
sort(all(rev));
vector < int > id_in_suff(n);
for(int i = 0 ; i < n; ++i){
id_in_suff[rev[i].se] = i;
}
/// and also we want lcp_st
fill(lcp_st, lcp_st + n , 0);
fill(lcp, lcp + n , 0);
for(int i = 0; i < n - 1; ++i){
while(lcp_st[i] < len(st[i]) && st[i][lcp_st[i]] == st[i+1][lcp_st[i]]){
++lcp_st[i];
}
}
for(int i = 0; i < n - 1; ++i){
while(lcp[i] < len(st[i]) && rev[i].fi[lcp[i]] == rev[i+1].fi[lcp[i]]){
++lcp[i];
}
}
for(int i = 0; i < n - 1; ++i){
sparse[i][0] = lcp[i];
}
for(int st = 1; st < LG; ++st){
for(int i = 0 ; i + (1 << (st-1)) < n - 1; ++i){
sparse[i][st] = min(sparse[i][st-1], sparse[i+(1<<(st-1))][st-1]);
}
}
// cerr << "ok \n";
// cerr << "ST " << len(st) << '\n';
// for(auto u : st)
// cerr << u << ' ';
// cerr << '\n';
/// so what are we doing now?
/// we want to find splitting strings into increasing blocks, okay
vector < vector < pair < int , int > > > blocks(n);
vector < int > pointer(n);
for(int i = 0 ; i < n; ++i){
/// spliting and adding questions???
int l = 0, r = 0;
for(int x = 1; x < len(st[i]); ++x){
if(st[i][x] < st[i][x - 1]){
/// we have a block [l,r]
blocks[i].pb({l , r});
l = r = x;
}else{
r++;
}
}
blocks[i].pb({l , r});
}
// cerr << "2\n";
// /// okay what now
// /// SORTED REVERSED
// cout << " SORTED REVERSED\n";
// for(auto u : rev)
// cout << u.fi << '\n';
// cout << endl;
// cout << " JUST SORTEED \n";
// for(auto u : st)
// cout << u << endl;
// cout << endl;
// cerr << " BLOCKS \n";
// for(int x = 0 ; x < n; ++x){
// cout << " el " << x << endl;
// for(auto lines : blocks[x])
// cout << lines.fi << ' ' << lines.se << '\n';
// cout << endl;
// }
for(int pref = 0 ; pref < len(st[0]); ++pref){
/// what are we doing?
int start = 0;
// cerr << "4\n" << pref << '\n';
while(start < n){
// cerr << "in while\n";
int en = start;
while(en + 1 < n && lcp_st[en] >= pref)
++en;
/// now our class is from l to r
/// for each string in class we want answer queries about blocks
/// firstly put evertything in a fen
for(int x = start; x <= en; ++x){
modify(id_in_suff[x] , cnt[x]);
}
// cerr << "wtf \ n";
/// okay
for(int x = start; x <= en; ++x){
while(pointer[x] < len(blocks[x]) && blocks[x][pointer[x]].fi < pref)
++pointer[x];
if(pointer[x] == len(blocks[x]))
continue;
if(pref == blocks[x][pointer[x]].fi){
/// we want to answer the query, how much string we have wich has common suffix with len >= len(st[0]) - 1 - pref[i].se;
int want = len(st[0])-1-blocks[x][pointer[x]].se;
int id = id_in_suff[x];
int L,R;
L=0,R=id;
while(L != R){
// cerr << " dix 1\n";
int mid = (L + R) >> 1;
int LCP = get_mn(mid, id-1);
if(LCP < want){
if(L + 1 == R)
L = R;
else
L = mid;
}else
R = mid;
}
/// so yeah
int l,r;
l = R;
L = id, R = n - 1;
while(L != R){
// cerr << " dix 2\n";
int mid = (L + R) >> 1;
int LCP = get_mn(id, R-1);
if(LCP >= want){
if(L + 1 == R)
L = R;
else
L = mid;
}else
R = mid;
}
int LCP = get_mn(id, R-1);
if(LCP >= want)
++R;
--R;
r = R;
// cerr << " for " << x << ' ' << pref << " " << l << ' ' << r << ' ' << blocks[x][pointer[x]].se << ' ' << want << endl;
/// so total line is [l,r]
one += 1ll * (get_line(l, r) - cnt[x]) * cnt[x];
}
}
for(int x = start; x <= en; ++x){
modify(id_in_suff[x] , -cnt[x]);
}
start = en + 1;
}
}
// cerr << "3\n";
ll total=0;
for(auto u : cnt)
total += u;
total = (total) * (total - 1) / 2;
ll two = total - one - zero;
answer += two * 2 + one * 1;
// cerr << " GROUP \n";
// for(int i = 0 ; i < len(st); ++i){
// cerr << st[i] << ' ' << cnt[i] << '\n';
// }
// cerr << " lol \n";
// cerr << total << endl;
// cerr << "one " << one << '\n';
// cerr << "zero " << zero << '\n';
// cerr << "two " << two << '\n';
}
signed main(){
int n;
ios_base::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);
cin >> n;
vector < string > s(n);
for(auto &i : s)
cin >> i;
map < vector < int > , vector < string > > eqval;
for(auto i : s){
vector < int > cnt(26);
for(auto u : i)
cnt[u-'a']++;
eqval[cnt].pb(i);
}
/// f(a,b) = 1337
ll answer = 0;
for(auto u : eqval){
answer += 1ll * len(u.se) * (n - len(u.se));
}
answer /= 2;
answer *= 1337;
/// going inside
for(auto u : eqval){
solve_for_class(u.se, answer);
}
cout << answer << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
const int inf = 1e9;
const ll inf64 = 1e18;
bool check(string a, string b) {
int n = (int) a.size();
int l = 0, r = 0;
while (l < n && a[l] == b[l]) l++;
while (r < n && a[n - 1 - r] == b[n - 1 - r]) r++;
if (l + r >= n) return true;
int ql = l, qr = n - r - 1;
int oka = 1, okb = 1;
for (int i = ql; i < qr; i++) {
if (a[i] < a[i + 1]) oka = 0;
if (b[i] < b[i + 1]) okb = 0;
}
return oka || okb;
}
ll solveNNS(vector<string> a) {
int n = (int) a.size();
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
int cost = 2;
if (check(a[i], a[j]))
cost = 1;
res += cost;
}
}
return res;
}
const int A = 26;
struct Trie {
struct Node {
vector<int> nxt = vector<int>(A, -1);
int par = -1;
int tin = 0;
int tout = 0;
};
vector<Node> t = {Node()};
int timer = 0;
int add_string(const string& s) {
int v = 0;
for (char c : s) {
c -= 'a';
if (t[v].nxt[c] == -1) {
t[v].nxt[c] = (int) t.size();
t.emplace_back();
t.back().par = v;
}
v = t[v].nxt[c];
}
return v;
}
int get(const string& s) {
int v = 0;
for (char c : s) {
c -= 'a';
v = t[v].nxt[c];
}
return v;
}
void dfs(int v) {
t[v].tin = timer++;
for (int c = 0; c < A; c++) {
int to = t[v].nxt[c];
if (to == -1)
continue;
dfs(to);
}
t[v].tout = timer++;
}
void build() {
dfs(0);
}
};
struct pt {
int x = 0;
int y = 0;
};
ll solveNSS(vector<string> a) {
sort(a.begin(), a.end());
for (int i = 0; i + 1 < (int) a.size(); i++)
assert(a[i] != a[i + 1]);
if (a.empty()) return 0;
int n = (int) a.size();
int k = (int) a[0].size();
ll res = 1ll * n * (n - 1);
ll cnt = 0;
Trie pref, suff;
vector<string> b = a;
for (int i = 0; i < n; i++) {
pref.add_string(a[i]);
reverse(b[i].begin(), b[i].end());
suff.add_string(b[i]);
}
pref.build();
suff.build();
vector<pt> ps(n);
for (int i = 0; i < n; i++) {
int u = pref.get(a[i]);
int v = suff.get(b[i]);
ps[i].x = pref.t[u].tin;
ps[i].y = suff.t[v].tin;
if (i > 0) assert(ps[i - 1].x <= ps[i].x);
}
vector<tuple<int, int, int, int, int>> recs;
for (int i = 0; i < n; i++) {
int pv = 0, sv = suff.get(b[i]);
// cout << i << " : \n";
int last_lx = 0;
int last_rx = 0;
for (int r = -1, l = 0; l + 1 < k; pv = pref.t[pv].nxt[a[i][l] - 'a'], l++) {
while (r < l) {
sv = suff.t[sv].par;
r++;
}
while (r + 1 < k && a[i][r] >= a[i][r + 1]) {
sv = suff.t[sv].par;
r++;
}
{
int npv = pref.t[pv].nxt[a[i][l] - 'a'];
int lx = pref.t[pv].tin;
int rx = pref.t[npv].tin;
assert(last_lx <= lx); last_lx = lx;
assert(last_rx <= rx); last_rx = rx;
int ly = suff.t[sv].tin;
int ry = suff.t[sv].tout;
int from = 0;
{
int bl = -1, br = i, bm;
while (br - bl > 1) {
bm = (bl + br) >> 1;
if (ps[bm].x <= lx) bl = bm;
else br = bm;
}
from = max(0, bl - 2);
}
for (int j = from; j < i; j++) {
if (lx < ps[j].x && ps[j].x < rx && ly < ps[j].y && ps[j].y < ry)
cnt++;
}
}
}
}
// cout << "cnt = " << cnt << "\n";
res -= cnt;
return res;
}
const int SQRT = (int) sqrt(2e5);
ll fast(int n, vector<string> a) {
vector<string> b(n);
for (int i = 0; i < n; i++) {
b[i] = a[i];
sort(b[i].begin(), b[i].end());
}
vector<int> perm(n);
for (int i = 0; i < n; i++)
perm[i] = i;
sort(perm.begin(), perm.end(), [&](int i, int j) {
return b[i] < b[j];
});
ll add = 0, res = 0;
for (int it = 0; it < n; it++) {
int jit = it;
vector<string> group;
while (jit < n && b[perm[it]] == b[perm[jit]]) {
group.push_back(a[perm[jit]]);
jit++;
}
jit--;
add += 1ll * (int) group.size() * (n - (int) group.size());
res += n < SQRT ? solveNNS(group) : solveNSS(group);
// res += solveNSS(group);
it = jit;
}
assert(add % 2 == 0);
res += 1337ll * add / 2;
return res;
}
ll slow(int n, vector<string> a) {
sort(a.begin(), a.end());
ll res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
{
string aa = a[i], bb = a[j];
sort(aa.begin(), aa.end());
sort(bb.begin(), bb.end());
if (aa != bb) {
res += 1337;
continue;
}
}
int l = 0, r = 0;
int sz = (int) a[i].size();
while (l < sz && a[i][l] == a[j][l]) l++;
while (r < sz && a[i][sz - 1 - r] == a[j][sz - 1 - r]) r++;
assert(l + r < sz);
int ql = l, qr = sz - r - 1;
int ok = 1;
for (int q = ql; q < qr; q++) {
if (a[i][q] < a[i][q + 1]) ok = 0;
}
if (ok) res++;
else res += 2;
}
}
return res;
}
void work() {
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
for (char& c : a[i])
c = 25 - (c - 'a') + 'a';
}
ll res = fast(n, a);
cout << res << "\n";
}
string gen_string(mt19937& rnd, int len, const int MAXC) {
string res(len, '?');
for (char& c : res)
c = rnd() % MAXC + 'a';
return res;
}
void test() {
mt19937 rnd(42);
const int MAXN = 10;
const int MAXL = 5;
const int MAXC = 3;
while (1) {
int n = rnd() % MAXN + 1;
int m = rnd() % MAXL + 1;
vector<string> a(n);
for (int i = 0; i < n; i++) {
if (i == 0 || rnd() % 2)
a[i] = gen_string(rnd, m, MAXC);
else {
a[i] = a[rnd() % i];
shuffle(a[i].begin(), a[i].end(), rnd);
}
}
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
n = (int) a.size();
shuffle(a.begin(), a.end(), rnd);
ll fs = fast(n, a);
ll sl = slow(n, a);
if (fs == sl) {
cout << "OK(" << fs << ")" << endl;
} else {
cout << "WA\n";
cout << "exp = " << sl << "\n";
cout << "fnd = " << fs << "\n";
cout << n << "\n";
for (int i = 0; i < n; i++)
cout << a[i] << "\n";
break;
}
}
}
int main() {
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
work();
// test();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
const int K=5900;
mt19937 gen(chrono::steady_clock::now().time_since_epoch().count());
auto rng=[&](int l,int r)->int{return uniform_int_distribution<int>(l,r)(gen);};
const ll mod=1000000007;
array<ll,2> p={rng(26,135),rng(26,135)};
if(p[0]==p[1]) p[1]++;
auto add=[&](ll a,ll b)->ll{return (a+b)%mod;};
auto sub=[&](ll a,ll b)->ll{return (a-b+mod)%mod;};
auto mul=[&](ll a,ll b)->ll{return (a*b)%mod;};
int n;
cin >> n;
vector<string> s(n+1);
for(int i=1;i<=n;i++)
{
cin >> s[i];
s[i]="$"+s[i];
}
int sz=(int)s[1].size()-1;
vector<array<ll,2>> pw(sz+1,{1,1});
for(int i=1;i<=sz;i++) for(int z=0;z<2;z++) pw[i][z]=mul(pw[i-1][z],p[z]);
vector<vector<array<ll,2>>> h(n+1,vector<array<ll,2>>(sz+1,{0,0}));
for(int i=1;i<=n;i++) for(int j=1;j<=sz;j++) for(int z=0;z<2;z++) h[i][j][z]=add(mul(h[i][j-1][z],p[z]),s[i][j]-'a');
auto g=[&](int i,int l,int r)->array<ll,2>{return {sub(h[i][r][0],mul(h[i][l-1][0],pw[r-(l-1)][0])),sub(h[i][r][1],mul(h[i][l-1][1],pw[r-(l-1)][1]))};};
vector<vector<int>> inc(n+1,vector<int>(sz+1,0));
for(int i=1;i<=n;i++)
{
int l=1;
while(l<=sz)
{
int r=l;
while(r+1<=sz&&s[i][r]<=s[i][r+1]) r++;
for(int j=l;j<=r;j++) inc[i][j]=r;
l=r+1;
}
}
vector<pair<array<int,26>,int>> cnt(n+1);
for(int i=1;i<=n;i++)
{
cnt[i].first.fill(0);
cnt[i].second=i;
for(int j=1;j<=sz;j++) cnt[i].first[s[i][j]-'a']++;
}
ll res=0;
vector<vector<int>> groups;
vector<int> tmp;
sort(cnt.begin(),cnt.end());
for(int i=1;i<=n;i++)
{
tmp.push_back(cnt[i].second);
if((i<n&&cnt[i].first!=cnt[i+1].first)||i==n)
{
res+=(ll(tmp.size())*(i-tmp.size())*1337);
groups.push_back(tmp);
tmp.clear();
}
}
if(n<=K)
{
for(vector<int> &group:groups)
{
for(int a:group)
{
for(int b:group)
{
if(a>=b) continue;
int l=0,r=sz;
while(l<r-1)
{
int m=(l+r)/2;
if(h[a][m]==h[b][m]) l=m;
else r=m;
}
int one=r;
l=1,r=sz+1;
while(l<r-1)
{
int m=(l+r)/2;
if(g(a,m,sz)==g(b,m,sz)) r=m;
else l=m;
}
int two=l;
if(inc[a][one]>=two||inc[b][one]>=two) res++;
else res+=2;
}
}
}
}
else
{
vector<vector<array<ll,2>>> halpha(sz+1,vector<array<ll,2>>(26,{0,0}));
for(int i=1;i<=sz;i++) for(int j=0;j<26;j++) for(int z=0;z<2;z++) halpha[i][j][z]=add(mul(halpha[i-1][j][z],p[z]),j);
auto hsort=[&](array<int,26> &c)->array<ll,2>
{
array<ll,2> t={0,0};
for(int i=0;i<26;i++) for(int z=0;z<2;z++) t[z]=add(mul(t[z],pw[c[i]][z]),halpha[c[i]][i][z]);
return t;
};
vector<vector<array<ll,2>>> opt(n+1);
for(int i=1;i<=n;i++)
{
vector<array<ll,2>> now;
for(int l=1;l<=sz;l++)
{
array<int,26> c;
c.fill(0);
for(int r=l;r<=sz;r++)
{
c[s[i][r]-'a']++;
array<ll,2> t={0,0};
for(int z=0;z<2;z++)
{
t[z]=h[i][l-1][z];
t[z]=add(mul(t[z],pw[r-l+1][z]),hsort(c)[z]);
t[z]=add(mul(t[z],pw[sz-r][z]),g(i,r+1,sz)[z]);
}
now.push_back(t);
}
}
sort(now.begin(),now.end());
for(int j=0;j<(int)now.size();j++) if(j==0||now[j]!=now[j-1]) opt[i].push_back(now[j]);
}
for(vector<int> &group:groups)
{
int gsz=group.size();
res+=(2*ll(gsz)*(gsz-1)/2);
vector<array<ll,2>> v;
for(int a:group) for(array<ll,2> t:opt[a]) v.push_back(t);
sort(v.begin(),v.end());
for(int a:group)
{
res-=(upper_bound(v.begin(),v.end(),h[a][sz])-lower_bound(v.begin(),v.end(),h[a][sz])-1);
}
}
}
cout << res << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define loop(i, l, r) for(int i = (int) l; i <= (int) r; i++)
#define rloop(i, r, l) for(int i = (int) r; i >= (int) l; i--)
#define vi vector<int>
#define ii pair<int, int>
#define eb emplace_back
#define all(x) begin(x), end(x)
#define fi first
#define se second
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define rand rng
#define endl '\n'
#define sp ' '
#define int long long
const int maxN = 4e5 + 5, mod = 1e9 + 7, p = 31;
int lg2[maxN];
int N, M;
int ans;
string S[maxN];
int euler[maxN];
vector<int> r[maxN];
int e[maxN];
int eucnt;
int spa[20][maxN];
void prepsparse(){
loop(bit, 1, 20){
int len = 1 << bit;
loop(i, 1, eucnt - len + 1){
spa[bit][i] = min(spa[bit - 1][i], spa[bit - 1][i + len / 2]);
}
}
}
int getmin(int l, int r){
if(l > r) swap(l, r);
int bit = lg2[r - l + 1], len = 1 << bit;
return min(spa[bit][l], spa[bit][r - len + 1]);
}
struct node{
int p, child[26], d = 0, in = 0;
vector<int> list;
node(int p = 0):p(p){
fill(all(child), -1);
}
};
struct trie{
vector<node> T;
trie(){
}
void clear(){
T.clear(); T.eb(node());
eucnt = 0;
}
void insert(int id, bool rev){
string s = S[id];
if(rev) reverse(all(s));
int n = 0;
for(char c: s){
int e = c - 'a';
if(T[n].child[e] == -1){
T[n].child[e] = T.size();
T.eb(node(n));
}
n = T[n].child[e];
}
T[n].list.eb(id);
}
void dfs(int n){
T[n].in = ++eucnt;
spa[0][T[n].in] = T[n].d;
loop(e, 0, 25){
int v = T[n].child[e];
if(v != -1) {
T[v].d = T[n].d + 1;
dfs(v);
spa[0][++eucnt] = T[n].d;
}
}
for(int i: T[n].list){
euler[i] = T[n].in;
}
}
vector<ii> list(int n){
vector<ii> all;
loop(e, 0, 25){
int v = T[n].child[e];
if(v != -1) {
T[v].d = T[n].d + 1;
vector<ii> tmp = list(v);
for(auto t: tmp) all.eb(t);
}
}
for(int i: T[n].list){
all.eb(euler[i], i);
}
sort(all(all));
loop(idx, 0, all.size() - 1){
int i = all[idx].se;
if(r[i][T[n].d]){
int req = M - 1 - r[i][T[n].d];
int num = 0;
int low = 0, high = idx;
while(low < high){
int m = (low + high + 1) / 2;
int j = all[idx - m].se;
int lcs = getmin(euler[i], euler[j]);
if(lcs >= req) low = m;
else high = m - 1;
}
num += low;
low = 0, high = all.size() - 1 - idx;
while(low < high){
int m = (low + high + 1) / 2;
int j = all[idx + m].se;
int lcs = getmin(euler[i], euler[j]);
if(lcs >= req) low = m;
else high = m - 1;
}
num += low;
ans -= 2 * (num - e[i]);
}
}
return all;
}
} pref, suf;
void solve(vector<int> t){
pref.clear();
suf.clear();
for(int i: t){
pref.insert(i, 0); // map node to string, too
suf.insert(i, 1);
}
suf.dfs(0); // map, sparse
prepsparse();
pref.list(0);
}
int gethash(string &s){
int r = 0;
for(char c: s){
r = (r * p + c - 'a') % mod;
}
return r;
}
int getclass(string &s){
int r = 0;
vector<int> cnt(26, 0);
for(char c: s){
cnt[c - 'a']++;
}
loop(i, 0, 25){
r = (r * p + cnt[i]) % mod;
}
return r;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
lg2[1] = 0;
loop(i, 2, maxN - 1){
lg2[i] = lg2[i / 2] + 1;
}
cin >> N;
loop(i, 1, N){
cin >> S[i];
}
M = S[1].length();
vector<ii> cl, el;
loop(i, 1, N){
r[i].resize(M + 1, 0);
loop(j, 0, M - 1){
// cout << "j: " << j << endl;
r[i][j] = j;
while(r[i][j] < M - 1 and S[i][r[i][j] + 1] >= S[i][r[i][j]]) ++r[i][j];
// cout << i << sp << j <<sp << r[i][j] << endl;
j = r[i][j];
}
cl.eb(getclass(S[i]), i);
el.eb(gethash(S[i]), i);
}
sort(all(cl));
sort(all(el));
int sum = N * (N - 1);
loop(i, 0, N - 1){
int j = i, cnt = 1;
while(j + 1 < N and el[j + 1].fi == el[i].fi) {
j++;
++cnt;
}
vector<int> tmp;
loop(k, i, j){
e[cl[k].se] = cnt - 1;
}
ans -= 2 * cnt * (cnt - 1);
i = j;
}
loop(i, 0, N - 1){
int j = i;
while(j + 1 < N and cl[j + 1].fi == cl[i].fi) ++j;
vector<int> tmp;
loop(k, i, j){
tmp.eb(cl[k].se);
}
ans += 2 * tmp.size() * (tmp.size() - 1);
solve(tmp);
sum -= tmp.size() * (tmp.size() - 1);
i = j;
}
ans += sum * 1337;
ans /= 2;
cout << ans;
}
|
#include <bits/stdc++.h>
#define MAX 200010
using namespace std;
const uint64_t base = mt19937_64(chrono::system_clock::now().time_since_epoch().count())();
int n, m, k;
char str[MAX];
bitset<16> dp[MAX][16];
uint64_t get_sh(string s){
sort(s.begin(), s.end());
uint64_t h = 0;
for (auto c: s) h = h * base + c;
return h;
}
inline bool check(int idx1, int idx2, const string& s1, const string& s2, bool small){
int i = 0, j = k - 1;
while (s1[i] == s2[i]) i++;
while (s1[j] == s2[j]) j--;
if (small) return dp[idx1][i][j] | dp[idx2][i][j];
int l, flag1 = 0, flag2 = 0;
for (l = i; l < j && !(flag1 & flag2); l++){
flag1 |= (s1[l + 1] < s1[l]);
flag2 |= (s2[l + 1] < s2[l]);
}
return !(flag1 & flag2);
}
int main(){
int i, j, l;
scanf("%d", &n);
unordered_map<uint64_t, vector<string>> mp;
long long cnt1 = 0, cnt2 = 0, total = (long long)n * (n - 1) / 2;
while(n--){
scanf("%s", str);
auto s = string(str);
auto h = get_sh(s);
mp[h].push_back(s);
}
for (auto it: mp){
auto v = it.second;
sort(v.begin(), v.end());
m = v.size(), k = v[0].length();
long long c1 = 0;
if (k <= 16){
for (i = 0; i < m; i++){
for (j = 0; j < k; j++){
dp[i][j][j] = 1;
for (l = j + 1; l < k; l++){
dp[i][j][l] = dp[i][j][l - 1] & (v[i][l] >= v[i][l - 1]);
}
}
}
for (i = 0; i < m; i++){
for (j = i + 1; j < m; j++){
c1 += check(i, j, v[i], v[j], true);
}
}
}
else{
for (i = 0; i < m; i++){
for (j = i + 1; j < m; j++){
c1 += check(i, j, v[i], v[j], false);
}
}
}
cnt1 += c1;
cnt2 += ((long long)m * (m - 1) / 2 - c1);
}
long long res = 1337 * (total - cnt1 - cnt2) + cnt1 + cnt2 * 2;
printf("%lld\n", res);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.