text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long long ma, n, i, j, temp;
long long mi = 1000LL * 1000LL * 1000LL * 1000LL * 1000LL * 1000LL;
int main() {
cin >> n;
for (i = 1; i * i * i <= n; i++)
if (n % i == 0)
for (j = i; j * j <= n / i; j++)
if ((n / i) % j == 0) {
temp = (n / i) / j;
ma = max(ma, (i + 2) * (j + 2) * (temp + 1));
ma = max(ma, (i + 2) * (j + 1) * (temp + 2));
ma = max(ma, (i + 1) * (j + 2) * (temp + 2));
mi = min(mi, (i + 2) * (j + 2) * (temp + 1));
mi = min(mi, (i + 2) * (j + 1) * (temp + 2));
mi = min(mi, (i + 1) * (j + 2) * (temp + 2));
}
cout << mi - n << " " << ma - n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n;
long long mx = 0;
long long mn = numeric_limits<long long>::max();
cin >> n;
for (long long a = 1; a * a <= n; ++a)
if (n % a == 0) {
long long m = n / a;
for (long long b = 1; b * b <= m; ++b)
if (m % b == 0) {
long long c = m / b;
long long x = (a + 1) * (b + 2) * (c + 2) - n;
long long y = (a + 2) * (b + 1) * (c + 2) - n;
long long z = (a + 2) * (b + 2) * (c + 1) - n;
mn = min(x, min(y, min(z, mn)));
mx = max(x, max(y, max(z, mx)));
}
}
cout << mn << ' ' << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
v.push_back(1);
long long n;
cin >> n;
long long mx = 0, mn = 1000000000000000LL;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
v.push_back(i);
}
}
for (int i = 0; i < v.size(); i++) {
for (int j = i; j < v.size(); j++) {
if (n % ((long long)v[i] * v[j])) continue;
int c = n / ((long long)v[i] * v[j]);
mx = max(mx, (long long)(v[i] + 1) * (v[j] + 2) * (c + 2));
mx = max(mx, (long long)(v[i] + 2) * (v[j] + 1) * (c + 2));
mx = max(mx, (long long)(v[i] + 2) * (v[j] + 2) * (c + 1));
mn = min(mn, (long long)(v[i] + 1) * (v[j] + 2) * (c + 2));
mn = min(mn, (long long)(v[i] + 2) * (v[j] + 1) * (c + 2));
mn = min(mn, (long long)(v[i] + 2) * (v[j] + 2) * (c + 1));
}
}
cout << mn - n << " " << mx - n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> divisor;
int main() {
long long N;
int i, j;
cin >> N;
int bts = (int)sqrt(N);
for (i = 1; i <= bts; i++) {
if (N % i == 0) {
divisor.push_back(i);
if (N / i != i) divisor.push_back(N / i);
}
}
long long maxx = (3LL * 3LL * (N + 1)) - N;
long long minn = maxx;
bts = divisor.size();
long long arr[3];
for (i = 0; i < bts; i++) {
int bantu = N / divisor[i];
for (j = i; j < bts; j++) {
if (bantu % divisor[j]) continue;
arr[0] = divisor[i];
arr[1] = divisor[j];
arr[2] = bantu / divisor[j];
sort(arr, arr + 3);
long long lho = ((arr[0] + 1) * (arr[1] + 2) * (arr[2] + 2)) - N;
if (lho < minn) minn = lho;
}
}
cout << minn << " " << maxx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, a, b, c, v, mins = -1, maxs = -1;
vector<int> d;
int dl;
int main() {
cin >> n;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
d.push_back(i);
d.push_back(n / i);
if (i == n / i) d.pop_back();
}
}
sort(d.begin(), d.end());
dl = d.size();
for (int i = 0; i < dl; i++) {
a = d[i];
m = n / a;
for (int j = 0; j < dl; j++) {
b = d[j];
if (m % b != 0) continue;
c = m / b;
cerr << "a=" << a << "b=" << b << "c=" << c << endl;
v = (a + 1) * (b + 2) * (c + 2) - n;
cerr << "v=" << v << endl;
if (mins == -1)
mins = v;
else
mins = v < mins ? v : mins;
if (maxs == -1)
maxs = v;
else
maxs = v > maxs ? v : maxs;
}
}
cout << mins << " " << maxs << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans1 = 0, ans2, n, i, j, besti, t, k;
cin >> n;
ans2 = (n + 1) * 3 * 3 - n;
ans1 = ans2;
for (i = 1; i * i <= n; i++) {
if (n % i == 0)
for (j = 1; j * j <= n / i; j++) {
besti = n / i;
if (besti % j != 0) continue;
long long tmp = (i + 1) * (j + 2) * (n / (i * j) + 2) - n;
if (ans1 > tmp) {
ans1 = tmp;
t = i, k = j;
}
}
}
cout << ans1 << " " << ans2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, bc, c;
scanf("%d", &n);
long long sol_mx = 0, sol_mn = (long long)1e15;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
bc = n / i;
for (int j = 1; j * j <= bc; ++j)
if (bc % j == 0) {
c = bc / j;
long long p1 = (long long)(c + 1) * (i + 2) * (j + 2);
long long p2 = (long long)(i + 1) * (c + 2) * (j + 2);
long long p3 = (long long)(j + 1) * (c + 2) * (i + 2);
sol_mx = max(max(sol_mx, p1), max(p2, p3));
sol_mn = min(min(sol_mn, p1), min(p2, p3));
}
}
}
printf("%I64d %I64d\n", sol_mn - n, sol_mx - n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long i, q2, w1, w2, e1, e2, a, b, q, n, r, q1, mi, j, r1, r2, t;
int main() {
cin >> a;
mi = 6 * (a + 2);
b = a;
r = powl(a, 1. / 3.);
r++;
for (i = r; i >= 1; i--)
if (b % i == 0) {
a = b / i;
t = sqrtl(a);
for (j = t; j >= 1; j--)
if (a % j == 0) {
q = a / j;
r1 = min(i, min(j, q));
r2 = max(i, max(j, q));
q = i + j + q - (r1 + r2);
q = (r1 + 1) * (r2 + 2) * (q + 2);
mi = min(mi, q);
}
}
q1 = mi - b;
q2 = (b + 1) * 9;
q2 -= b;
if (q1 > q2) swap(q1, q2);
cout << q1 << " " << q2 << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m1, m2, c, m;
int main() {
cin >> n;
m1 = 1e+17;
m2 = 0;
for (int i = 1; i * i * i <= n; i++)
if (n % i == 0) {
m = n / i;
for (int j = 1; m >= j * j; j++)
if (m % j == 0) {
c = m / j;
if ((c + 2) * (i + 1) * (j + 2) < m1)
m1 = (c + 2) * (i + 1) * (j + 2);
if ((c + 2) * (i + 1) * (j + 2) > m2)
m2 = (c + 2) * (i + 1) * (j + 2);
if ((c + 1) * (i + 2) * (j + 2) < m1)
m1 = (c + 1) * (i + 2) * (j + 2);
if ((c + 1) * (i + 2) * (j + 2) > m2)
m2 = (c + 1) * (i + 2) * (j + 2);
}
}
cout << m1 - n << " " << m2 - n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long Min = 100000000000000;
long long Max = -1;
for (long long a = 1; a * a * a <= n; ++a)
if (n % a == 0) {
for (long long b = a; b * b <= n / a; ++b)
if ((n / a) % b == 0) {
long long c = n / a / b;
Min = min(Min, min((a + 1) * (b + 2) * (c + 2) - n,
min((a + 2) * (b + 1) * (c + 2) - n,
(a + 2) * (b + 2) * (c + 1) - n)));
Max = max(Max, max((a + 1) * (b + 2) * (c + 2) - n,
max((a + 2) * (b + 1) * (c + 2) - n,
(a + 2) * (b + 2) * (c + 1) - n)));
}
}
cout << Min << ' ' << Max << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> v;
long long mx = -1, mn = -1;
for (long long i = 1; i * i <= n; i++)
if (n % i == 0) {
v.push_back(i);
v.push_back(n / i);
}
sort((v).begin(), (v).end());
for (int i = 0; i < (int)(v).size(); i++) {
long long rest = n / v[i];
for (int j = 0; j < (int)(v).size(); j++)
if (rest % v[j] == 0) {
long long a = v[i] + 1;
long long b = v[j] + 2;
long long c = rest / v[j] + 2;
mx = max(mx, a * b * c - (a - 1) * (b - 2) * (c - 2));
if (mn == -1) mn = a * b * c - (a - 1) * (b - 2) * (c - 2);
mn = min(mn, a * b * c - (a - 1) * (b - 2) * (c - 2));
}
}
cout << mn << " " << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x;
cin >> n;
long long i, j, k, ans = 9 * n + 9, mx = 0;
for (i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
x = n / i;
for (j = 1; j <= sqrt(x); j++) {
if (x % j == 0) {
k = x / j;
ans = min(ans, ((i + 1) * (j + 2) * (k + 2)));
ans = min(ans, ((i + 2) * (j + 1) * (k + 2)));
ans = min(ans, ((i + 2) * (j + 2) * (k + 1)));
mx = max(mx, ((i + 2) * (j + 2) * (k + 1)));
mx = max(mx, ((i + 2) * (j + 1) * (k + 2)));
mx = max(mx, ((i + 1) * (j + 2) * (k + 2)));
}
}
}
}
cout << ans - n << " " << mx - n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int main() {
long long n;
cin >> n;
long long minv = 3 * 3 * (n + 1);
for (long long i = 1; i <= 100000; i++) {
if (n % i == 0) {
for (long long j = 1; j <= 100000; j++) {
if (n % (i * j) == 0) {
long long c = n / i / j;
minv = min(minv, (min(min(i, j), c) + 1) * (max(max(i, j), c) + 2) *
(i + j + c - min(min(i, j), c) -
max(max(i, j), c) + 2));
}
}
}
}
cout << minv - n << " " << 3 * 3 * (n + 1) - n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long minans = 1e+15, maxans = 0;
int n;
scanf("%d", &n);
for (int i = 1; i * i <= n; i++) {
if (n % i != 0) continue;
int a = n / i;
for (int j = 1; j * j <= a; j++) {
if (a % j != 0) continue;
int b = j, c = a / j;
long long num = ((long long)(i + 1)) * (b + 2) * (c + 2) - n;
if (num < minans) minans = num;
if (num > maxans) maxans = num;
num = ((long long)(i + 2)) * (b + 1) * (c + 2) - n;
if (num < minans) minans = num;
if (num > maxans) maxans = num;
num = ((long long)(i + 2)) * (b + 2) * (c + 1) - n;
if (num < minans) minans = num;
if (num > maxans) maxans = num;
}
}
printf("%lld %lld\n", minans, maxans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 62;
long long min_n, max_n, n;
void func(long long a, long long m) {
for (long long b = 1LL; b * b <= m; b++) {
if (m % b == 0) {
long long c = m / b;
long long res = (a + 1LL) * (b + 2LL) * (c + 2LL);
if (min_n > res) min_n = res;
if (max_n < res) max_n = res;
}
}
}
int main() {
cin >> n;
min_n = INF, max_n = 0;
for (long long a = 1LL; a * a <= n; a++) {
if (n % a == 0) {
func(a, n / a);
func(n / a, a);
}
}
cout << min_n - n << ' ' << max_n - n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
int main(int argc, char *argv[]) {
long long n;
cin >> n;
long long ret1 = (1LL << 60);
long long ret2 = 0;
for (long long x = 1; x * x <= n; ++x) {
if (n % x) continue;
long long m = n / x;
for (long long y = 1; y * y <= m; ++y) {
if ((n / x) % y) continue;
long long z = m / y;
long long a = x + 1;
long long b = y + 2;
long long c = z + 2;
ret1 = min(a * b * c - n, ret1);
ret2 = max(a * b * c - n, ret2);
b = x + 2;
c = z + 2;
a = y + 1;
ret1 = min(a * b * c - n, ret1);
ret2 = max(a * b * c - n, ret2);
a = z + 1;
b = x + 2;
c = y + 2;
ret1 = min(a * b * c - n, ret1);
ret2 = max(a * b * c - n, ret2);
}
}
cout << ret1 << " " << ret2 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long solve(long long x, long long y, long long z) {
vector<long long> vec;
vec.push_back(x);
vec.push_back(y);
vec.push_back(z);
sort(vec.begin(), vec.end());
return (long long)((vec[0] + 1) * (vec[1] + 2) * (vec[2] + 2));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
long long limit = ceil(pow(n, 0.5));
long long x1, x2;
long long mini, maxi;
maxi = 3 * 3 * (n + 1) - n;
mini = maxi;
for (int i = 1; i <= limit; ++i) {
x1 = i;
if (n % x1 != 0) continue;
for (int j = i; j <= limit; ++j) {
x2 = j;
if (n % (x1 * x2) != 0) continue;
long long ans = solve(x1, x2, n / (x1 * x2)) - n;
mini = min(mini, ans);
}
}
cout << mini << " " << maxi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m[2], m2, mc[1000];
map<string, int> ms;
int k;
bool v[520][520];
int main() {
long long int n;
cin >> n;
long long int ma = 0;
long long int mi = LONG_LONG_MAX;
for (long long int a = 1; a * a * a <= n; a++) {
if (n % a == 0) {
for (long long int b = a; b * b <= n / a; b++) {
if ((n / a) % b == 0) {
long long int c = (n / a) / b;
ma = max(ma, (a + 1) * (b + 2) * (c + 2));
mi = min(mi, (a + 1) * (b + 2) * (c + 2));
ma = max(ma, (a + 2) * (b + 1) * (c + 2));
mi = min(mi, (a + 2) * (b + 1) * (c + 2));
ma = max(ma, (a + 2) * (b + 2) * (c + 1));
mi = min(mi, (a + 2) * (b + 2) * (c + 1));
}
}
}
}
cout << mi - n << " " << ma - n << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long minx = 0x3f3f3f3f3f3f3f3f;
long long maxx = 0;
long long n;
cin >> n;
long long temp;
for (long long i = 1; i * i * i <= n; i++) {
if (n % i == 0) {
for (long long j = 1; j * j <= n / i; j++) {
if ((n / i) % j == 0) {
long long a = i, b = j, c = n / i / j;
temp = (a + 1) * (b + 2) * (c + 2);
maxx = max(temp, maxx);
minx = min(temp, minx);
temp = (b + 1) * (a + 2) * (c + 2);
maxx = max(temp, maxx);
minx = min(temp, minx);
temp = (c + 1) * (a + 2) * (b + 2);
maxx = max(temp, maxx);
minx = min(temp, minx);
}
}
}
}
cout << minx - n << " " << maxx - n << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 62;
long long min_n, max_n, n;
void func(long long a, long long m) {
for (long long b = 1LL; b * b <= m; b++) {
if (m % b == 0) {
long long c = m / b;
long long res = (a + 1LL) * (b + 2LL) * (c + 2LL);
if (min_n > res) min_n = res;
if (max_n < res) max_n = res;
}
}
}
int main() {
cin >> n;
min_n = INF, max_n = 0;
for (long long a = 1LL; a * a <= n; a++) {
if (n % a == 0) {
func(a, n / a);
func(n / a, a);
}
}
cout << min_n - n << ' ' << max_n - n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
long long mn = 1e16, mx = -1e16;
for (int i = 1; i * i * i <= n; ++i) {
if (n % i != 0) continue;
for (int j = i; i * j * j <= n; ++j) {
if ((n / i) % j != 0) continue;
mn = min(mn, (i + 2ll) * (j + 2) * (n / i / j + 1));
mx = max(mx, (i + 2ll) * (j + 2) * (n / i / j + 1));
mn = min(mn, (i + 1ll) * (j + 2) * (n / i / j + 2));
mx = max(mx, (i + 1ll) * (j + 2) * (n / i / j + 2));
}
}
printf("%lld %lld\n", mn - n, mx - n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a = 999999999999999999, n;
cin >> n;
for (long long i = 1; i * i * i <= n; ++i) {
if (n % i) continue;
for (long long j = i; i * j * j <= n; j++)
if ((n / i) % j == 0) {
int k = n / i / j;
a = min(a, (i + 1) * (j + 2) * (k + 2) - n);
}
}
cout << a << ' ' << 8 * n + 9;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, ans = 1000000000000000000;
cin >> n;
for (int a = 1; a * a * a <= n; ++a) {
if (n % a == 0) {
b = n / a;
for (int b = a; b * b <= n / a; ++b) {
if ((n / a) % b == 0) {
c = n / (a * b);
ans = min((a + 1) * (b + 2) * (c + 2), ans);
ans = min((b + 1) * (a + 2) * (c + 2), ans);
ans = min((c + 1) * (b + 2) * (a + 2), ans);
}
}
}
}
cout << ans - n << " " << (n + 1) * 3 * 3 - n;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
while (cin >> n) {
unsigned long long maxc = 0, minc = 1844674407370955161;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
long long bc = n / i;
for (long long j = 1; j * j <= bc; j++) {
if (bc % j == 0) {
int k = bc / j;
if ((i + 1) * (j + 2) * (k + 2) > maxc)
maxc = (i + 1) * (j + 2) * (k + 2);
if ((i + 2) * (j + 1) * (k + 2) > maxc)
maxc = (i + 2) * (j + 1) * (k + 2);
if ((i + 2) * (j + 2) * (k + 1) > maxc)
maxc = (i + 2) * (j + 2) * (k + 1);
if ((i + 1) * (j + 2) * (k + 2) < minc)
minc = (i + 1) * (j + 2) * (k + 2);
if ((i + 2) * (j + 1) * (k + 2) < minc)
minc = (i + 2) * (j + 1) * (k + 2);
if ((i + 2) * (j + 2) * (k + 1) < minc)
minc = (i + 2) * (j + 2) * (k + 1);
}
}
}
}
cout << minc - n << " " << maxc - n << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long x = -1, y = -1;
for (long long a = 1; a * a <= n; a++) {
if (n % a == 0) {
long long m = n / a;
for (long long b = a; b * b <= m; b++) {
if (m % b == 0) {
long long c = m / b;
vector<long long> v(3);
v[0] = a;
v[1] = b;
v[2] = c;
sort(v.begin(), v.end());
do {
long long cur = (v[0] + 1) * (v[1] + 2) * (v[2] + 2);
if (x == -1)
x = cur;
else
x = min(x, cur);
if (y == -1)
y = cur;
else
y = max(y, cur);
} while (next_permutation(v.begin(), v.end()));
}
}
}
}
cout << x - n << " " << y - n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> delit;
int l = sqrt(double(n));
for (int i = 1; i <= l; i++) {
if (n % i == 0) {
delit.push_back(i);
delit.push_back(n / i);
}
}
sort(delit.begin(), delit.end());
long long mx = 0, mn = (long long)1e18;
for (int i = 0; i < delit.size(); i++) {
for (int j = 0; j < delit.size(); j++) {
if (i != j) {
long long a = delit[i];
long long b = delit[j];
long long c;
if (a * b <= n)
c = n / a / b;
else
break;
if (a * b * c != n) continue;
long long V = (a + 1) * (b + 2) * (c + 2);
if (V < mn) mn = V;
if (V > mx) mx = V;
V = (a + 2) * (b + 1) * (c + 2);
if (V < mn) mn = V;
if (V > mx) mx = V;
V = (a + 2) * (b + 2) * (c + 1);
if (V < mn) mn = V;
if (V > mx) mx = V;
}
}
}
cout << mn - n << " " << mx - n;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 41, P = 1000000007;
int n, p[maxn], base[maxn], f[5100];
int fact[maxn], C[maxn][maxn], pw[maxn][maxn], vis[maxn];
vector<int> len, cnt, sub[5100];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]), p[i]--;
}
auto init = [&]() {
vector<int> V;
for (int i = 0; i < n; i++) if (!vis[i]) {
int len = 0;
for (int j = i; !vis[j]; j = p[j]) vis[j] = 1, len++;
V.push_back(len);
}
sort(V.begin(), V.end());
for (int i = 0, j; i < V.size(); i = j) {
for (j = i; j < V.size() && V[i] == V[j]; j++);
len.push_back(V[i]), cnt.push_back(j - i);
}
for (int i = base[0] = 1; i <= len.size(); i++) {
base[i] = base[i - 1] * (cnt[i - 1] + 1);
}
for (int i = fact[0] = C[0][0] = 1; i <= n; i++) {
fact[i] = 1LL * i * fact[i - 1] % P;
for (int j = C[i][0] = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
}
}
for (int S = 0; S < base[len.size()]; S++) {
function<void(int, int)> dfs = [&](int pos, int T) {
if (pos == len.size()) {
if (T) sub[S].push_back(T); return;
}
for (int i = 0; i <= S / base[pos] % (cnt[pos] + 1); i++) {
dfs(pos + 1, T + i * base[pos]);
}
};
dfs(0, 0);
}
};
auto solve = [&]() {
for (int i = 0; i < n; i++) {
pw[i][0] = 1;
for (int j = 0; j <= i; j++) {
pw[i][1] = (pw[i][1] + 1LL * C[i][j] * fact[j] % P * fact[n - j - 1]) % P;
}
for (int j = 2; j <= n; j++) {
pw[i][j] = 1LL * pw[i][j - 1] * pw[i][1] % P;
}
}
for (int S = f[0] = 1; S < base[len.size()]; S++) {
for (int T : sub[S]) {
int s1 = 0, s2 = 0, s3 = 0;
int coef = 1;
for (int i = 0; i < len.size(); i++) {
int x = S / base[i] % (cnt[i] + 1);
int y = T / base[i] % (cnt[i] + 1);
s1 += len[i] * y, s2 += len[i] * (x - y), s3 += y;
coef = 1LL * coef * C[x][y] % P;
}
if (!(s3 & 1)) coef = P - coef;
f[S] = (f[S] + 1LL * pw[s2][s1] * f[S - T] % P * coef) % P;
}
}
};
init(), solve();
printf("%d\n", f[base[len.size()] - 1]);
return 0;
} |
/*
{
######################
# Author #
# Gary #
# 2021 #
######################
*/
#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
#define check_min(a,b) a=min(a,b)
#define check_max(a,b) a=max(a,b)
using namespace std;
//inline int read(){
// int x=0;
// char ch=getchar();
// while(ch<'0'||ch>'9'){
// ch=getchar();
// }
// while(ch>='0'&&ch<='9'){
// x=(x<<1)+(x<<3)+(ch^48);
// ch=getchar();
// }
// return x;
//}
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
/*}
*/
const int MAXN=44;
int fa[MAXN];
map<mp,int> M;
vector<vector<int> > allv;
int n,a[MAXN];
int root(int x){
if(fa[x]==x) return x;
return root(fa[x]);
}
int val[44];
mp myhash(vector<int> v){
mp ret=II(666,233);
int mul1,mul2,mod1,mod2;
mul1=1e9+7;
mod1=19260817;
mul2=1e9+3;
mod2=66662333;
for(auto it:v){
ret.FIR=1ll*ret.FIR*mul1%mod1;
ret.SEC=1ll*ret.SEC*mul2%mod2;
(ret.FIR+=val[it])%=mod1;
(ret.SEC+=val[it])%=mod2;
}
return ret;
}
int id(vector<int> v){
return M[myhash(v)];
}
vector<mp> v;
const int MOD=1e9+7;
int fact[MAXN],ifact[MAXN];
vector<int> tonow;
int Cnt=0;
void dfs(int now){
if(now==v.size()){
allv.PB(tonow);
M[myhash(tonow)]=++Cnt;
return ;
}
rb(i,0,v[now].SEC){
tonow.PB(i);
dfs(now+1);
tonow.POB();
}
}
LL quick(LL A,LL B){
if(B==0) return 1;
LL tmp=quick(A,B>>1);
tmp*=tmp;
tmp%=MOD;
if(B&1)
tmp*=A,tmp%=MOD;
return tmp;
}
int inv(int x){
return quick(x,MOD-2);
}
void add(int & A,int B){
A+=B;
if(A>=MOD) A-=MOD;
}
int c(int A,int B){
return 1ll*fact[A]*ifact[B]%MOD*ifact[A-B]%MOD;
}
struct state{
int to,pre,sum,k;
bool operator < (const state &oth) const {
return II(II(to,pre),II(sum,k))<II(II(oth.to,oth.pre),II(oth.sum,oth.k));
}
bool operator == (const state &oth) const {
return II(II(to,pre),II(sum,k))==II(II(oth.to,oth.pre),II(oth.sum,oth.k));
}
int getpresum(){
vector<int> V=allv[k-1];
int rest=0;
rep(i,V.size()) rest+=V[i]*v[i].FIR;
return rest-sum;
}
state(){}
state(int A,int B,int C,int D){
to=A,pre=B,sum=C,k=D;
}
};
map<state,int> dp;
void debug(state now,int val){
cout<<"{"<<now.to<<','<<now.sum<<' '<<now.pre<<"___"<<now.k<<'[';
for(auto it:allv[now.k-1]) cout<<it<<',';
cout<<"]:"<<val<<endl;
}
int calc(int have,int len){
int tmp=0;
rb(i,0,have){
(tmp+=1ll*c(have,i)*fact[i]%MOD*fact[n-i-1]%MOD)%=MOD;
}
return quick(tmp,len);
}
int calc(state now){
if(dp.find(now)!=dp.end()) return dp[now];
int to,pre,sum,k;
to=now.to,pre=now.pre,sum=now.sum,k=now.k;
vector<int> nowv,nv;
int nto,npre,nsum,nk;
int presum=now.getpresum();
dp[now]=0;
if(presum+sum==n){
dp[now]=1;
return dp[now];
}
nv=nowv=allv[k-1];
if(to!=v.size()-1){
dp[now]=calc(state(to+1,pre,sum,k));
int i=to+1;
int rst=v[i].SEC-nowv[i];
int one=(calc(presum,v[i].FIR)-calc(presum-pre,v[i].FIR)+MOD)%MOD;
if(pre==0) one=calc(0,v[i].FIR);
rb(j,1,rst){
int tmp=quick(one,j);
tmp=1ll*tmp*c(rst,j)%MOD;
nto=i;
npre=pre;
nsum=sum+j*v[i].FIR;
nv[i]+=j;
nk=id(nv);
nv[i]-=j;
dp[now]+=1ll*tmp*calc(state(nto,npre,nsum,nk))%MOD;
dp[now]%=MOD;
}
}
else
if(sum){
dp[now]+=calc(state(-1,sum,0,k));
dp[now]%=MOD;
}
return dp[now];
}
int main(){
SRAND;
scanf("%d",&n);
fact[0]=1;
rb(i,1,n) fact[i]=1ll*fact[i-1]*i%MOD;
ifact[n]=quick(fact[n],MOD-2);
rl(i,n-1,0) ifact[i]=1ll*(i+1)*ifact[i+1]%MOD;
rep(i,n) val[i]=random(998244853);
rb(i,1,n) scanf("%d",&a[i]);
rb(i,1,n) fa[i]=i;
rb(i,1,n) fa[root(i)]=root(a[i]);
int siz[MAXN]={0};
int cnt[MAXN]={0};
rb(i,1,n) siz[root(i)]++;
rb(i,1,n) if(root(i)==i) cnt[siz[i]]++;
rb(i,1,n) if(cnt[i]) v.PB(II(i,cnt[i]));
dfs(0);
cout<<calc(state(-1,0,0,1));
return 0;
} |
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define pii pair<int,int>
#define pll pair<ll,ll>
#define ldb double
template<typename T>void ckmn(T&a,T b){a=min(a,b);}
template<typename T>void ckmx(T&a,T b){a=max(a,b);}
void rd(int&x){scanf("%i",&x);}
void rd(ll&x){scanf("%lld",&x);}
void rd(char*x){scanf("%s",x);}
void rd(ldb&x){scanf("%lf",&x);}
void rd(string&x){scanf("%s",&x);}
template<typename T1,typename T2>void rd(pair<T1,T2>&x){rd(x.first);rd(x.second);}
template<typename T>void rd(vector<T>&x){for(T&i:x)rd(i);}
template<typename T,typename...A>void rd(T&x,A&...args){rd(x);rd(args...);}
template<typename T>void rd(){T x;rd(x);return x;}
int ri(){int x;rd(x);return x;}
template<typename T>vector<T> rv(int n){vector<T> x(n);rd(x);return x;}
template<typename T>void ra(T a[],int n,int st=1){for(int i=0;i<n;++i)rd(a[st+i]);}
template<typename T1,typename T2>void ra(T1 a[],T2 b[],int n,int st=1){for(int i=0;i<n;++i)rd(a[st+i]),rd(b[st+i]);}
template<typename T1,typename T2,typename T3>void ra(T1 a[],T2 b[],T3 c[],int n,int st=1){for(int i=0;i<n;++i)rd(a[st+i]),rd(b[st+i]),rd(c[st+i]);}
void re(vector<int> E[],int m,bool dir=0){for(int i=0,u,v;i<m;++i){rd(u,v);E[u].pb(v);if(!dir)E[v].pb(u);}}
template<typename T>void re(vector<pair<int,T>> E[],int m,bool dir=0){for(int i=0,u,v;i<m;++i){T w;rd(u,v,w);E[u].pb({v,w});if(!dir)E[v].pb({u,w});}}
const int mod=1e9+7;
int add(int a,int b){a+=b;return a>=mod?a-mod:a;}
void ckadd(int&a,int b){a=add(a,b);}
int sub(int a,int b){a-=b;return a<0?a+mod:a;}
void cksub(int&a,int b){a=sub(a,b);}
int mul(int a,int b){return (ll)a*b%mod;}
void ckmul(int&a,int b){a=mul(a,b);}
int powmod(int x,int k){int ans=1;for(;k;k>>=1,ckmul(x,x))if(k&1)ckmul(ans,x);return ans;}
int inv(int x){return powmod(x,mod-2);}
const int N=42;
int F[N],I[N];
int binom(int n,int k){return mul(F[n],mul(I[k],I[n-k]));}
map<vector<pii>,int> dp;
int DP(vector<pii> cycles){
if(dp.count(cycles))return dp[cycles];
if(cycles.empty())return 1;
int n=0,ways=1;
for(pii cs:cycles)n+=cs.first*cs.second,ways*=cs.second+1;
int ans=0;
for(int mask=1;mask<ways;mask++){
vector<pii> go;
int tmp=mask,cnt=0,now=1,m=0;
for(pii cs:cycles){
int rem=tmp%(cs.second+1);
tmp/=cs.second+1;
if(rem!=cs.second)go.pb({cs.first,cs.second-rem});
ckmul(now,binom(cs.second,rem));
ckmul(now,powmod(F[n-1],rem*cs.first));
m+=rem*cs.first;
cnt+=rem;
}
ckmul(now,mul(powmod(mul(binom(n,m),F[m]),n-m),DP(go)));
if(cnt&1)ckadd(ans,now);
else cksub(ans,now);
}
return dp[cycles]=ans;
}
int p[N],was[N];
int main(){
F[0]=1;for(int i=1;i<N;i++)F[i]=mul(F[i-1],i);
I[0]=I[1]=1;for(int i=2;i<N;i++)I[i]=mul(mod-mod/i,I[mod%i]);
for(int i=1;i<N;i++)ckmul(I[i],I[i-1]);
int n=ri();
ra(p,n);
map<int,int> cycles;
for(int i=1;i<=n;i++)if(!was[i]){
int sz=0;
for(int j=i;!was[j];j=p[j]){
was[j]=1;sz++;
}
cycles[sz]++;
}
printf("%i\n",DP(vector<pii>(cycles.begin(),cycles.end())));
return 0;
} |
#include <bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
constexpr int P = 1000000007;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
std::cin >> n;
std::vector<int> p(n);
for (int i = 0; i < n; i++) {
std::cin >> p[i];
p[i]--;
}
std::vector<int> a;
std::vector<bool> vis(n);
for (int i = 0; i < n; i++) {
if (vis[i]) {
continue;
}
int j = i;
int len = 0;
while (!vis[j]) {
vis[j] = true;
j = p[j];
len++;
}
a.push_back(len);
}
std::sort(a.begin(), a.end());
std::vector<int> len, cnt;
for (int i = 0; i < int(a.size()); ) {
int j = i;
while (j < int(a.size()) && a[i] == a[j]) {
j++;
}
len.push_back(a[i]);
cnt.push_back(j - i);
i = j;
}
int k = len.size();
std::vector<int> pre(k + 1);
pre[0] = 1;
for (int i = 0; i < k; ++i) {
pre[i + 1] = pre[i] * (cnt[i] + 1);
}
std::vector<int> fac(n + 1);
fac[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = i64(fac[i - 1]) * i % P;
}
std::vector<int> dp(pre[k]);
std::vector<std::vector<int>> C(n + 1, std::vector<int>(n + 1));
for (int i = 0; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % P;
}
}
std::vector<std::vector<int>> sub(pre[k]);
for (int mask = 0; mask < pre[k]; mask++) {
std::function<void(int, int)> dfs = [&](int x, int r) {
if (x == k) {
sub[mask].push_back(r);
return;
}
for (int i = 0; i <= mask / pre[x] % (cnt[x] + 1); i++) {
dfs(x + 1, r + pre[x] * i);
}
};
dfs(0, 0);
}
dp[0] = 1;
std::vector<int> val(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
val[i] = (val[i] + i64(C[i][j]) * fac[j] % P * fac[n - j - 1]) % P;
}
}
std::vector<std::vector<int>> pval(n, std::vector<int>(n + 1));
for (int i = 0; i < n; ++i) {
pval[i][0] = 1;
for (int j = 1; j <= n; j++) {
pval[i][j] = i64(pval[i][j - 1]) * val[i] % P;
}
}
for (int mask = 1; mask < pre[k]; mask++) {
std::vector<int> c(k);
for (int i = 0; i < k; i++) {
c[i] = mask / pre[i] % (cnt[i] + 1);
}
for (auto t : sub[mask]) {
if (t == 0) {
continue;
}
int s1 = 0, s2 = 0;
std::vector<int> b(k);
int res = P - 1;
for (int i = 0; i < k; i++) {
b[i] = t / pre[i] % (cnt[i] + 1);
s1 += len[i] * b[i];
s2 += len[i] * (c[i] - b[i]);
res = i64(res) * C[c[i]][b[i]] % P;
if (b[i] % 2 == 1) {
res = P - res;
}
}
res = i64(res) * pval[s2][s1] % P;
dp[mask] = (dp[mask] + i64(res) * dp[mask - t]) % P;
}
}
std::cout << dp[pre[k] - 1] << "\n";
return 0;
} |
#include<bits/stdc++.h>
clock_t __t=clock();
namespace my_std{
using namespace std;
#define pii pair<int,int>
#define fir first
#define sec second
#define MP make_pair
#define rep(i,x,y) for (int i=(x);i<=(y);i++)
#define drep(i,x,y) for (int i=(x);i>=(y);i--)
#define go(x) for (int i=head[x];i;i=edge[i].nxt)
#define templ template<typename T>
#define sz 1555
#define mod 1000000007ll
typedef long long ll;
typedef double db;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
templ inline T rnd(T l,T r) {return uniform_int_distribution<T>(l,r)(rng);}
templ inline bool chkmax(T &x,T y){return x<y?x=y,1:0;}
templ inline bool chkmin(T &x,T y){return x>y?x=y,1:0;}
templ inline void read(T& t)
{
t=0;char f=0,ch=getchar();double d=0.1;
while(ch>'9'||ch<'0') f|=(ch=='-'),ch=getchar();
while(ch<='9'&&ch>='0') t=t*10+ch-48,ch=getchar();
if(ch=='.'){ch=getchar();while(ch<='9'&&ch>='0') t+=d*(ch^48),d*=0.1,ch=getchar();}
t=(f?-t:t);
}
template<typename T,typename... Args>inline void read(T& t,Args&... args){read(t); read(args...);}
char __sr[1<<21],__z[20];int __C=-1,__zz=0;
inline void Ot(){fwrite(__sr,1,__C+1,stdout),__C=-1;}
inline void print(int x)
{
if(__C>1<<20)Ot();if(x<0)__sr[++__C]='-',x=-x;
while(__z[++__zz]=x%10+48,x/=10);
while(__sr[++__C]=__z[__zz],--__zz);__sr[++__C]='\n';
}
void file()
{
#ifdef NTFOrz
freopen("a.in","r",stdin);
#endif
}
inline void chktime()
{
#ifdef NTFOrz
cout<<(clock()-__t)/1000.0<<'\n';
#endif
}
#ifdef mod
ll ksm(ll x,int y){ll ret=1;for (;y;y>>=1,x=x*x%mod) if (y&1) ret=ret*x%mod;return ret;}
ll inv(ll x){return ksm(x,mod-2);}
#else
ll ksm(ll x,int y){ll ret=1;for (;y;y>>=1,x=x*x) if (y&1) ret=ret*x;return ret;}
#endif
// ll mul(ll x,ll y){ull s=1.0*x/mod*y;ll res=1ull*x*y-s*mod;return (res%mod+mod)%mod;}
}
using namespace my_std;
int n,m;
int cnt[sz],pre[sz],tot[sz],a[sz][44];
ll _fac[sz],fac[sz];
ll tr[44][44];
void init()
{
static int p[sz],vis[sz];
rep(i,1,n) read(p[i]);
rep(i,1,n) if (!vis[i]) { vis[i]=1; int len=1; for (int x=p[i];x!=i;x=p[x]) vis[x]=1,++len; ++cnt[len]; }
m=1; rep(i,1,n) m*=(cnt[i]+1);
pre[1]=1; rep(i,2,n+1) pre[i]=pre[i-1]*(cnt[i-1]+1);
rep(i,0,m-1) { int x=i; rep(k,1,n) tot[i]+=(a[i][k]=x%(cnt[k]+1))*k,x/=(cnt[k]+1); }
_fac[0]=fac[0]=1; rep(i,1,sz-1) _fac[i]=inv(fac[i]=fac[i-1]*i%mod);
rep(i,0,n) rep(k,0,i) (tr[i][1]+=fac[i]*_fac[i-k]%mod*fac[n-k-1]%mod)%=mod;
rep(i,0,n) rep(j,0,n) tr[i][j]=ksm(tr[i][1],j);
}
ll dp[sz][44][44];
int main()
{
file();
read(n); init();
dp[0][0][n+1]=mod-1;
ll ans=0;
auto Go=[&](int s,int i,int j,ll w,int tp)
{
int c=cnt[j]-s/pre[j]%(cnt[j]+1);
rep(l,tp,c) (dp[s+l*pre[j]][i][j+1]+=w*tr[i][l*j]%mod*_fac[l]%mod)%=mod;
};
rep(s,0,m-1) rep(i,0,tot[s]) rep(j,1,n+1) if (dp[s][i][j])
{
ll w=dp[s][i][j];
if (j!=n+1) { Go(s,i,j,w,0); continue; }
w=w*(mod-1)%mod;
if (s==m-1) { (ans+=w)%=mod; break; }
rep(k,1,n) Go(s,tot[s],k,w,1);
}
rep(i,1,n) ans=ans*fac[cnt[i]]%mod*((cnt[i]&1)?mod-1:1)%mod;
cout<<ans;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define pii pair<int, int>
const int maxN = 2e5 + 10, mod = 1e9 + 7;
int n, m, lim;
int pre[45], p[45], val[45];
int C[45][45], fac[45], ct[45], coef[45][45];
int f[maxN + 1], bc[maxN + 1];
bool vis[45];
vector<pii> vec[maxN + 1];
inline void update(int &x, int y) { x = x + y >= mod ? x + y - mod : x + y; }
inline void dfs(int x, int s, int coef, int t)
{
if(x > m)
{
if(t) vec[s].push_back( pii(t, coef) );
return;
}
int a = (s / pre[x - 1]) % (ct[ val[x] ] + 1);
for(int i = 0; i <= a; i++)
{
int nc = 1ll * coef * C[a][i] % mod;
dfs(x + 1, s, (i & 1) ? mod - nc : nc, t + i * pre[x - 1]);
}
}
int main()
{
scanf("%d", &n);
for(int i = 1; i <= n; i++) scanf("%d", &p[i]);
for(int i = 1; i <= n; i++)
{
if(vis[i]) continue;
int x = i, cnt = 0;
while(!vis[x]) vis[x] = true, x = p[x], cnt ++;
ct[cnt] ++;
}
pre[0] = 1;
for(int i = 1; i <= n; i++)
if(ct[i])
{
val[++ m] = i;
pre[m] = pre[m - 1] * (ct[i] + 1);
}
for(int i = 0; i <= n; i++)
{
C[i][0] = 1;
for(int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
fac[0] = 1;
for(int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
lim = pre[m];
for(int s = 1; s < lim; s++)
{
dfs(1, s, mod - 1, 0);
for(int j = 1; j <= m; j++) bc[s] += val[j] * ((s / pre[j - 1]) % (ct[ val[j] ] + 1));
}
for(int j = 0; j < n; j++)
{
int sum = 0;
for(int k = 0; k <= j; k++)
update(sum, 1ll * fac[k] * fac[n - 1 - k] % mod * C[j][k] % mod);
coef[0][j] = 1;
for(int i = 1; i <= n; i++)
coef[i][j] = 1ll * coef[i - 1][j] * sum % mod;
}
f[0] = 1;
for(int s = 1; s < lim; s++)
for(int i = 0; i < vec[s].size(); i++)
{
int t = vec[s][i].first, w = 1ll * vec[s][i].second * f[s - t] % mod * coef[ bc[t] ][ bc[s - t] ] % mod;
update(f[s], w);
}
printf("%d\n", f[lim - 1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, k, p[45], vis[45], len[45], cnt[45], ps[45], f[1440], C[45][45], fact[45], pw[45][45];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i]);
vector<int> vc;
for (int i = 1; i <= n; i++) if (!vis[i]) {
int j = i, c = 0;
while (!vis[j]) {
vis[j] = 1;
c++;
j = p[j];
}
vc.push_back(c);
}
sort(vc.begin(), vc.end());
ps[0] = 1;
for (int i = 0, j; i < (int)vc.size(); i = j) {
for (j = i; j < (int)vc.size() && vc[i] == vc[j]; j++);
++k;
len[k] = vc[i];
cnt[k] = j - i;
ps[k] = ps[k - 1] * (cnt[k] + 1);
}
for (int i = fact[0] = 1; i <= n; i++) fact[i] = 1ll * fact[i - 1] * i % mod;
for (int i = C[0][0] = 1; i <= n; i++)
for (int j = C[i][0] = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
for (int i = 0; i < n; i++) {
int b = 0;
for (int j = 0; j <= i; j++)
b = (b + 1ll * fact[j] * fact[n - j - 1] % mod * C[i][j]) % mod;
for (int j = pw[i][0] = 1; j <= n; j++)
pw[i][j] = 1ll * pw[i][j - 1] * b % mod;
}
f[0] = 1;
for (int mask = 1; mask < ps[k]; mask++) {
int c[45], al = 0;
for (int i = 1; i <= k; i++) c[i] = mask / ps[i - 1] % (cnt[i] + 1), al += len[i] * c[i];
function<void(int, int, int, int)> go = [&](int i, int nmask, int sum, int cf) {
if (i == k + 1) {
if (nmask != mask) {
f[mask] = (f[mask] + 1ll * cf * f[nmask] % mod * pw[sum][al - sum]) % mod;
}
return;
}
for (int b = 0; b <= c[i]; b++) {
go(i + 1,
nmask + ps[i - 1] * (c[i] - b),
sum + len[i] * (c[i] - b),
1ll * cf * ((b & 1) ? mod - C[c[i]][b] : C[c[i]][b]) % mod);
}
};
go(1, 0, 0, mod - 1);
}
printf("%d\n", f[ps[k] - 1]);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define MN 45
#define Mod 1000000007
#define pii pair<int,int>
#define mp make_pair
#define x first
#define y second
int ksm(int a,int x){
int ans=1,w=a;
while(x){
if(x&1)ans=ans*w%Mod;
w=w*w%Mod;
x>>=1;
}
return ans;
}
int n,a[MN],F[MN],siz[MN];
int fac[MN],dfac[MN],inv[MN],C[MN][MN];
int c[MN][MN][MN];
int Find(int a){
if(F[a]==a)return a;
return F[a]=Find(F[a]);
}
#define vc vector<int>
map<vc,int>f[MN];
vector<vc >st[MN];
void dfs(int s,vc v,int p){
if(s==n||p==v.size())return;
for(int i=p;i<v.size();++i){
vc tmp=v;
int ad=0;
for(int j=1;j<=v[i];++j){
tmp[i]--;
ad+=i;
st[s+ad].push_back(tmp);
dfs(s+ad,tmp,i+1);
}
}
}
int tax[MN];
void DFS(int I,vector<pii>use_J,int K,vector<int>&tmp,int p){
if(I+K==n||p==tmp.size())return;
for(int i=p;i<tmp.size();++i){
vc to=tmp;
int ad=0,vv=0;
vector<pii >temp=use_J;
for(int j=tmp[i]-1;j>=0;--j){
to[i]--;
ad+=i;
int dt=tmp[i]-j;
// cerr<<"dt: "<<dt<<endl;
// int tv=prod;
vector<pii >tv=use_J;
//C[tmp[i]][dt];
int ret=0;
for(int k=1;k<=dt;++k)
for(auto &T:tv){
T.y=T.y*c[I][T.x][i]%Mod;
}
for(auto &T:tv){
T.y=T.y*C[tmp[i]][dt]%Mod;
ret=(ret+T.y);
}
// cerr<<"ret: "<<ret<<" "<<C[tmp[i]][dt]<<endl;
(f[K+ad][to]+=ret)%=Mod;
DFS(I,tv,K+ad,to,i+1);
}
use_J=temp;
}
}
signed main(){
// freopen("1.in","r",stdin);
cin>>n;
fac[0]=fac[1]=dfac[0]=dfac[1]=inv[1]=1;
for(int i=2;i<=n;++i){
fac[i]=fac[i-1]*i%Mod;
inv[i]=(Mod-Mod/i)*inv[Mod%i]%Mod;
dfac[i]=dfac[i-1]*inv[i]%Mod;
}
C[0][0]=1;
for(int i=1;i<=n;++i){
C[i][0]=1;
for(int j=1;j<=n;++j){
C[i][j]=(C[i-1][j-1]+C[i-1][j])%Mod;
}
}
for(int i=1;i<=n;++i)F[i]=i,siz[i]=1;
for(int i=1;i<=n;++i){
cin>>a[i];
int fa=Find(a[i]),fi=Find(i);
if(fa!=fi){
F[fi]=fa;
siz[fa]+=siz[fi];
}
}
vector<int>v;v.resize(n+1);
for(int i=0;i<=n;++i)v[i]=0;
for(int i=1;i<=n;++i)
if(Find(i)==i){
v[siz[i]]++;
tax[siz[i]]++;
}
for(int i=0;i<=n;++i)
for(int j=0;j<=i;++j)
for(int k=1;i+k<=n;++k){
if(i){
int tmp=0;
for(int o=0;o<=i;++o){
tmp=(tmp+C[i][o]*fac[o]%Mod*fac[n-o-1])%Mod;
}
tmp=ksm(tmp,k);
int sub=0;
for(int o=0;o<=i-j;++o){
sub=(sub+C[i-j][o]*fac[o]%Mod*fac[n-o-1])%Mod;
}
sub=ksm(sub,k);
c[i][j][k]=(tmp-sub+Mod)%Mod;
}
else{
c[i][j][k]=ksm(fac[n-1],k);
}
}
st[0].push_back(v);
f[0][v]=1;
dfs(0,v,1);
int ans=0;
for(int i=0;i<=n;++i){
for(auto v:st[i]){
vector<pii > use_j(0);
for(int j=0;j<=n;++j){
if(!f[j].count(v))continue;
use_j.push_back(mp(j,f[j][v]));
//DFS(i,j,0,1,v,1,f[j][v]);
if(i==n)ans=(ans+f[j][v])%Mod;
}
DFS(i,use_j,0,v,1);
}
}
printf("%lld\n",ans);
return 0;
} |
#include <bits/stdc++.h>
const int mod=1e9+7;
using namespace std;
int n,fac[50],C[50][50],tr[50][50],p[50],cnt[50],pre[50],q[125000],w[125000],t=0,sz[125000],dp[125000];
bool vis[50];
void init(int N){
pre[0]=fac[0]=1;
for(int i=1;i<=N;i++) fac[i]=1ll*i*fac[i-1]%mod;
C[0][0]=1;
for(int i=1;i<=N;i++){
C[i][0]=1;
for(int j=1;j<=N;j++) C[i][j]=(C[i-1][j]+C[i-1][j-1])%mod;
}
for(int i=0;i<n;i++){
tr[i][0]=1;
for(int j=0;j<=i;j++) tr[i][1]=(tr[i][1]+1ll*C[i][j]*fac[j]%mod*fac[n-j-1])%mod;
for(int j=2;j<=N;j++) tr[i][j]=1ll*tr[i][j-1]*tr[i][1]%mod;
}
for(int i=1;i<=n;i++){
if(vis[i]) continue;
int l=0,u=i;
for(;!vis[u];l++,u=p[u]) vis[u]=true;
++cnt[l];
}
for(int i=1;i<=n;i++) pre[i]=1ll*pre[i-1]*(cnt[i]+1);
dp[0]=1;
for(int S=0;S<pre[n];S++){
t=0;
q[++t]=0,w[t]=mod-1;
for(int i=1;i<=n;i++){
int lst=t;
int lim=(S/pre[i-1])%(cnt[i]+1);
sz[S]+=i*lim;
for(int o=1;o<=lst;o++) for(int j=1;j<=lim;j++){
q[++t]=q[o]+j*pre[i-1];
w[t]=1ll*w[o]*(j&1?mod-1:1)%mod*C[lim][j]%mod;
}
}
for(int i=2;i<=t;i++) dp[S]=(dp[S]+1ll*dp[S-q[i]]*w[i]%mod*tr[sz[S]-sz[q[i]]][sz[q[i]]])%mod;
}
printf("%d\n",dp[pre[n]-1]);
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&p[i]);
init(40);
} |
#include <cstdio>
#include <cstring>
#include <map>
const int P=1000000007;
inline int mul(const int &a,const int &b){return 1ll*a*b%P;}
inline int sub(int a,const int &b){a-=b;return (a<0)?a+P:a;}
inline int add(int a,const int &b){a+=b;return(a>=P)?a-P:a;}
int qsm(int a,int b){
int ans=1;
while(b){
if(b&1)ans=mul(ans,a);
a=mul(a,a);
b>>=1;
}
return ans;
}
int n,p[41],hav[1501][11],chose[11],g[41][41],down[1501][11],siz[1501];
int f[11][1501][41][41],inv[41],_mul[41],invmul[41];
bool vis[41];
int tag[41];
int cnt[41][2],now,top;
void dfs(int x,int tot=0){
if(x>top){
memcpy(hav[++now],chose,sizeof chose);
siz[now]=tot;
return;
}
for(chose[x]=0;chose[x]<=cnt[x][1];++chose[x])
dfs(x+1,tot+cnt[x][0]*chose[x]);
}
int h,t,C[41][41];
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%d",p+i);
for(int i=1;i<=n;i++)
if(!vis[i]){
int tem=i,len=0;
while(!vis[tem]){
++len;
vis[tem]=1;
tem=p[tem];
}
if(!tag[len])cnt[tag[len]=++top][0]=len;
++cnt[tag[len]][1];
}
dfs(1);
for(int i=1;i<=now;i++){
for(int j=top,x=1;j;j--){
down[i][j]=i-x;
x*=cnt[j][1]+1;
}
}
inv[0]=inv[1]=_mul[0]=_mul[1]=invmul[0]=invmul[1]=1;
for(int i=2;i<=n;i++)inv[i]=mul(P-P/i,inv[P%i]);
for(int i=2;i<=n;i++)_mul[i]=mul(_mul[i-1],i);
for(int i=2;i<=n;i++)invmul[i]=mul(invmul[i-1],invmul[i]);
for(int i=0;i<=n;i++){
C[i][0]=1;
for(int j=1;j<=i;j++)
C[i][j]=add(C[i-1][j],C[i-1][j-1]);
}
f[0][now][0][0]=1;
for(int i=now;i;--i)
for(int sum=n;~sum;--sum){
for(int s=0,o=sum;s<=sum;s++,o--)
for(int j=0;j<top;j++){
if(f[j][i][s][o]){
if(j==0&&s==0&&siz[i]+o<n)continue;
// printf("%d %d %d %d %d (%d) %d\n",j,i,s,o,f[j][i][s][o],o+siz[i],hav[i][j+1]);
int v=sub(qsm(mul(inv[o+siz[i]],_mul[n]),cnt[j+1][0]),mul((o+siz[i]!=n),qsm(mul(inv[s+o+siz[i]],_mul[n]),cnt[j+1][0])));
// printf("%d\n",v);
for(int k=0,x=i,m=1;k<=hav[i][j+1];k++){
int &p=(j+1==top)?f[0][x][o+k*cnt[j+1][0]][0]:f[j+1][x][s][o+k*cnt[j+1][0]];
if(j+1==top&&o+k*cnt[j+1][0]==0);
else p=add(p,mul(f[j][i][s][o],mul(C[hav[i][j+1]][k],m)));
m=mul(m,v);
x=down[x][j+1];
}
}
}
}
int ans=0;
for(int i=1;i<=n;i++)
ans=add(ans,f[0][1][i][0]);
printf("%d\n",ans);
} |
//
// cf
//
// Created by Mr. Khanh on 04/01/2021.
//
// <3 Duck
#include <bits/stdc++.h>
#include <iostream>
#include <vector>
#include <array>
#include <numeric>
#include <utility>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a; swap(a, m);
u -= t * v; swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
else v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const { return static_cast<U>(value); }
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; }
Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; }
template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); }
template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); }
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) { Modular result(*this); *this += 1; return result; }
Modular operator--(int) { Modular result(*this); *this -= 1; return result; }
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type& operator*=(const Modular& rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
asm(
"divl %4; \n\t"
: "=a" (d), "=d" (m)
: "d" (xh), "a" (xl), "r" (mod())
);
value = m;
#else
value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, long long>::value, Modular>::type& operator*=(const Modular& rhs) {
long long q = static_cast<long long>(static_cast<long double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type& operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) { return *this *= Modular(inverse(other.value, mod())); }
friend const Type& abs(const Modular& x) { return x.value; }
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename V, typename U>
friend V& operator>>(V& stream, Modular<U>& number);
private:
Type value;
};
template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value == rhs.value; }
template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs) { return lhs == Modular<T>(rhs); }
template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) == rhs; }
template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value < rhs.value; }
template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template<typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
// U == std::ostream? but done this way because of fastoutput
template <typename U, typename T>
U& operator<<(U& stream, const Modular<T>& number) {
return stream << number();
}
// U == std::istream? but done this way because of fastinput
template <typename U, typename T>
U& operator>>(U& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, long long>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
/*
using ModType = int;
struct VarMod { static ModType value; };
ModType VarMod::value;
ModType& md = VarMod::value;
using Mint = Modular<VarMod>;
*/
constexpr int md = (int) 1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
/*vector<Mint> fact(1, 1);
vector<Mint> inv_fact(1, 1);
Mint C(int n, int k) {
if (k < 0 || k > n) {
return 0;
}
while ((int) fact.size() < n + 1) {
fact.push_back(fact.back() * (int) fact.size());
inv_fact.push_back(1 / fact.back());
}
return fact[n] * inv_fact[k] * inv_fact[n - k];
}*/
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
--p[i];
}
vector<bool> was(n, false);
vector<int> cnt(n + 1, 0);
for (int i = 0; i < n; i++) {
if (was[i]) {
continue;
}
int len = 0;
int x = i;
while (!was[x]) {
len += 1;
was[x] = true;
x = p[x];
}
cnt[len] += 1;
}
int states = 1;
for (int i = 1; i <= n; i++) {
states *= cnt[i] + 1;
}
vector<vector<int>> g(states);
int cnt_edges = 0;
function<void(int, int, int)> Dfs = [&](int i, int x, int y) {
if (i == n + 1) {
if (x != y) {
g[x].push_back(y);
++cnt_edges;
}
return;
}
for (int j = 0; j <= cnt[i]; j++) {
for (int k = j; k <= cnt[i]; k++) {
Dfs(i + 1, x * (cnt[i] + 1) + k, y * (cnt[i] + 1) + j);
}
}
};
Dfs(0, 0, 0);
debug(cnt_edges);
vector<Mint> fact(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i;
}
vector<vector<Mint>> C(n + 1, vector<Mint>(n + 1));
for (int i = 0; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
}
vector<vector<Mint>> dp(states, vector<Mint>(n + 1));
for (int state = states - 2; state >= 0; state--) {
vector<int> a(n + 1);
{
int tmp = state;
for (int i = n; i >= 1; i--) {
a[i] = tmp % (cnt[i] + 1);
tmp /= cnt[i] + 1;
}
}
Mint choose = 1;
int elems = 0;
for (int i = 1; i <= n; i++) {
elems += a[i] * i;
choose *= C[cnt[i]][a[i]];
}
assert(elems < n);
dp[state][n - elems] = choose * power(fact[n - 1], n - elems);
for (int other : g[state]) {
vector<int> b(n + 1);
{
int tmp = other;
for (int i = n; i >= 1; i--) {
b[i] = tmp % (cnt[i] + 1);
tmp /= cnt[i] + 1;
}
}
Mint new_choose = 1;
int new_elems = 0;
for (int i = 1; i <= n; i++) {
new_elems += b[i] * i;
assert(b[i] <= a[i]);
new_choose *= C[a[i]][b[i]];
}
assert(new_elems < elems);
for (int last = 1; last <= n; last++) {
if (dp[state][last] == 0) {
continue;
}
Mint coeff = new_choose;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < a[i] - b[i]; j++) {
Mint cur = power(fact[elems + last] / elems, i);
cur -= power(fact[elems + last - 1], i);
coeff *= cur;
}
}
coeff *= power(C[elems + last][elems] * fact[last], new_elems);
dp[other][elems - new_elems] += dp[state][last] * coeff;
}
}
}
Mint ans = 0;
for (int last = 1; last <= n; last++) {
ans += dp[0][last];
}
cout << ans << '\n';
return 0;
}
|
/***************************************************************
File name: CF1466H.cpp
Author: ljfcnyali
Create time: 2021年01月06日 星期三 20时52分14秒
***************************************************************/
#include<bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for ( int i = (a), _end_ = (b); i <= _end_; ++ i )
#define mem(a) memset ( (a), 0, sizeof ( a ) )
#define str(a) strlen ( a )
#define pii pair<int, int>
#define int long long
typedef long long LL;
const int maxn = 41;
const int Mod = 1e9 + 7;
int n, m, a[maxn], fac[maxn], inv[maxn], g[maxn][maxn][maxn], siz[maxn], belong[maxn];
bool vis[maxn];
map<vector<int>, int> Map[maxn];
inline int power(int a, int b) { int r = 1; while ( b ) { if ( b & 1 ) r = r * a % Mod; a = a * a % Mod; b >>= 1; } return r; }
inline int C(int n, int m) { return n < m ? 0 : (fac[n] * inv[m] % Mod) * inv[n - m] % Mod; }
inline int Solve(vector<int> a, int lst) ;
inline int DFS(vector<int> b, int x, vector<int> a, int lst, int sum, int num, int i)
{
if ( x == m )
{
if ( sum == i ) return 0;
return Solve(b, sum - i) * num % Mod;
}
int ret = 0;
REP(j, a[x], siz[belong[x]])
{
b.push_back(j);
ret += DFS(b, x + 1, a, lst, sum + belong[x] * j, num *
C(siz[belong[x]] - a[x], j - a[x]) % Mod * power(g[i][lst][belong[x]], j - a[x]) % Mod, i);
b.pop_back();
}
return ret % Mod;
}
inline int Solve(vector<int> a, int lst)
{
if ( Map[lst].count(a) ) return Map[lst][a];
int sum = 0; REP(i, 0, m - 1) sum += a[i] * belong[i];
// cerr << a.size() << endl;
if ( sum == n ) return 1;
vector<int> b; int ret = DFS(b, 0, a, lst, 0, 1, sum);
Map[lst][a] = ret; return ret;
}
signed main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
scanf("%lld", &n); REP(i, 1, n) scanf("%lld", &a[i]);
fac[0] = inv[0] = 1; REP(i, 1, n) fac[i] = fac[i - 1] * i % Mod;
inv[n] = power(fac[n], Mod - 2); for ( int i = n - 1; i >= 1; -- i ) inv[i] = inv[i + 1] * (i + 1) % Mod;
REP(i, 0, n - 1) REP(j, 0, n) REP(k, 1, n)
{
if ( j == 0 ) { g[i][j][k] = power(fac[n - 1], k); continue ; }
int num1 = 0, num2 = 0;
REP(o, 0, i)
{
num1 = (num1 + C(i, o) * fac[o] % Mod * fac[n - o - 1]) % Mod;
num2 = (num2 + C(i - j, o) * fac[o] % Mod * fac[n - o - 1]) % Mod;
}
g[i][j][k] = (power(num1, k) - power(num2, k)) % Mod;
}
REP(i, 1, n) if ( !vis[i] )
{
int cnt = 0, x = i;
while ( !vis[a[x]] ) { vis[a[x]] = true; x = a[x]; ++ cnt; }
++ siz[cnt];
}
REP(i, 1, n) if ( siz[i] ) belong[m ++] = i;
vector<int> p; REP(i, 1, m) p.push_back(0);
printf("%lld\n", (Solve(p, 0) + Mod) % Mod);
return 0;
}
|
//Let's join Kaede Takagaki Fan Club !!
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define mp make_pair
#define pb push_back
#define fi first
#define sc second
#define rep(i,x) for(int i=0;i<x;i++)
#define repn(i,x) for(int i=1;i<=x;i++)
const ll mod = 1000000007;
ll F[50], R[50];
ll modpow(ll a, ll n){
ll ret = 1;
while(n){
if(n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
void init(){
F[0] = 1;
for(int i=1;i<50;i++) F[i] = F[i-1] * i % mod;
rep(i, 50) R[i] = modpow(F[i], mod-2);
}
ll C(int a, int b){
if(b < 0 || a < b) return 0LL;
return F[a] * R[b] % mod * R[a-b] % mod;
}
int n, go[42], vis[42];
vector<int>cmp;
ll coef[42][42][42];
map<pair<P, vector<P>>, ll>M;
ll solve(int old, int pre, vector<P>part);
ll make(int old, int pre, vector<P>cur, vector<P>&part, ll mm, int sz){
int id = cur.size();
ll sum = 0;
if(id == part.size()){
if(sz) return solve(old+pre, sz, cur) * mm % mod;
else return 0LL;
}
for(int x=part[id].fi;x>=0;x--){
ll mm2 = mm * C(part[id].fi, x) % mod;
cur.pb(mp(x, part[id].sc));
sum += make(old, pre, cur, part, mm2, sz+(part[id].fi-x)*part[id].sc);
cur.pop_back();
mm = mm * coef[old][pre][part[id].sc] % mod;
}
return sum%mod;
}
ll solve(int old, int pre, vector<P>part){
for(auto at:part) if(at.fi) goto nxt;
return 1LL; nxt:;
if(M.find(mp( mp(old, pre), part)) != M.end()) return M[mp(mp(old, pre), part)];
return M[mp(mp(old, pre), part)] = make(old, pre, vector<P>(), part, 1, 0);
}
int main(){
init();
cin >> n;
repn(i, n) cin >> go[i];
repn(i, n){
if(vis[i]) continue;
int cur = i, cnt = 0;
while(!vis[cur]){
vis[cur] = 1;
cnt ++;
cur = go[cur];
}
cmp.pb(cnt);
}
sort(cmp.begin(), cmp.end());
vector<int>mm(n+1, 0);
rep(i, cmp.size()) mm[cmp[i]] ++;
vector<P>m;
rep(i, n+1) if(mm[i]) m.pb(mp(mm[i], i));
rep(x, n+1){
repn(y, n-x){
repn(z, n-x-y){
ll sum = 0;
ll sum2 = 0;
rep(i, x+1) {
sum += C(x, i) * C(y, 0) % mod * F[i+0] % mod * F[n-1-i-0] % mod;
}
rep(i, x+1) rep(j, y+1){
sum2 += C(x, i) * C(y, j) % mod * F[i+j] % mod * F[n-1-i-j] % mod;
}
sum %= mod;
sum2 %= mod;
coef[x][y][z] = modpow(sum2, z) - modpow(sum, z);
if(coef[x][y][z] < 0) coef[x][y][z] += mod;
}
}
}
repn(x, n) coef[0][0][x] = modpow(F[n-1], x);
cout << solve(0, 0, m) << endl;
} |
#include <bits/stdc++.h>
const int S = 1500;
const int P = int(1E9) + 7;
inline int add(int x, int y) {x += y; return x >= P ? x - P : x;}
inline int sub(int x, int y) {x -= y; return x < 0 ? x + P : x;}
inline int mul(int x, int y) {if( x == 0 || y == 0 ) return 0; else return (int)(1ll * x * y % P);}
int mpow(int b, int p) {
int r; for(r = 1; p; p >>= 1, b = mul(b, b))
if( p & 1 ) r = mul(r, b);
return r;
}
int comb[45][45], fct[45];
void init() {
fct[0] = 1; for(int i=1;i<=40;i++) fct[i] = mul(fct[i - 1], i);
for(int i=0;i<=40;i++) for(int j=0;j<=i;j++)
comb[i][j] = (j == 0 ? 1 : add(comb[i - 1][j], comb[i - 1][j - 1]));
}
/*
int mx = 0;
void divide(int n, int x, int s) {
if( n == 0 ) {
mx = std::max(mx, s);
return ;
}
if( n < x ) return ;
for(int p=0;p*x<=n;p++)
divide(n - p * x, x + 1, s * (p + 1));
}
void calc() {
divide(40, 1, 1);
printf("%d\n", mx);
}
*/
int a[45], n, t;
int g[45][45], sz[S + 5], sum[S + 5];
void pre() {
t = 1; for(int i=1;i<=n;i++) t = t * a[i];
for(int i=0;i<t;i++) for(int k=1,i1=i;k<=n;i1/=a[k],k++)
sz[i] += (i1 % a[k]), sum[i] += (i1 % a[k]) * k;
int h[45] = {};
for(int j=0;j<=n;j++) for(int p=0;p<=j;p++)
h[j] = add(h[j], mul(comb[j][p], mul(fct[p], fct[n - p - 1])));
for(int j=0;j<=n;j++) {
g[0][j] = 1;
for(int i=1;i<=n;i++)
g[i][j] = mul(g[i - 1][j], h[j]);
}
}
int calc(int i, int j) {
int ans = 1;
for(int k=1,i1=i,j1=j;k<=n;i1/=a[k],j1/=a[k],k++)
ans = mul(ans, comb[i1 % a[k]][j1 % a[k]]);
ans = mul(ans, g[sum[j]][sum[i - j]]);
return sz[j] & 1 ? ans : sub(0, ans);
}
int f[S + 5];
void solve() {
f[t - 1] = 1;
for(int i=t-1;i>0;i--) for(int j=i;j>0;j--)
f[i - j] = add(f[i - j], mul(f[i], calc(i, j)));
}
int p[45], vis[45];
int main() {
// calc();
init(), scanf("%d", &n);
for(int i=1;i<=n;i++) scanf("%d", &p[i]), a[i]++;
for(int i=1;i<=n;i++) if( !vis[i] ) {
int tmp = i, s = 0;
do {
vis[tmp] = true, tmp = p[tmp], s++;
}while( !vis[tmp] );
a[s]++;
}
pre(), solve(), printf("%d\n", f[0]);
} |
#include <bits/stdc++.h>
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n) - 1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<vi> vvi;
typedef long long i64;
typedef vector<i64> vi64;
typedef vector<vi64> vvi64;
typedef pair<i64, i64> pi64;
typedef double ld;
template<class T> bool uin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool uax(T &a, T b) { return a < b ? (a = b, true) : false; }
struct TState {
map<int, int> cs, ns;
int v;
bool operator<(const TState &st) const {
if (cs != st.cs) return cs < st.cs;
if (ns != st.ns) return ns < st.ns;
return v < st.v;
}
};
map<TState, i64> memo;
const int maxn = 41;
i64 fact[maxn], tcaf[maxn], inv[maxn];
int n;
const i64 P = 1000000000 + 7;
i64 cnk(int n, int k) {
return fact[n] * tcaf[k] % P * tcaf[n - k] % P;
}
i64 deg(i64 x, i64 d) {
if (d < 0) d += P - 1;
i64 y = 1;
while (d) {
if (d & 1) (y *= x) %= P;
d /= 2;
(x *= x) %= P;
}
return y;
}
i64 get_dp(TState st) {
/* cerr << "CS: ";
for (auto [x, y]: st.cs) cerr << x << ": " << y << ", ";
cerr << '\n';
cerr << "NS: ";
for (auto [x, y]: st.ns) cerr << x << ": " << y << ", ";
cerr << '\n';
cerr << st.v << '\n';
cerr << "---\n";*/
if (memo.count(st)) return memo[st];
auto &res = memo[st];
res = 0;
if (st.cs.empty()) {
if (!st.v) return res = 0;
TState nst = st;
nst.ns.swap(nst.cs);
int lft = 0;
for (auto &w: st.ns) lft += w.fi * w.se;
nst.v = 0;
// cerr << lft << ' ' << fact[n] << ' ' << inv[n - lft] << ' ' << fact[n] * inv[n - lft] % P << '\n';
i64 coef = deg(fact[n] * inv[n - lft] % P, st.v);
// cerr << coef << '\n';
return res = -coef * get_dp(nst) % P;
}
assert(!st.cs.empty());
auto it = --st.cs.end();
int x = it->fi, y = it->se;
st.cs.erase(it);
forn(j, y + 1) {
TState nst = st;
nst.v += j * x;
if (j < y) nst.ns[x] += y - j;
(res += get_dp(nst) * (j % 2 ? -1 : 1) * cnk(y, j)) %= P;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
#ifdef LOCAL_DEFINE
freopen("input.txt", "rt", stdin);
#endif
cin >> n;
fact[0] = 1;
for1(i, n) fact[i] = i * fact[i - 1] % P;
forn(i, n + 1) tcaf[i] = deg(fact[i], -1);
for1(i, n) inv[i] = deg(i, -1);
vi a(n);
forn(i, n) cin >> a[i], --a[i];
map<int, int> cs;
forn(i, n) {
if (a[i] == -1) continue;
int len = 0;
for (int j = i; a[j] != -1; ) {
++len;
int k = a[j];
a[j] = -1;
j = k;
}
++cs[len];
}
memo[{{}, {}, 0}] = 1;
i64 ans = get_dp({cs, {}, 0});
if (ans < 0) ans += P;
cout << ans << '\n';
#ifdef LOCAL_DEFINE
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
|
/*
Author: QAQAutoMaton
Lang: C++
Code: H.cpp
Mail: lk@qaq-am.com
Blog: https://www.qaq-am.com/
*/
#include<bits/stdc++.h>
#define debug(qaq...) fprintf(stderr,qaq)
#define DEBUG printf("Passing [%s] in LINE %d\n",__FUNCTION__,__LINE__)
#define Debug debug("Passing [%s] in LINE %d\n",__FUNCTION__,__LINE__)
#define all(x) x.begin(),x.end()
#define x first
#define y second
#define unq(a) sort(all(a)),a.erase(unique(all(a)),a.end())
using namespace std;
typedef unsigned uint;
typedef long long ll;
typedef unsigned long long ull;
typedef complex<double> cp;
typedef pair<int,int> pii;
int inf;
const double eps=1e-8;
const double pi=acos(-1.0);
template<class T,class T2>int chkmin(T &a,T2 b){return a>b?a=b,1:0;}
template<class T,class T2>int chkmax(T &a,T2 b){return a<b?a=b,1:0;}
template<class T>T sqr(T a){return a*a;}
template<class T,class T2>T mmin(T a,T2 b){return a<b?a:b;}
template<class T,class T2>T mmax(T a,T2 b){return a>b?a:b;}
template<class T>T aabs(T a){return a<0?-a:a;}
template<class T>int dcmp(T a,T b){return a>b;}
template<int *a>int cmp_a(int x,int y){return a[x]<a[y];}
template<class T>bool sort2(T &a,T &b){return a>b?swap(a,b),1:0;}
#define min mmin
#define max mmax
#define abs aabs
struct __INIT__{
__INIT__(){
fill((unsigned char*)&inf,(unsigned char*)&inf+sizeof(inf),0x3f);
}
}__INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55]; int f, qr;
// getchar
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
// print the remaining part
inline void flush () {
fwrite (obuf, 1, oS - obuf, stdout);
oS = obuf;
}
// putchar
inline void putc (char x) {
*oS ++ = x;
if (oS == oT) flush ();
}
template<typename A>
inline bool read (A &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;else if(c==EOF)return 0;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15); x *= f;
return 1;
}
inline bool read (char &x) {
while((x=gc())==' '||x=='\n' || x=='\r');
return x!=EOF;
}
inline bool read(char *x){
while((*x=gc())=='\n' || *x==' '||*x=='\r');
if(*x==EOF)return 0;
while(!(*x=='\n'||*x==' '||*x=='\r'||*x==EOF))*(++x)=gc();
*x=0;
return 1;
}
template<typename A,typename ...B>
inline bool read(A &x,B &...y){
return read(x)&&read(y...);
}
template<typename A>
inline bool write (A x) {
if (!x) putc ('0'); if (x < 0) putc ('-'), x = -x;
while (x) qu[++ qr] = x % 10 + '0', x /= 10;
while (qr) putc (qu[qr --]);
return 0;
}
inline bool write (char x) {
putc(x);
return 0;
}
inline bool write(const char *x){
while(*x){putc(*x);++x;}
return 0;
}
inline bool write(char *x){
while(*x){putc(*x);++x;}
return 0;
}
template<typename A,typename ...B>
inline bool write(A x,B ...y){
return write(x)||write(y...);
}
//no need to call flush at the end manually!
struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
}
using io :: read;
using io :: putc;
using io :: write;
const int p=1000000007;
struct Z{
uint x;
Z(){}
Z(uint a){
x=a;
}
};
inline uint modp(const uint x){
return x<p?x:x-p;
}
inline Z operator+(const Z x1, const Z x2) { return modp(x1.x+x2.x);}
inline Z operator-(const Z x1, const Z x2) { return modp(x1.x+p-x2.x);}
inline Z operator-(const Z x) {return x.x?p-x.x:0;}
inline Z operator*(const Z x1, const Z x2) { return static_cast<ull>(x1.x)*x2.x%p;}
void exgcd(int a,int b,int &x,int &y){
if(!b){x=1;y=0;return;}
exgcd(b,a%b,y,x);
y-=(a/b)*x;
}
inline Z Inv(const Z a){
int x,y;
exgcd(p,a.x,x,y);
return y<0?y+=p:y;
}
inline Z operator/(const Z x1, const Z x2) { return x1*Inv(x2);}
inline Z &operator++(Z &x1){x1.x==p-1?x1.x=0:++x1.x;return x1;}
inline Z &operator--(Z &x1){x1.x?--x1.x:x1.x=p-1;return x1;}
inline Z &operator+=(Z &x1, const Z x2) { return x1 = x1 + x2; }
inline Z &operator-=(Z &x1, const Z x2) { return x1 = x1 - x2; }
inline Z &operator*=(Z &x1, const Z x2) { return x1 = x1 * x2; }
inline Z &operator/=(Z &x1, const Z x2) { return x1 = x1 / x2; }
inline Z fpm(Z a,int b){Z c(1);for(;b;b>>=1,a*=a)if(b&1)c*=a;return c;}
Z f[45][45];
int s[5005];
bitset<45> v;
int c;
int pw;
int a[45],b[45];
int cur[45],nx[45],af[5005][45];
Z C[45][45];
int c1[5005];
Z dp[5005];
void chai(int x){
int y=x;
s[x]=0;
c1[x]=0;
for(int i=c;i;--i){
cur[i]=af[x][i]=y%a[i];
s[x]+=cur[i]*b[i];
c1[x]^=cur[i]&1;
y/=a[i];
}
}
int get(){
int w=0;
for(int i=1;i<=c;++i)w=w*a[i]+nx[i];
return w;
}
signed main(){
#ifdef QAQAutoMaton
freopen("H.in","r",stdin);
freopen("H.out","w",stdout);
#endif
int n;
read(n);
for(int i=0;i<n;++i){
f[i][0]=1;
f[i][1]=1;
for(int j=1;j<=n;++j)if(j+i!=n)f[i][1]*=j;
//write(f[i][1].x,i==n-1?'\n':' ');
for(int j=2;j<=n;++j)f[i][j]=f[i][j-1]*f[i][1];
}
for(int i=0;i<=n;++i){
C[i][0]=C[i][i]=1;
for(int j=1;j<i;++j)C[i][j]=C[i-1][j-1]+C[i-1][j];
}
for(int i=1;i<=n;++i){read(a[i]);}
for(int i=1;i<=n;++i)if(!v[i]){
int l=0,j=i;
while(!v[j]){++l;v[j]=1;j=a[j];}
++s[l];
}
int w(1);
for(int i=1;i<=n;++i){
if(s[i]){
++c;
a[c]=s[i]+1;
w*=a[c];
b[c]=i;
}
}
dp[0]=1;
for(int i=1;i<w;++i){
chai(i);
//for(int j=1;j<=c;++j)write(cur[j],j==c?'\n':' ');
for(int j=1;j<=c;++j)nx[j]=0;
while(1){
//for(int j=1;j<=c;++j)debug("%d %d\n",cur[j],nx[j]);
int j=get();
if(i==j)break;
Z S(1);
//for(int j=1;j<=c;++j)assert(nx[j]<=cur[j]);
for(int j=1;j<=c;++j)S*=C[cur[j]][nx[j]];
//write(i,' ',j,' ',s[j],' ',s[i]-s[j],' ',f[s[j]][s[i]-s[j]].x,'\n');
dp[i]+=dp[j]*(c1[i]^c1[j]?1:p-1)*f[s[j]][s[i]-s[j]]*S;
++nx[1];
j=1;
while(j<c && nx[j]>cur[j]){nx[j]=0;++nx[++j];}
}
//write(i,':',dp[i].x,'\n');
}
write(dp[w-1].x,'\n');
return 0;
}
|
using namespace std;
#include <bits/stdc++.h>
#define N 45
#define ll long long
#define mo 1000000007
ll qpow(ll x,ll y=mo-2){
ll r=1;
for (;y;y>>=1,x=x*x%mo)
if (y&1)
r=r*x%mo;
return r;
}
int n;
int a[N];
int c[N],p[N];
ll fac[N*2],ifac[N*2];
void initC(int n){
fac[0]=1;
for (int i=1;i<=n;++i)
fac[i]=fac[i-1]*i%mo;
ifac[n]=qpow(fac[n]);
for (int i=n-1;i>=0;--i)
ifac[i]=ifac[i+1]*(i+1)%mo;
}
ll C(int m,int n){return fac[m]*ifac[n]%mo*ifac[m-n]%mo;}
void init(){
scanf("%d",&n);
initC(n*2);
for (int i=1;i<=n;++i)
scanf("%d",&a[i]);
static int bz[N];
for (int i=1;i<=n;++i)
if (!bz[i]){
int t=0;
for (int x=i;!bz[x];x=a[x])
bz[x]=1,t++;
c[t]++;
}
p[0]=1;
for (int i=1;i<=n;++i)
p[i]=p[i-1]*(c[i]+1);
}
ll q[N];
ll f[1440];
ll g[1440][N][N];
void doit(){
for (int i=0;i<=n;++i){
ll s=0;
for (int j=0;j<=i;++j)
(s+=C(i,j)*fac[j]%mo*fac[n-1-j])%=mo;
q[i]=s;
}
for (int i=0;i<p[n];++i){
for (int t=0;t<=n;++t)
for (int j=1;j<=n;++j){
int w=i%p[j]/p[j-1];
ll qj=qpow(q[t],j),tmp=1;
for (int k=w;k<=c[j];++k){
(g[i+(k-w)*p[j-1]][j][t]+=g[i][j-1][t]*ifac[k-w]%mo*tmp)%=mo;
tmp=tmp*(-1)*qj%mo;
}
}
ll S=1,s=0;
if (i==0)
f[0]=1;
else{
for (int j=1;j<=n;++j){
int w=i%p[j]/p[j-1];
S=S*fac[w]%mo;
s+=w*j;
}
ll tmp=0;
for (int j=0;j<=s;++j)
(tmp+=g[i][n][j])%=mo;
f[i]=tmp*S%mo;
}
// (g[i][0][s]+=f[i]*qpow(S)*(-1))%=mo;
ll v=f[i]*qpow(S)*(-1)%mo;
for (int j=1;j<=n;++j){
int w=i%p[j]/p[j-1];
ll qj=qpow(q[s],j),tmp=(-1)*qj;
for (int k=w+1;k<=c[j];++k){
(g[i+(k-w)*p[j-1]][j][s]+=v*ifac[k-w]%mo*tmp)%=mo;
tmp=tmp*(-1)*qj%mo;
}
}
}
}
int main(){
init();
doit();
// for (int i=0;i<p[n];++i)
// printf("%lld\n",f[i]);
ll ans=f[p[n]-1];
ans=(ans+mo)%mo;
printf("%lld\n",ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int Max_N=40,Max_S=1440;
const long long Mod=(1e9)+7;
int n,Top,a[Max_N+5],q[Max_N*Max_N*Max_N+5],vis[Max_N+5],cnt[Max_N+5],siz[Max_S+5],Siz[Max_N*Max_N*Max_N+5];
long long f[Max_S+5],p[Max_N+5],h[Max_N*Max_N*Max_N+5],Inv[Max_N+5],g[Max_N+5][Max_N+5];
inline long long C(int N,int M){
if(N<M||N<0||M<0) return 0;
return p[N]*Inv[M]%Mod*Inv[N-M]%Mod;
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&a[i]);
for(int i=1;i<=n;i++){
int len=0,x=i;
for(;!vis[x];vis[x]=1,x=a[x],++len);
++cnt[len];
}
p[0]=Inv[0]=Inv[1]=1;
for(int i=1;i<=n;i++) p[i]=p[i-1]*i%Mod;
for(int i=2;i<=n;i++) Inv[i]=Inv[Mod%i]*(Mod-Mod/i)%Mod;
for(int i=1;i<=n;i++) Inv[i]=Inv[i]*Inv[i-1]%Mod;
for(int i=0;i<=n;i++){
for(int j=0;j<=i;j++) g[i][1]=(g[i][1]+C(i,j)*p[j]%Mod*p[n-j-1]%Mod)%Mod;
for(int j=2;j<=n;j++) g[i][j]=g[i][j-1]*g[i][1]%Mod;
}
int S=1;
for(int i=1;i<=n;i++) S*=(cnt[i]+1);
f[0]=1;
for(int i=1;i<S;i++){
int x=i,lim=1;
q[Top=1]=0; h[Top]=1; Siz[Top]=0;
for(int j=1;j<=n;j++){
int now=x%(cnt[j]+1);
siz[i]+=j*now;
for(int k=Top;k>=1;k--){
for(int v=1;v<=now;v++){
q[++Top]=q[k]+v*lim;
h[Top]=h[k]*C(now,v)%Mod;
Siz[Top]=Siz[k]+v;
}
}
lim*=(cnt[j]+1),x/=(cnt[j]+1);
}
for(int j=2;j<=Top;j++) f[i]=(f[i]+(Siz[j]&1?1:Mod-1)*f[i-q[j]]%Mod*h[j]%Mod*g[siz[i]-siz[q[j]]][siz[q[j]]])%Mod;
}
printf("%lld\n",f[S-1]);
return 0;
}
|
#include<bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
const int maxn=1e6+100;
const int M=1000000007;
typedef array<int,41> A;
struct hasher {
size_t operator()(const A& p) const {
size_t result = 0;
for (int i=1;i<=40;i++) result = result * 19260817 + p[i];
return result;
}
};
bool vis[50];
int f[50],n,mx,F[50][50],G[50][50],p[50],nf[50],inv[50];
int ways[50][50][50];
unordered_map<A,int,hasher> dp[41][41][41];
void add(int &x,int y){x+=y;if (x>=M)x-=M;}
int C(int x,int y){
if (y<0||y>x) return 0;
return 1ll*f[x]*nf[y]%M*nf[x-y]%M;
}
void init(){
inv[1]=1; for (int i=2;i<=n;i++) inv[i]=M-1ll*(M/i)*inv[M%i]%M;
f[0]=nf[0]=1; for (int i=1;i<=n;i++) f[i]=1ll*f[i-1]*i%M,nf[i]=1ll*nf[i-1]*inv[i]%M;
F[0][0]=f[n-1];
for (int i=0;i<=n-1;i++)
for (int j=1;j+i<=n-1;j++){
F[i][j]=0;
for (int x=0;x<=i;x++)
for (int y=0;y<=j;y++){
add(F[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M);
if (!y) add(G[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M);
}
}
for (int i=0;i<=n-1;i++)
for (int j=0;j+i<=n-1;j++){
int x=1,y=1;
for (int k=1;k<=n;k++){
x=1ll*x*F[i][j]%M;
y=1ll*y*G[i][j]%M;
ways[i][j][k]=(x-y+M)%M;
}
}
}
int solve(int lasttot,int tot,int block,A a){
if (dp[lasttot][tot][block].find(a)!=dp[lasttot][tot][block].end()){
return dp[lasttot][tot][block][a];
}
int ret=0,sum=n;
for (int i=1;i<=mx;i++) sum-=a[i]*i;
if (sum==n) return dp[lasttot][tot][block][a]=nf[block];
A tmp=a;
for (int i=1;i<=mx;i++) {
if (a[i]){
tmp[i]--;
add(ret,1ll*ways[sum-tot-lasttot][lasttot][i]*a[i]%M*solve(lasttot,tot+i,block+1,tmp)%M);
if (block) add(ret,1ll*ways[sum-tot][tot][i]*a[i]%M*nf[block]%M*solve(tot,i,1,tmp)%M);
tmp[i]++;
}
}
return dp[lasttot][tot][block][a]=ret;
}
int main(){
scanf("%d",&n);
init();
for (int i=1;i<=n;i++) scanf("%d",&p[i]);
A a;
for (int i=0;i<=40;i++) a[i]=0;
for (int i=1;i<=n;i++) if (!vis[i]){
int w=0,tmp=i;
while (!vis[tmp]){
w++;
vis[tmp]=1;
tmp=p[tmp];
}
a[w]++;
mx=max(mx,w);
}
printf("%d\n",solve(0,0,0,a));
return 0;
}
|
#include<bits/stdc++.h>
#define pb push_back
using namespace std;typedef long long ll;const int maxn=1e6+100;const int M=1000000007;typedef array<int,41> A;bool vis[50];
int f[50],n,mx,F[50][50],G[50][50],p[50],nf[50],inv[50];map<A,int> dp[41][41][41];
void add(int &x,int y){x+=y;if (x>=M)x-=M;}
int C(int x,int y){if (y<0||y>x) return 0;return 1ll*f[x]*nf[y]%M*nf[x-y]%M;}
void init(){inv[1]=1; for (int i=2;i<=n;i++) inv[i]=M-1ll*(M/i)*inv[M%i]%M;f[0]=nf[0]=1; for (int i=1;i<=n;i++) f[i]=1ll*f[i-1]*i%M,nf[i]=1ll*nf[i-1]*inv[i]%M;
F[0][0]=f[n-1];for (int i=0;i<=n-1;i++)for (int j=1;j+i<=n-1;j++){F[i][j]=0;
for (int x=0;x<=i;x++)for (int y=0;y<=j;y++){add(F[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M);
if (!y) add(G[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M);}}}
int solve(int lasttot,int tot,int block,A a){if (dp[lasttot][tot][block].find(a)!=dp[lasttot][tot][block].end())return dp[lasttot][tot][block][a];int ret=0,sum=n;
for (int i=1;i<=mx;i++) sum-=a[i]*i;if (sum==n) return nf[block];int cof=1,ic=1,r=F[sum-tot-lasttot][lasttot];int cof2=1,ic2=1,r2=F[sum-tot][tot];A tmp=a;
for (int i=1;i<=mx;i++) {cof=1ll*cof*r%M;cof2=1ll*cof2*r2%M;ic=1ll*ic*G[sum-tot-lasttot][lasttot]%M;ic2=1ll*ic2*G[sum-tot][tot]%M;
if (a[i]){tmp[i]--;add(ret,1ll*(cof-ic+M)*a[i]%M*solve(lasttot,tot+i,block+1,tmp)%M);
if (block) add(ret,1ll*(cof2-ic2+M)*a[i]%M*nf[block]%M*solve(tot,i,1,tmp)%M);tmp[i]++;}}return dp[lasttot][tot][block][a]=ret;}
int main(){scanf("%d",&n);init();for (int i=1;i<=n;i++) scanf("%d",&p[i]);A a;for (int i=0;i<=40;i++) a[i]=0;
for (int i=1;i<=n;i++) if (!vis[i]){int w=0,tmp=i;while (!vis[tmp]){w++;vis[tmp]=1;tmp=p[tmp];}a[w]++;mx=max(mx,w);}printf("%d\n",solve(0,0,0,a));return 0;} |
#include <bits/stdc++.h>
using namespace std;
const int N = 45,P = 1000000007;
using ll = long long;
ll qpow(ll a,ll b)
{
ll ret = 1;
while (b)
{
if (b & 1) ret = ret * a % P;
a = a * a % P;b >>= 1;
}
return ret;
}
int pp[N],a[N],s[N],p[N],b[N],idx,n;
ll f[1505][N][N],g[N][N];bool vis[N];
ll fac[N],ifac[N];
inline ll C(int n,int m) {return fac[n] * ifac[m] % P * ifac[n - m] % P;}
int main ()
{
ios::sync_with_stdio(false);
cin >> n;for (int i = 1;i <= n;i++) cin >> pp[i];
fac[0] = 1;for (int i = 1;i <= n;i++) fac[i] = fac[i - 1] * i % P;
ifac[n] = qpow(fac[n],P - 2);
for (int i = n;i > 0;--i) ifac[i - 1] = ifac[i] * i % P;
for (int i = 1;i <= n;i++)
{
int kk = 0;
if (!vis[i])
for (int j = i;!vis[j];vis[j] = 1,j = pp[j]) ++kk;
a[++idx] = kk;++s[kk];
}
sort(a + 1,a + idx + 1);p[n] = 1;
for (int i = n - 1;i >= 0;--i) p[i] = p[i + 1] * (s[i + 1] + 1);
int lt = p[0];
for (int i = 0;i < n;i++)
{
ll sum = 0;
for (int j = 0;j <= i;j++)
sum = (sum + fac[j] * fac[n - j - 1] % P * C(i,j)) % P;
g[i][0] = 1;
for (int j = 1;j <= n;j++) g[i][j] = g[i][j - 1] * sum % P;
}
f[0][0][0] = 1;cerr << lt << endl;
for (int l = 0;l < lt;l++)
{
int kk = l,ss = 0;
for (int i = 1;i <= n;i++)
b[i] = kk / p[i],kk %= p[i],ss += b[i] * i;
for (int i = 0;i <= ss;i++)
{
for (int j = 0;j < n;j++)
if (f[l][i][j])
{
for (int k = b[j + 1];k <= s[j + 1];k++)
f[l + (k - b[j + 1]) * p[j + 1]][i][j + 1] =
(f[l + (k - b[j + 1]) * p[j + 1]][i][j + 1] +
f[l][i][j] * g[i][(k - b[j + 1]) * (j + 1)] % P
* C(k,b[j + 1]) * ((k - b[j + 1]) & 1 ? -1 : 1)) % P;
}
if (i < ss) f[l][ss][0] = (f[l][ss][0] - f[l][i][n]) % P;
}
}
cout << (f[lt - 1][n][0] + P) % P << endl;
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 MOD = (ll)1e9 + 7;
ll add(ll x, ll y) {
x += y;
if (x >= MOD) return x - MOD;
return x;
}
ll sub(ll x, ll y) {
x -= y;
if (x < 0) return x + MOD;
return x;
}
ll mult(ll x, ll y) {
return (x * y) % MOD;
}
ll bin_pow(ll x, ll p) {
if (p == 0) return 1;
if (p & 1) return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
ll rev(ll x) {
return bin_pow(x, MOD - 2);
}
const int M = (int)2.3e5;
const int N = 41;
int C[N][N];
int f[N], rf[N];
int prec[N][N][N];
int n;
vector<pii> toVec[M];
map<vector<pii>, int> toId;
int remOne[M][N];
pii bySum[M];
int dp[M][N];
int m = 0;
int getId(vector<pii> p) {
if (toId.count(p) == 0) {
toId[p] = m;
toVec[m] = p;
return m++;
}
return toId[p];
}
void brute(vector<pii> p, int lst, int sum) {
int v = getId(p);
bySum[v] = mp(sum, v);
for (int x = lst; x + sum <= n; x++) {
for (int k = 1; sum + k * x <= n; k++) {
p.push_back(mp(x, k));
brute(p, x + 1, sum + x * k);
p.pop_back();
}
}
}
void precalc() {
for (int i = 0; i < N; i++)
C[i][0] = C[i][i] = 1;
for (int i = 1; i < N; i++)
for (int j = 1; j < i; j++)
C[i][j] = add(C[i - 1][j - 1], C[i - 1][j]);
f[0] = 1;
for (int i = 1; i < N; i++)
f[i] = mult(f[i - 1], i);
rf[N - 1] = rev(f[N - 1]);
for (int i = N - 1; i > 0; i--)
rf[i - 1] = mult(rf[i], i);
for (int g = 1; g < N; g++) {
prec[g][0][0] = bin_pow(f[n - 1], g);
for (int x = 1; x < N; x++)
for (int y = x; g + y <= n; y++) {
int A = 0, B = 0;
for (int k = 0; k <= y; k++)
A = add(A, mult(C[y][k], mult(f[k], f[n - 1 - k])));
for (int k = 0; k <= y - x; k++)
B = add(B, mult(C[y - x][k], mult(f[k], f[n - 1 - k])));
prec[g][x][y] = sub(bin_pow(A, g), bin_pow(B, g));
}
}
brute({}, 1, 0);
eprintf("m = %d\n", m);
eprintf("time = %.5lf\n", getCurrentTime());
for (int id = 0; id < m; id++) {
for (int x = 0; x <= n; x++)
remOne[id][x] = -1;
for (int i = 0; i < (int)toVec[id].size(); i++) {
if (i != 0 && toVec[id][i] == toVec[id][i - 1]) continue;
vector<pii> p = toVec[id];
p[i].second--;
if (p[i].second == 0)
p.erase(p.begin() + i);
remOne[id][toVec[id][i].first] = getId(p);
}
}
eprintf("time = %.5lf\n", getCurrentTime());
}
int read() {
vector<int> p(n);
map<int, int> res;
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
p[i]--;
}
for (int i = 0; i < n; i++) {
if (p[i] == -1) continue;
int v = i;
int len = 0;
while(p[v] != -1) {
len++;
int u = p[v];
p[v] = -1;
v = u;
}
res[len]++;
}
vector<pii> rr;
for (auto t : res) {
eprintf("(%d %d) ", t.first, t.second);
rr.push_back(t);
}
eprintf("\n");
return getId(rr);
}
void brute2(int pos, int oldId, int newId, int X, int Y, int val, int nX) {
if (pos == (int)toVec[oldId].size()) {
if (nX == 0) return;
dp[newId][nX] = add(dp[newId][nX], val);
return;
}
int z = toVec[oldId][pos].first;
for (int k = 0; k <= toVec[oldId][pos].second; k++) {
if (k != 0) {
newId = remOne[newId][z];
nX += z;
val = mult(val, prec[z][X][Y]);
}
brute2(pos + 1, oldId, newId, X, Y, mult(val, C[toVec[oldId][pos].second][k]), nX);
}
}
int main()
{
startTime = clock();
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
scanf("%d", &n);
precalc();
sort(bySum, bySum + m);
int v = read();
dp[v][0] = 1;
for (int i = m - 1; i >= 0; i--) {
v = bySum[i].second;
int sum = bySum[i].first;
for (int x = 0; x + sum <= n; x++) {
if (dp[v][x] == 0) continue;
//eprintf("dp[%d][%d] = %d\n", v, x, dp[v][x]);
brute2(0, v, v, x, n - sum, dp[v][x], 0);
}
}
int ans = 0;
for (int x = 1; x <= n; x++)
ans = add(ans, dp[0][x]);
printf("%d\n", ans);
return 0;
}
|
//Let's join Kaede Takagaki Fan Club !!
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define mp make_pair
#define pb push_back
#define fi first
#define sc second
#define rep(i,x) for(int i=0;i<x;i++)
#define repn(i,x) for(int i=1;i<=x;i++)
const ll mod = 1000000007;
ll F[50], R[50];
ll modpow(ll a, ll n){
ll ret = 1;
while(n){
if(n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
void init(){
F[0] = 1;
for(int i=1;i<50;i++) F[i] = F[i-1] * i % mod;
rep(i, 50) R[i] = modpow(F[i], mod-2);
}
ll C(int a, int b){
if(b < 0 || a < b) return 0LL;
return F[a] * R[b] % mod * R[a-b] % mod;
}
int n, go[42], vis[42];
vector<int>cmp;
ll coef[42][42][42];
ll solve(int old, int pre, vector<P>part);
ll make(int old, int pre, vector<P>cur, vector<P>&part, ll mm, int sz){
int id = cur.size();
ll sum = 0;
if(id == part.size()){
if(sz){
return solve(old+pre, sz, cur) * mm % mod;
}
else return 0LL;
}
for(int x=part[id].fi;x>=0;x--){
ll mm2 = mm * C(part[id].fi, x) % mod;
cur.pb(mp(x, part[id].sc));
sum += make(old, pre, cur, part, mm2, sz+(part[id].fi-x)*part[id].sc);
cur.pop_back();
mm = mm * coef[old][pre][part[id].sc] % mod;
}
return sum%mod;
}
unordered_map<ll, ll>M[42][42];
ll solve(int old, int pre, vector<P>part){
for(auto at:part) if(at.fi) goto nxt;
return 1LL; nxt:;
ll enc = 0;
for(auto at:part) enc = enc * 41LL + (at.fi + 1);
if(M[old][pre].find(enc) != M[old][pre].end()) return M[old][pre][enc];
return M[old][pre][enc] = make(old, pre, vector<P>(), part, 1, 0);
}
int main(){
init();
cin >> n;
repn(i, n) cin >> go[i];
repn(i, n){
if(vis[i]) continue;
int cur = i, cnt = 0;
while(!vis[cur]){
vis[cur] = 1;
cnt ++;
cur = go[cur];
}
cmp.pb(cnt);
}
sort(cmp.begin(), cmp.end());
vector<int>mm(n+1, 0);
rep(i, cmp.size()) mm[cmp[i]] ++;
vector<P>m;
rep(i, n+1) if(mm[i]) m.pb(mp(mm[i], i));
rep(x, n+1){
repn(y, n-x){
repn(z, n-x-y){
ll sum = 0;
ll sum2 = 0;
rep(i, x+1) {
sum += C(x, i) * C(y, 0) % mod * F[i+0] % mod * F[n-1-i-0] % mod;
}
rep(i, x+1) rep(j, y+1){
sum2 += C(x, i) * C(y, j) % mod * F[i+j] % mod * F[n-1-i-j] % mod;
}
sum %= mod;
sum2 %= mod;
coef[x][y][z] = modpow(sum2, z) - modpow(sum, z);
if(coef[x][y][z] < 0) coef[x][y][z] += mod;
}
}
}
repn(x, n) coef[0][0][x] = modpow(F[n-1], x);
cout << solve(0, 0, m) << endl;
} |
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define endl '\n'
#define ll long long
#define pi pair<int, int>
#define f first
#define s second
const int mod = 1000000007;
const int mxn = 41, mxm = 1500;
int n;
ll a[mxn], b[mxn], c[mxn], p[mxn], f[mxn], iv[mxn], vis[mxn];
ll ff[mxn][mxn], g[mxn][mxn];
ll dp[mxm][mxn][mxn];
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for(int i = 0; i < n; i++) cin >> a[i], a[i]--;
for(int i = 0; i < n; i++) if(!vis[i]){
int x = 0;
for(int j = i; !vis[j]; j = a[j]) x++, vis[j] = 1;
b[x]++;
}
p[n] = 1;
for(int i = n; i; i--) p[i - 1] = (b[i] + 1) * p[i];
f[0] = iv[0] = ff[0][0] = 1;
for(int i = 1; i <= n; i++){
iv[i] = ~-i ? mod - mod / i * iv[mod % i] % mod : 1;
f[i] = i * f[i - 1] % mod;
ff[i][0] = 1;
for(int j = 1; j <= i; j++){
ff[i][j] = (ff[i - 1][j] + ff[i - 1][j - 1]) % mod;
}
}
for(int i = 0; i <= n; i++){
ll x = f[n] * iv[n - i] % mod;
g[i][0] = 1;
for(int j = 1; j <= n; j++) g[i][j] = x * g[i][j - 1] % mod;
}
dp[0][0][0] = 1;
for(int i = 0; i < p[0]; i++){ //cycle counts
int x = i, y = 0;
for(int j = 1; j <= n; j++) c[j] = x / p[j], x %= p[j], y += c[j] * j;
for(int j = 0; j <= y; j++){ //rounds passed
for(int k = 1; k <= n; k++) //cycle size added
for(int l = 0; l <= b[k] - c[k]; l++){
(dp[i + l * p[k]][j][k] += mod + (1 - 2 * (l & 1)) *
dp[i][j][k - 1] * g[j][k * l] % mod * ff[l + c[k]][c[k]]) %= mod;
}
if(j < y) (dp[i][y][0] += mod - dp[i][j][n]) %= mod;
}
}
cout << dp[p[0] - 1][n][0] << endl;
return 0;
} |
#include<bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
const int maxn=1e6+100;
const int M=1000000007;
typedef array<int,41> A;
bool vis[50];
int f[50],n,mx,F[50][50],G[50][50],p[50],nf[50],inv[50];
map<A,int> dp[41][41][41];
void add(int &x,int y){x+=y;if (x>=M)x-=M;}
int C(int x,int y){
if (y<0||y>x) return 0;
return 1ll*f[x]*nf[y]%M*nf[x-y]%M;
}
void init(){
inv[1]=1; for (int i=2;i<=n;i++) inv[i]=M-1ll*(M/i)*inv[M%i]%M;
f[0]=nf[0]=1; for (int i=1;i<=n;i++) f[i]=1ll*f[i-1]*i%M,nf[i]=1ll*nf[i-1]*inv[i]%M;
F[0][0]=f[n-1];
for (int i=0;i<=n-1;i++)
for (int j=1;j+i<=n-1;j++){
F[i][j]=0;
for (int x=0;x<=i;x++)
for (int y=0;y<=j;y++){
add(F[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M);
if (!y) add(G[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M);
}
}
}
int solve(int lasttot,int tot,int block,A a){
if (dp[lasttot][tot][block].find(a)!=dp[lasttot][tot][block].end()){
return dp[lasttot][tot][block][a];
}
int ret=0,sum=n;
for (int i=1;i<=mx;i++) sum-=a[i]*i;
if (sum==n) return nf[block]; //a = {0,0,...}
int cof=1,ic=1,r=F[sum-tot-lasttot][lasttot];
int cof2=1,ic2=1,r2=F[sum-tot][tot];
A tmp=a;
for (int i=1;i<=mx;i++) {
cof=1ll*cof*r%M;
cof2=1ll*cof2*r2%M;
ic=1ll*ic*G[sum-tot-lasttot][lasttot]%M;
ic2=1ll*ic2*G[sum-tot][tot]%M;
if (a[i]){
tmp[i]--;
add(ret,1ll*(cof-ic+M)*a[i]%M*solve(lasttot,tot+i,block+1,tmp)%M);
if (block) add(ret,1ll*(cof2-ic2+M)*a[i]%M*nf[block]%M*solve(tot,i,1,tmp)%M);
tmp[i]++;
}
}
return dp[lasttot][tot][block][a]=ret;
}
int main(){
scanf("%d",&n);
init();
for (int i=1;i<=n;i++) scanf("%d",&p[i]);
A a;
for (int i=0;i<=40;i++) a[i]=0;
for (int i=1;i<=n;i++) if (!vis[i]){
int w=0,tmp=i;
while (!vis[tmp]){
w++;
vis[tmp]=1;
tmp=p[tmp];
}
a[w]++;
mx=max(mx,w);
}
printf("%d\n",solve(0,0,0,a));
return 0;
}
|
#include<bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
const int maxn=1e6+100;
const int M=1000000007;
typedef array<int,41> A;
bool vis[50];
int f[50],n,mx,F[50][50],G[50][50],p[50],nf[50],inv[50];
int ways[50][50][50];
map<A,int> dp[41][41][41];
void add(int &x,int y){x+=y;if (x>=M)x-=M;}
int C(int x,int y){
if (y<0||y>x) return 0;
return 1ll*f[x]*nf[y]%M*nf[x-y]%M;
}
void init(){
inv[1]=1; for (int i=2;i<=n;i++) inv[i]=M-1ll*(M/i)*inv[M%i]%M;
f[0]=nf[0]=1; for (int i=1;i<=n;i++) f[i]=1ll*f[i-1]*i%M,nf[i]=1ll*nf[i-1]*inv[i]%M;
F[0][0]=f[n-1];
for (int i=0;i<=n-1;i++)
for (int j=1;j+i<=n-1;j++){
F[i][j]=0;
for (int x=0;x<=i;x++)
for (int y=0;y<=j;y++){
add(F[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M);
if (!y) add(G[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M);
}
}
for (int i=0;i<=n-1;i++)
for (int j=0;j+i<=n-1;j++){
int x=1,y=1;
for (int k=1;k<=n;k++){
x=1ll*x*F[i][j]%M;
y=1ll*y*G[i][j]%M;
ways[i][j][k]=(x-y+M)%M;
}
}
}
int solve(int lasttot,int tot,int block,A a){
if (dp[lasttot][tot][block].find(a)!=dp[lasttot][tot][block].end()){
return dp[lasttot][tot][block][a];
}
int ret=0,sum=n;
for (int i=1;i<=mx;i++) sum-=a[i]*i;
if (sum==n) return dp[lasttot][tot][block][a]=nf[block];
A tmp=a;
for (int i=1;i<=mx;i++) {
if (a[i]){
tmp[i]--;
add(ret,1ll*ways[sum-tot-lasttot][lasttot][i]*a[i]%M*solve(lasttot,tot+i,block+1,tmp)%M);
if (block) add(ret,1ll*ways[sum-tot][tot][i]*a[i]%M*nf[block]%M*solve(tot,i,1,tmp)%M);
tmp[i]++;
}
}
return dp[lasttot][tot][block][a]=ret;
}
int main(){
scanf("%d",&n);
init();
for (int i=1;i<=n;i++) scanf("%d",&p[i]);
A a;
for (int i=0;i<=40;i++) a[i]=0;
for (int i=1;i<=n;i++) if (!vis[i]){
int w=0,tmp=i;
while (!vis[tmp]){
w++;
vis[tmp]=1;
tmp=p[tmp];
}
a[w]++;
mx=max(mx,w);
}
printf("%d\n",solve(0,0,0,a));
return 0;
}
|
#include <bits/stdc++.h>
#define fo(a,b,c) for (a=b; a<=c; a++)
#define fd(a,b,c) for (a=b; a>=c; a--)
#define C(n,m) (jc[n]*Jc[m]%mod*Jc[(n)-(m)]%mod)
#define add(a,b) a=((a)+(b))%mod
#define mod 1000000007
#define Mod 1000000005
#define ll long long
//#define file
using namespace std;
int P[41],a[41],s[41],p[42],b[41],tot,n,i,j,k,l,L,S;
ll f[1501][41][41],g[41][41],ans;
ll jc[41],Jc[41],sum;
bool Bz[41];
ll qpower(ll a,int b) {ll ans=1; while (b) {if (b&1) ans=ans*a%mod;a=a*a%mod;b>>=1;} return ans;}
void init()
{
jc[0]=1;
fo(i,1,n) jc[i]=jc[i-1]*i%mod;
Jc[n]=qpower(jc[n],Mod);
fd(i,n-1,0) Jc[i]=Jc[i+1]*(i+1)%mod;
fo(i,1,n) {k=0;if (!Bz[i]) {for (l=i; !Bz[l]; Bz[l]=1,l=P[l]) ++k;a[++tot]=k;++s[k];}}
sort(a+1,a+tot+1);
p[n]=1;
fd(i,n-1,0) p[i]=p[i+1]*(s[i+1]+1);
}
int main()
{
#ifdef file
freopen("CF1466H.in","r",stdin);
#endif
scanf("%d",&n);
fo(i,1,n) scanf("%d",&P[i]);
init();L=p[0];
fo(i,0,n-1)
{
sum=0;
fo(j,0,i) add(sum,jc[j]*jc[n-j-1]%mod*C(i,j));
g[i][0]=1;
fo(j,1,n) g[i][j]=g[i][j-1]*sum%mod;
}
f[0][0][0]=1;
fo(l,0,L-1)
{
k=l;S=0;
fo(i,1,n) b[i]=k/p[i],k%=p[i],S+=b[i]*i;
fo(i,0,S)
{
fo(j,0,n-1)
{
if (f[l][i][j])
{
fo(k,b[j+1],s[j+1])
add(f[l+(k-b[j+1])*p[j+1]][i][j+1],f[l][i][j]*g[i][(k-b[j+1])*(j+1)]%mod*C(k,b[j+1])*(((k-b[j+1])&1)?-1:1));
}
}
if (i<S) add(f[l][S][0],-f[l][i][n]);
}
}
ans=f[L-1][n][0];
printf("%lld\n",(ans+mod)%mod);
fclose(stdin);
fclose(stdout);
return 0;
} |
//#define DEBUG
//#define USEPB_DS
#define USETR1
#define CPPELEVEN
#define GPP
/*
* temp.cpp
*
* Created on: 2012-7-18
* Author: BSBandme
*/
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#if __cplusplus < 201500L
#include <bits/stdc++.h>
#else
#include <iostream>
#include <fstream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <string>
#include <vector>
#include <queue>
#include <cassert>
#include <list>
#include <iomanip>
#include <cmath>
#include <deque>
#include <utility>
#include <map>
#include <set>
#include <bitset>
#include <numeric>
#include <climits>
#include <cctype>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <functional>
#include <sstream>
#include <tuple>
#endif
using namespace std;
#ifndef CPPELEVEN
#ifdef USETR1
#include <tr1/unordered_map>
#include <tr1/unordered_set>
using namespace tr1;
#endif
#else
#include <unordered_map>
#include <unordered_set>
#endif
#ifdef USEPB_DS
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
// binomial_heap_tag, rc_binomial_heap_tag, thin_heap_tag, binary_heap_tag
typedef __gnu_pbds::priority_queue<int, greater<int>, pairing_heap_tag> pq_type;
// splay_tree_tag, ov_tree_tag
typedef tree <int, null_type, less <int>, rb_tree_tag, tree_order_statistics_node_update> tree_type;
#endif
#define mpr make_pair
typedef unsigned int ui;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<string> vs;
typedef map<string, int> mpsi;
typedef map<double, int> mpdi;
typedef map<int, int> mpii;
const double pi = acos(0.0) * 2.0;
const long double eps = 1e-10;
const int step[8][2] = { { -1, 0 }, { 0, 1 }, { 1, 0 }, { 0, -1 }, { -1, 1 }, {
1, 1 }, { 1, -1 }, { -1, -1 } };
template<class T> inline T abs1(T a) {
return a < 0 ? -a : a;
}
#ifndef CPPELEVEN
template <class T> inline T max1(T a, T b) { return b < a ? a : b; }
template <class T> inline T max1(T a, T b, T c) { return max1(max1(a, b), c); }
template <class T> inline T max1(T a, T b, T c, T d) { return max1(max1(a, b, c), d); }
template <class T> inline T max1(T a, T b, T c, T d, T e) { return max1(max1(a, b, c, d), e); }
template <class T> inline T min1(T a, T b) { return a < b ? a : b; }
template <class T> inline T min1(T a, T b, T c) { return min1(min1(a, b), c); }
template <class T> inline T min1(T a, T b, T c, T d) { return min1(min1(a, b, c), d); }
template <class T> inline T min1(T a, T b, T c, T d, T e) { return min1(min1(a, b, c, d), e); }
#else
template<typename t, typename t1>
t min1(t a, t1 b) {
return a < b ? a : b;
}
template<typename t, typename ... arg>
t min1(t a, arg ... arr) {
return min1(a, min1(arr...));
}
template<typename t, typename t1>
t max1(t a, t1 b) {
return a > b ? a : b;
}
template<typename t, typename ... arg>
t max1(t a, arg ... arr) {
return max1(a, max1(arr...));
}
#endif
inline int jud(double a, double b) {
if (abs(a) < eps && abs(b) < eps)
return 0;
else if (abs1(a - b) / max(abs1(a), abs1(b)) < eps) return 0;
if (a < b) return -1;
return 1;
}
template<typename t> inline int jud(t a, t b) {
if (a < b) return -1;
if (a == b) return 0;
return 1;
}
// f_lb == 1代表返回相同的一串的左边界，f_small == 1代表返回如果没有寻找的值返回小的数
template<typename it, typename t1>
inline int RangeFind(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
if (na == 0) return 0;
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1) be--;
if (!f_small && jud(*(a + be), val) == -1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1) be--;
if (f_small && jud(*(a + be), val) == 1) be++;
}
return be;
}
template<class T> inline T lowb(T num) {
return num & (-num);
}
#ifdef GPP
inline int bitnum(ui nValue) {
return __builtin_popcount(nValue);
}
inline int bitnum(int nValue) {
return __builtin_popcount(nValue);
}
inline int bitnum(ull nValue) {
return __builtin_popcountll(nValue);
}
inline int bitnum(ll nValue) {
return __builtin_popcountll(nValue);
}
inline int bitmaxl(ui a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(int a) {
if (a == 0) return 0;
return 32 - __builtin_clz(a);
}
inline int bitmaxl(ull a) {
if (a == 0) return 0;
return 64 - __builtin_clzll(a);
}
inline int bitmaxl(ll a) {
if (a == 0) return 0;
return 64 - __builtin_clzll(a);
}
#else
#endif
long long pow(long long n, long long m, long long mod = 0) {
if (m < 0) return 0;
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
#define MOD 1000000007
template<class t1, class t2>
inline void add(t1 &a, t2 b, int mod = -1) {
if (mod == -1) mod = MOD;
a += b;
while (a >= mod)
a -= mod;
while (a < 0)
a += mod;
}
template<class t>
void output1(t arr) {
for (int i = 0; i < (int) arr.size(); i++)
cerr << arr[i] << ' ';
cerr << endl;
}
template<class t>
void output2(t arr) {
for (int i = 0; i < (int) arr.size(); i++)
output1(arr[i]);
}
//....................密..........封..........线..........下..........禁..........止..........hack...............................................
const int maxn = 44;
const int mod = MOD;
int n;
int per[maxn];
int loop_cnt[maxn];
ll fac[maxn], invfac[maxn];
struct Status {
vector<pii> loops;
int sum, last;
Status(const vector<pii>& all) : Status(all, 0) {}
Status(const vector<pii>& all, int rlast) {
sum = 0;
last = rlast;
loops.clear();
for (const auto& it : all) {
sum += it.first * it.second;
if (it.second) loops.push_back(it);
}
sort(loops.begin(), loops.end());
}
bool operator < (const Status& other) const {
if (last == other.last) {
if (sum == other.sum) return loops < other.loops;
return sum < other.sum;
}
return last < other.last;
}
bool operator == (const Status& other) const {
return sum == other.sum && loops == other.loops && last == other.last;
}
};
map<Status, ll> dp[maxn];
ll c(int a, int b) {
if (a < b) return 0;
return fac[a] * invfac[b] % mod * invfac[a - b] % mod;
}
ll tlast, tdp, tbef, rcnt_have, rcnt_no;
void Dfs(int deep, vector<pii>& loops, int rlast) {
if (deep == (int)loops.size()) {
if (rlast) {
add(dp[n - rlast - tlast - tbef][Status(loops, rlast)], tdp);
}
return;
}
int rcnt = loops[deep].second;
ll multi =
pow(rcnt_no, loops[deep].first, mod) - pow(rcnt_no - rcnt_have, loops[deep].first, mod) + mod;
multi %= mod;
for (int i = 0; i <= rcnt; i++) {
loops[deep].second = i;
ll rtdp = tdp;
tdp = tdp * c(rcnt, i) % mod;
tdp = tdp * pow(multi, rcnt - i, mod) % mod;
Dfs(deep + 1, loops, rlast + (rcnt - i) * loops[deep].first);
tdp = rtdp;
}
}
int main() {
//............................不要再忘了检查maxn大小了！！！！BSBandme你个SB！！！！...................................................
ios_base::sync_with_stdio(0);
#ifdef DEBUG //......................................................................................................
freopen("input.txt", "r", stdin);
#endif //...........................................................................................................
fac[0] = 1;
for (int i = 1; i < maxn; i++) {
fac[i] = fac[i - 1] * i % mod;
}
invfac[maxn - 1] = pow(fac[maxn - 1], mod - 2, mod);
for (int i = maxn - 2; i >= 0; i--) {
invfac[i] = invfac[i + 1] * (i + 1) % mod;
}
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", per + i);
per[i]--;
}
for (int i = 0; i < n; i++) if (per[i] != -1) {
int rcnt = -1;
for (int nxt = i; nxt != -1; rcnt++) {
int no = nxt;
nxt = per[nxt];
per[no] = -1;
}
loop_cnt[rcnt]++;
}
vector<pii> rs;
for (int i = 1; i <= n; i++) if (loop_cnt[i]) {
rs.push_back(mpr(i, loop_cnt[i]));
}
dp[n][Status(rs)] = 1;
for (int i = n; i > 0; i--) {
for (const auto& it : dp[i]) {
tlast = it.first.last;
tdp = it.second;
tbef = n - it.first.sum - tlast;
ll base = fac[tlast] * fac[tbef] % mod * fac[n - tlast - tbef - 1] % mod;
rcnt_have = base * c(n - tbef - 1, max(tlast - 1, 0ll)) % mod * c(n, tbef) % mod;
rcnt_no = base * c(n - tbef, tlast) % mod * c(n, tbef) % mod;
vector<pii> new_st = it.first.loops;
Dfs(0, new_st, 0);
}
}
ll ans = 0;
for (const auto& it : dp[0]) {
add(ans, it.second);
}
printf("%I64d\n", ans);
return 0;
}
|
#pragma GCC optimize(3)
#include<bits/stdc++.h>
#define pb push_back
using namespace std;
typedef long long ll;
const int maxn=1e6+100;
const int M=1000000007;
typedef array<int,41> A;
bool vis[50];
int f[50],n,mx,F[50][50],G[50][50],p[50],nf[50],inv[50];
int ways[50][50][50];
map<A,int> dp[41][41][41];
void add(int &x,int y){x+=y;if (x>=M)x-=M;}
int C(int x,int y){
if (y<0||y>x) return 0;
return 1ll*f[x]*nf[y]%M*nf[x-y]%M;
}
void init(){
inv[1]=1; for (int i=2;i<=n;i++) inv[i]=M-1ll*(M/i)*inv[M%i]%M;
f[0]=nf[0]=1; for (int i=1;i<=n;i++) f[i]=1ll*f[i-1]*i%M,nf[i]=1ll*nf[i-1]*inv[i]%M;
F[0][0]=f[n-1];
for (int i=0;i<=n-1;i++)
for (int j=1;j+i<=n-1;j++){
F[i][j]=0;
for (int x=0;x<=i;x++)
for (int y=0;y<=j;y++){
add(F[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M);
if (!y) add(G[i][j],1ll*C(i,x)*C(j,y)%M*f[n-1-x-y]%M*f[x+y]%M);
}
}
for (int i=0;i<=n-1;i++)
for (int j=0;j+i<=n-1;j++){
int x=1,y=1;
for (int k=1;k<=n;k++){
x=1ll*x*F[i][j]%M;
y=1ll*y*G[i][j]%M;
ways[i][j][k]=(x-y+M)%M;
}
}
}
int solve(int lasttot,int tot,int block,A a){
if (dp[lasttot][tot][block].find(a)!=dp[lasttot][tot][block].end()){
return dp[lasttot][tot][block][a];
}
int ret=0,sum=n;
for (int i=1;i<=n;i++) sum-=a[i]*i;
if (sum==n) return dp[lasttot][tot][block][a]=nf[block];
A tmp=a;
for (int i=1;i<=n;i++) {
if (a[i]){
tmp[i]--;
add(ret,1ll*ways[sum-tot-lasttot][lasttot][i]*a[i]%M*solve(lasttot,tot+i,block+1,tmp)%M);
if (block) add(ret,1ll*ways[sum-tot][tot][i]*a[i]%M*nf[block]%M*solve(tot,i,1,tmp)%M);
tmp[i]++;
}
}
return dp[lasttot][tot][block][a]=ret;
}
int main(){
scanf("%d",&n);
init();
for (int i=1;i<=n;i++) scanf("%d",&p[i]);
A a;
for (int i=0;i<=40;i++) a[i]=0;
for (int i=1;i<=n;i++) if (!vis[i]){
int w=0,tmp=i;
while (!vis[tmp]){
w++;
vis[tmp]=1;
tmp=p[tmp];
}
a[w]++;
mx=max(mx,w);
}
printf("%d\n",solve(0,0,0,a));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
const int P = 1000000007;
map<vector<array<int, 2>>, int> dp;
int n, p[50];
i64 C[50][50], fac[50];
long long Pow(int a, int b) {
long long ans = 1;
for (int i = 0; i < b; i++)
ans = ans * a % P;
return ans;
}
long long solve(vector<array<int, 2>> cycle) {
if (dp.count(cycle))
return dp[cycle];
if (cycle.empty())
return 1;
int tot = 0;
for (auto x : cycle)
tot += x[0] * x[1];
vector<array<int, 2>> rem;
i64 ans = 0;
function<void(int, int)> dfs = [&](int dep, i64 w) {
if (dep == cycle.size()) {
int ctot = 0;
for (auto x : rem)
ctot += x[0] * x[1];
if (ctot == tot)
return;
ans = (ans + w * Pow(C[tot][ctot] * fac[tot - ctot] % P, ctot) % P *
solve(rem)) %
P;
} else {
int c = cycle[dep][1], len = cycle[dep][0];
for (int j = 0; j <= c; j++) {
if (j != c)
rem.push_back({len, c - j});
dfs(dep + 1, w * C[c][j] % P);
if (j != c)
rem.pop_back();
w = (P - w * Pow(fac[tot - 1], len) % P);
}
}
};
dfs(0, P - 1);
return dp[cycle] = ans;
}
int vis[50], cnt[50];
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) {
C[i][i] = C[i][0] = 1;
for (int j = 1; j < i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
}
fac[0] = 1;
for (int i = 1; i <= n; i++) {
fac[i] = fac[i - 1] * i % P;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
}
/* for (int i = 1; i <= n; i++) {
p[i] = i;
}*/
i64 ans = 0;
// while (true) {
for (int i = 1; i <= n; i++)
vis[i] = 0, cnt[i] = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) {
int len = 0, j = i;
while (true) {
len += 1;
vis[j] = true;
j = p[j];
if (j == i)
break;
}
cnt[len] += 1;
}
vector<array<int, 2>> initc;
for (int i = 1; i <= n; i++)
if (cnt[i])
initc.push_back({i, cnt[i]});
i64 val = solve(initc);
ans = (ans + val) % P;
printf("%lld\n", val);
// printf("%lld\n", solve(initc));
// if (!next_permutation(p + 1, p + n + 1))
// break;
//}
// assert(ans == Pow(fac[n], n));
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long int LL;
#define st first
#define nd second
#define PII pair <int, int>
const int N = 60;
const int MX = 1e9 + 7;
struct state {
int sum_picked = 0;
int last_picked = 0, cur_picked = 0;
int iterator = 0;
vector <PII> lengths;
state(vector <PII> _lengths) {
lengths = _lengths;
}
/* operators for map comparisons */
bool operator<(const state &s) const {
if(lengths != s.lengths) return lengths < s.lengths;
if(last_picked != s.last_picked) return last_picked < s.last_picked;
if(cur_picked != s.cur_picked) return cur_picked < s.cur_picked;
return iterator < s.iterator;
}
bool operator==(const state &s) const {
if(last_picked != s.last_picked) return false;
if(cur_picked != s.cur_picked) return false;
if(iterator != s.iterator) return false;
if(lengths != s.lengths) return false;
return true;
}
};
int n;
vector <PII> cycles;
map <state, int> dp;
int sil[N], rv[N];
int pre[N][N][N];
int fast(int a, int b) {
int ret = 1;
while(b) {
if(b & 1)
ret = 1LL * ret * a % MX;
b >>= 1;
a = 1LL * a * a % MX;
}
return ret;
}
int newt(int a, int b) {
if(b < 0 || a < b)
return 0;
return 1LL * sil[a] * rv[b] % MX * rv[a - b] % MX;
}
PII get_ways(int a, int b) {
if(a == 0 && b == 0)
return {sil[n - 1], 0};
int ret = 0, ret2 = 0;
int c = n - a - 1;
for(int t = 1; t + c <= n; ++t) {
ret = (ret + 1LL * newt(n - t, c) * sil[c] % MX * newt(n - c - 1, b) % MX * sil[b] % MX * sil[a - b]) % MX;
ret2 = (ret2 + 1LL * newt(n - t, c) * sil[c] % MX * newt(n - t - c, b) % MX * sil[b] % MX * sil[a - b]) % MX;
}
return {ret, ret2};
}
void precalc() {
sil[0] = 1;
for(int i = 1; i <= n; ++i)
sil[i] = 1LL * sil[i - 1] * i % MX;
rv[n] = fast(sil[n], MX - 2);
for(int i = n; i >= 1; --i)
rv[i - 1] = 1LL * rv[i] * i % MX;
for(int i = 0; i < n; ++i)
for(int j = 0; j <= i; ++j) {
if(i && j == 0)
continue;
auto [val, val2] = get_ways(i, j);
pre[i][j][0] = 1;
int res = 1, res2 = 1;
for(int k = 1; k <= n; ++k) {
res = 1LL * res * val % MX;
res2 = 1LL * res2 * val2 % MX;
pre[i][j][k] = (res + MX - res2) % MX;
}
}
}
void read() {
scanf("%d", &n);
precalc();
vector <int> input(n);
for(auto &v: input) {
scanf("%d", &v);
v--;
}
vector <bool> vis(n);
vector <int> cycle_lengths;
for(int i = 0; i < n; ++i) {
if(vis[i])
continue;
int cur = i;
int cycle_length = 0;
while(!vis[cur]) {
++cycle_length;
vis[cur] = true;
cur = input[cur];
}
cycle_lengths.push_back(cycle_length);
}
sort(cycle_lengths.begin(), cycle_lengths.end());
for(auto v: cycle_lengths) {
if(cycles.size() && cycles.back().st == v)
cycles.back().nd++;
else
cycles.push_back({v, 1});
}
}
int solve(state &cur) {
if(cur.sum_picked == n)
return 1;
if(dp.count(cur))
return dp[cur];
if(cur.iterator == (int)cur.lengths.size()) {
if(cur.cur_picked == 0)
return dp[cur] = 0;
state nxt = cur;
nxt.sum_picked += nxt.cur_picked;
nxt.last_picked = nxt.cur_picked;
nxt.cur_picked = 0;
nxt.iterator = 0;
return dp[cur] = solve(nxt);
}
state nxt = cur;
nxt.iterator++;
int ret = 0, tmp = 1;
auto [length, count] = cur.lengths[cur.iterator];
for(int i = 0; i <= count; ++i) {
nxt.cur_picked = cur.cur_picked + i * length;
nxt.lengths[cur.iterator].nd = count - i;
ret = (ret + 1LL * solve(nxt) * tmp % MX * newt(count, i)) % MX;
tmp = 1LL * tmp * pre[cur.sum_picked][cur.last_picked][length] % MX;
}
return dp[cur] = ret;
}
int main() {
read();
state start = state(cycles);
int ans = solve(start);
printf("%d\n", ans);
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = long double; // or double, if TL is tight
using str = string; // yay python!
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using pd = pair<db,db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
#define tcT template<class T
#define tcTU tcT, class U
// ^ lol this makes everything look weird but I'll try it
tcT> using V = vector<T>;
tcT, size_t SZ> using AR = array<T,SZ>;
tcT> using PR = pair<T,T>;
// pairs
#define mp make_pair
#define f first
#define s second
// vectors
// oops size(x), rbegin(x), rend(x) need C++17
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) bg(x), end(x)
#define rall(x) x.rbegin(), x.rend()
#define sor(x) sort(all(x))
#define rsz resize
#define ins insert
#define ft front()
#define bk back()
#define pb push_back
#define eb emplace_back
#define pf push_front
#define lb lower_bound
#define ub upper_bound
tcT> int lwb(V<T>& a, const T& b) { return int(lb(all(a),b)-bg(a)); }
// loops
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x)
const int MOD = 1e9+7; // 998244353;
const int MX = 2e5+5;
const ll INF = 1e18; // not too close to LLONG_MAX
const db PI = acos((db)-1);
const int dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1}; // for every grid problem!!
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;
// bitwise ops
// also see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
constexpr int bits(int x) { // assert(x >= 0); // make C++11 compatible until USACO updates ...
return x == 0 ? 0 : 31-__builtin_clz(x); } // floor(log2(x))
constexpr int p2(int x) { return 1<<x; }
constexpr int msk2(int x) { return p2(x)-1; }
ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down
tcT> bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0; } // set a = min(a,b)
tcT> bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0; }
tcTU> T fstTrue(T lo, T hi, U f) {
hi ++; assert(lo <= hi); // assuming f is increasing
while (lo < hi) { // find first index such that f is true
T mid = lo+(hi-lo)/2;
f(mid) ? hi = mid : lo = mid+1;
}
return lo;
}
tcTU> T lstTrue(T lo, T hi, U f) {
lo --; assert(lo <= hi); // assuming f is decreasing
while (lo < hi) { // find first index such that f is true
T mid = lo+(hi-lo+1)/2;
f(mid) ? lo = mid : hi = mid-1;
}
return lo;
}
tcT> void remDup(vector<T>& v) { // sort and remove duplicates
sort(all(v)); v.erase(unique(all(v)),end(v)); }
tcTU> void erase(T& t, const U& u) { // don't erase
auto it = t.find(u); assert(it != end(t));
t.erase(it); } // element that doesn't exist from (multi)set
// INPUT
#define tcTUU tcT, class ...U
tcT> void re(complex<T>& c);
tcTU> void re(pair<T,U>& p);
tcT> void re(V<T>& v);
tcT, size_t SZ> void re(AR<T,SZ>& a);
tcT> void re(T& x) { cin >> x; }
void re(double& d) { str t; re(t); d = stod(t); }
void re(long double& d) { str t; re(t); d = stold(t); }
tcTUU> void re(T& t, U&... u) { re(t); re(u...); }
tcT> void re(complex<T>& c) { T a,b; re(a,b); c = {a,b}; }
tcTU> void re(pair<T,U>& p) { re(p.f,p.s); }
tcT> void re(V<T>& x) { trav(a,x) re(a); }
tcT, size_t SZ> void re(AR<T,SZ>& x) { trav(a,x) re(a); }
tcT> void rv(int n, V<T>& x) { x.rsz(n); re(x); }
// TO_STRING
#define ts to_string
str ts(char c) { return str(1,c); }
str ts(const char* s) { return (str)s; }
str ts(str s) { return s; }
str ts(bool b) {
// #ifdef LOCAL
// return b ? "true" : "false";
// #else
return ts((int)b);
// #endif
}
tcT> str ts(complex<T> c) {
stringstream ss; ss << c; return ss.str(); }
str ts(V<bool> v) {
str res = "{"; F0R(i,sz(v)) res += char('0'+v[i]);
res += "}"; return res; }
template<size_t SZ> str ts(bitset<SZ> b) {
str res = ""; F0R(i,SZ) res += char('0'+b[i]);
return res; }
tcTU> str ts(pair<T,U> p);
tcT> str ts(T v) { // containers with begin(), end()
#ifdef LOCAL
bool fst = 1; str res = "{";
for (const auto& x: v) {
if (!fst) res += ", ";
fst = 0; res += ts(x);
}
res += "}"; return res;
#else
bool fst = 1; str res = "";
for (const auto& x: v) {
if (!fst) res += " ";
fst = 0; res += ts(x);
}
return res;
#endif
}
tcTU> str ts(pair<T,U> p) {
#ifdef LOCAL
return "("+ts(p.f)+", "+ts(p.s)+")";
#else
return ts(p.f)+" "+ts(p.s);
#endif
}
// OUTPUT
tcT> void pr(T x) { cout << ts(x); }
tcTUU> void pr(const T& t, const U&... u) {
pr(t); pr(u...); }
void ps() { pr("\n"); } // print w/ spaces
tcTUU> void ps(const T& t, const U&... u) {
pr(t); if (sizeof...(u)) pr(" "); ps(u...); }
// DEBUG
void DBG() { cerr << "]" << endl; }
tcTUU> void DBG(const T& t, const U&... u) {
cerr << ts(t); if (sizeof...(u)) cerr << ", ";
DBG(u...); }
#ifdef LOCAL // compile with -DLOCAL, chk -> fake assert
#define dbg(...) cerr << "Line(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#define chk(...) if (!(__VA_ARGS__)) cerr << "Line(" << __LINE__ << ") -> function(" \
<< __FUNCTION__ << ") -> CHK FAILED: (" << #__VA_ARGS__ << ")" << "\n", exit(0);
#else
#define dbg(...) 0
#define chk(...) 0
#endif
void setPrec() { cout << fixed << setprecision(15); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
// FILE I/O
void setIn(str s) { freopen(s.c_str(),"r",stdin); }
void setOut(str s) { freopen(s.c_str(),"w",stdout); }
void setIO(str s = "") {
unsyncIO(); setPrec();
// cin.exceptions(cin.failbit);
// throws exception when do smth illegal
// ex. try to read letter into int
if (sz(s)) setIn(s+".in"), setOut(s+".out"); // for USACO
}
/**
* Description: modular arithmetic operations
* Source:
* KACTL
* https://codeforces.com/blog/entry/63903
* https://codeforces.com/contest/1261/submission/65632855 (tourist)
* https://codeforces.com/contest/1264/submission/66344993 (ksun)
* also see https://github.com/ecnerwala/cp-book/blob/master/src/modnum.hpp (ecnerwal)
* Verification:
* https://open.kattis.com/problems/modulararithmetic
*/
template<int MOD, int RT> struct mint {
static const int mod = MOD;
static constexpr mint rt() { return RT; } // primitive root for FFT
int v; explicit operator int() const { return v; } // explicit -> don't silently convert to int
mint() { v = 0; }
mint(ll _v) { v = int((-MOD < _v && _v < MOD) ? _v : _v % MOD);
if (v < 0) v += MOD; }
friend bool operator==(const mint& a, const mint& b) {
return a.v == b.v; }
friend bool operator!=(const mint& a, const mint& b) {
return !(a == b); }
friend bool operator<(const mint& a, const mint& b) {
return a.v < b.v; }
friend void re(mint& a) { ll x; re(x); a = mint(x); }
friend str ts(mint a) { return ts(a.v); }
mint& operator+=(const mint& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this; }
mint& operator-=(const mint& m) {
if ((v -= m.v) < 0) v += MOD;
return *this; }
mint& operator*=(const mint& m) {
v = int((ll)v*m.v%MOD); return *this; }
mint& operator/=(const mint& m) { return (*this) *= inv(m); }
friend mint pow(mint a, ll p) {
mint ans = 1; assert(p >= 0);
for (; p; p /= 2, a *= a) if (p&1) ans *= a;
return ans; }
friend mint inv(const mint& a) { assert(a.v != 0);
return pow(a,MOD-2); }
mint operator-() const { return mint(-v); }
mint& operator++() { return *this += 1; }
mint& operator--() { return *this -= 1; }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
};
typedef mint<MOD,5> mi; // 5 is primitive root for both common mods
typedef vector<mi> vmi;
typedef pair<mi,mi> pmi;
typedef vector<pmi> vpmi;
vector<vmi> scmb; // small combinations
void genComb(int SZ) {
scmb.assign(SZ,vmi(SZ)); scmb[0][0] = 1;
FOR(i,1,SZ) F0R(j,i+1)
scmb[i][j] = scmb[i-1][j]+(j?scmb[i-1][j-1]:0);
}
// mi dp[][];
int N;
map<pair<vi,vi>,mi> dp;
vi x;
int bef, rem;
mi perm[45][45];
mi no(int len) {
return pow(perm[bef-1][rem],len);
}
mi whatever(int len) {
return pow(perm[bef][rem],len);
}
mi yes(int len) {
return whatever(len)-no(len);
// return rem*perm[bef-1][rem-1];
}
vi cyc_len;
void dfs_add(vi y, mi num, int ind) {
if (ind == sz(x)) {
dp[{x,y}] += num;
return;
}
num *= pow(whatever(cyc_len[ind]),y[ind]);
int dif = x[ind]-y[ind];
mi YES = yes(cyc_len[ind]), NO = no(cyc_len[ind]);
F0R(j,dif+1) {
mi mul = num*scmb[dif][j]*pow(YES,j)*pow(NO,dif-j);
vi Y = y; Y[ind] = y[ind]+j;
dfs_add(Y,mul,ind+1);
}
// y[ind] are available: do whatever
// perm(bef,rem)
// x[ind]-y[ind] are not
// either rem*perm(bef-1,rem-1) -> make available
// or perm(bef-1,rem) -> not make available
}
int sum(vi v) { // OK
int res = 0;
F0R(i,sz(v)) res += v[i]*cyc_len[i];
return res;
}
int main() {
setIO();
re(N);
genComb(45);
F0R(i,45) {
perm[i][0] = 1;
FOR(j,1,i+1) perm[i][j] = perm[i][j-1]*(i+1-j);
}
// dbg(perm[4][3], perm[4][2]);
vi P(N); re(P);
trav(t,P) --t;
vb vis(N);
map<int,int> cyc;
F0R(i,N) if (!vis[i]) {
int cnt = 0;
int cur = i;
while (!vis[cur]) {
vis[cur] = 1;
++cnt;
cur = P[cur];
}
++ cyc[cnt];
}
vi st;
trav(t,cyc) {
cyc_len.pb(t.f);
st.pb(t.s);
}
// how many left, how many available
dp[{st,st}] = 1;
assert(sum(st) == N);
mi ans = 0;
while (sz(dp)) {
auto it = prev(end(dp));
pair<pair<vi,vi>,mi> a = *it; dp.erase(it);
// dbg("DOING",a);
int ind = 0; while (ind < sz(a.f.s) && a.f.s[ind] == 0) ++ind;
bef = sum(a.f.f);
if (ind == sz(a.f.s)) { // none to remove
if (bef == 0) ans += a.s;
continue;
}
{ // just ignore it
x = a.f.f; --a.f.s[ind];
dp[{x,a.f.s}] += a.s;
}
--x[ind];
rem = cyc_len[ind]; // # that were removed
a.s *= pow(perm[bef-1][bef-1],rem);
dfs_add(a.f.s,a.s,0);
}
ps(ans);
// F0R(i,1<<sz(cyc)) {
// trav(t,ok[i]) F0R(j,sz(cyc)) if (t.f&(1<<j)) { // res, # of ways
// int I = i^(1<<j);
// int T = t.f^(t.f&((1<<(j+1))-1));
// }
// }
// dbg(cyc);
// exit(0);
// F0R(i,N) if (!) {
// }
// you should actually read the stuff at the bottom
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
* DON'T GET STUCK ON ONE APPROACH
*/
|
#include <bits/stdc++.h>
#define mp std::make_pair
typedef std::pair<int, int> pii;
typedef std::vector<pii> vpii;
template <class T>
inline void read(T &res)
{
res = 0; bool bo = 0; char c;
while (((c = getchar()) < '0' || c > '9') && c != '-');
if (c == '-') bo = 1; else res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
const int N = 45, M = 3e5 + 5, EI = 1e9 + 7;
int n, p[N], ToT, son[M][N], Root, f[M], C[N][N], g[N], h[N][N], fac[N];
vpii nums[M];
bool vis[N];
int dfs(int cur, vpii now)
{
int u; nums[u = ++ToT] = now; vpii nxt = now;
int lst = now.empty() ? 0 : now[now.size() - 1].first;
for (int i = lst; i <= n - cur; i++) if (i)
{
if (i == lst) nxt[nxt.size() - 1].second++;
else nxt.push_back(mp(i, 1));
son[u][i] = dfs(cur + i, nxt);
nxt = now;
}
return u;
}
void dfs_trans(int u, int dep, int v, int in, int out,
int now, vpii &trans)
{
if (dep == nums[u].size())
{
if (u == v) return;
trans.push_back(mp(1ll * now * h[out][in] % EI, v));
return;
}
int x = nums[u][dep].second, y = nums[u][dep].first;
for (int i = 0; i <= x; i++)
dfs_trans(u, dep + 1, v, in, out, 1ll * now * C[x][i] % EI, trans),
v = son[v][y], in += y, out -= y, now = EI - now;
}
int dp(int u)
{
if (f[u] != -1) return f[u];
if (u == Root) return f[u] = 1;
vpii trans; int sze = 0, cnt = 0; f[u] = 0;
for (int i = 0; i < nums[u].size(); i++)
sze += nums[u][i].first * nums[u][i].second,
cnt += nums[u][i].second;
dfs_trans(u, 0, Root, 0, sze, cnt & 1 ? 1 : EI - 1, trans);
for (int i = 0; i < trans.size(); i++)
f[u] = (1ll * trans[i].first * dp(trans[i].second) + f[u]) % EI;
return f[u];
}
int main()
{
read(n); Root = dfs(0, vpii(0));
for (int i = 1; i <= n; i++) read(p[i]);
std::vector<int> cir;
for (int i = 1; i <= n; i++) if (!vis[i])
{
int c = 0;
for (int j = i; !vis[j]; j = p[j]) c++, vis[j] = 1;
cir.push_back(c);
}
int u = 1;
std::sort(cir.begin(), cir.end());
for (int i = 0; i < cir.size(); i++) u = son[u][cir[i]];
for (int i = 0; i <= n; i++) C[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % EI;
memset(f, -1, sizeof(f)); fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % EI;
for (int i = 0; i < n; i++)
{
for (int j = 0; j <= i; j++)
g[i] = (1ll * fac[j] * fac[n - j - 1] % EI * C[i][j] + g[i]) % EI;
h[0][i] = 1;
for (int j = 1; j <= n; j++)
h[j][i] = 1ll * h[j - 1][i] * g[i] % EI;
}
return std::cout << dp(u) << std::endl, 0;
} |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define ll long long
#define mod 1000000007
using namespace std;
int n;
int ft[50],sz[50];
int rep[50];
int mul[50],inv[50],sf[50];
int f[41][41][1441][41];
int g[41][41][41][41];
int tmp[50],psm[1500];
int op[1500][41];
int fnd(int x)
{
return x==ft[x]?x:ft[x]=fnd(ft[x]);
}
int qpow(int a,int b)
{
int ans=1;
for(;b;b>>=1,a=(ll)a*a%mod)
if(b&1)
ans=(ll)ans*a%mod;
return ans;
}
void init()
{
mul[0]=1;
for(int i=1;i<=n;i++)
mul[i]=(ll)mul[i-1]*i%mod;
inv[n]=qpow(mul[n],mod-2);
for(int i=n;i>=1;i--)
inv[i-1]=(ll)inv[i]*i%mod;
// for(int i=1;i<=n;i++)
// printf("i:%d mul:%d inv:%d\n",i,mul[i],inv[i]);
}
int cb(int a,int b)
{
return a<0||b<0||b>a?0:(ll)mul[a]*inv[b]%mod*inv[a-b]%mod;
}
int cal(int *s)
{
int ans=0;
for(int i=1;i<=n;i++)
ans+=s[i]*sf[i+1];
return ans;
}
void get(int x,int *s)
{
for(int i=1;i<=n;i++)
s[i]=x/sf[i+1],x%=sf[i+1];
}
int cs(int a)
{
// if(a==0)
// return mul[n-1];
int ans=0;
for(int i=0;i<=a;i++)
(ans+=(ll)cb(a,i)*mul[i]%mod*mul[n-i-1]%mod)%=mod;
return ans;
}
int main()
{
scanf("%d",&n);
init();
for(int i=1;i<=n;i++)
ft[i]=i;
for(int i=1;i<=n;i++)
{
int a;
scanf("%d",&a);
ft[fnd(i)]=fnd(a);
}
for(int i=1;i<=n;i++)
sz[fnd(i)]++;
for(int i=1;i<=n;i++)
if(sz[i])
rep[sz[i]]++;
sf[n+1]=1;
for(int i=n;i>=1;i--)
sf[i]=sf[i+1]*(rep[i]+1);
// for(int i=1;i<=n;i++)
// printf("i:%d rep:%d sf:%d\n",i,rep[i],sf[i]);
// printf("1 1:%d\n",cs(1,1));
int mx=sf[1]-1;
// printf("mx:%d\n",mx);
for(int i=0;i<=n;i++)
for(int j=0;j<=i;j++)
for(int t=1;t<=n;t++)
for(int r=1;r<=n;r++)
{
int ma=qpow(cs(i),t),mb=i==0?0:qpow(cs(i-j),t);
g[i][j][t][r]=(ll)qpow((ma-mb+mod)%mod,r)*inv[r]%mod;
}
for(int s=0;s<=mx;s++)
{
// psm[s]=n;
get(s,op[s]);
for(int i=1;i<=n;i++)
psm[s]+=op[s][i]*i;
}
f[0][0][mx][0]=1;
for(int i=0;i<=n;i++)
for(int j=0;j<=i;j++)
{
for(int t=1;t<=n;t++)
{
for(int s=0;s<=mx;s++)
{
if(psm[s]+i>n)
continue;
int *tmp=op[s];
// get(s,tmp);
// for(int k=n-i;k>=0;k--)
// if(psm[s]+i+k==n)
int k=n-psm[s]-i;
for(int r=1;r<=tmp[t]&&i+k+r*t<=n;r++)
f[i][j][s-r*sf[t+1]][k+r*t]=(f[i][j][s-r*sf[t+1]][k+r*t]+(ll)f[i][j][s][k]*g[i][j][t][r])%mod;
}
}
for(int s=0;s<=mx;s++)
for(int k=1;k<=n-i;k++)
{
// printf("i:%d j:%d s:%d k:%d f:%d\n",i,j,s,k,f[i][j][s][k]);
// if(k)
(f[i+k][k][s][0]+=f[i][j][s][k])%=mod;
}
}
int ans=0;
for(int i=1;i<=n;i++)
(ans+=f[n][i][0][0])%=mod;
for(int i=1;i<=n;i++)
ans=(ll)ans*mul[rep[i]]%mod;
printf("%d",ans);
return 0;
} |
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define REP(i,n) for(int i=0;i<(n);i++)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(),(x).end()
using namespace std;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long long ll;
template<class T> void read(T &x){
int f=0; x=0; char ch=getchar();
for(;!isdigit(ch);ch=getchar()) f|=(ch=='-');
for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';
if(f) x=-x;
}
const int mod=1e9+7,N=45;
int fac[N],rev[N],p[N],vis[N],n;
vi c;
int power(int x,int p){
int res=1;
for(;p;p>>=1,x=(ll)x*x%mod){
if(p&1) res=(ll)res*x%mod;
}
return res;
}
int C(int n,int m){
return m<0||m>n?0:(ll)fac[n]*rev[m]%mod*rev[n-m]%mod;
}
void init(){
fac[0]=1;
rep(i,1,n){
fac[i]=(ll)fac[i-1]*i%mod;
}
rev[n]=power(fac[n],mod-2);
per(i,n,1){
rev[i-1]=(ll)rev[i]*i%mod;
}
}
map<vi,int> f;
int solve(vi c);
int dfs(int k,vi now,vi &c,int coef){
// printf("dfs %d %d\n",k,coef);
// for(auto x:now) printf("%d ",x); puts("");
// for(auto x:c) printf("%d ",x); puts("");
if(k==n){
vi rem(n);
int cnt=0,tot=0;
REP(i,n){
rem[i]=c[i]-now[i];
cnt+=now[i]*(i+1);
tot+=rem[i]*(i+1);
}
if(!cnt) return 0;
int val,sum=0;
rep(i,0,tot){
val=(ll)fac[i]*fac[n-1-i]%mod*C(tot,i)%mod;
sum=(sum+val)%mod;
}
coef=(ll)coef*power(sum,cnt)%mod;
return (ll)solve(rem)*coef%mod;
}
int res=0;
rep(i,0,c[k]){
now.pb(i);
int cc=coef;
cc=(ll)cc*C(c[k],i)%mod;
if(i&1) cc=mod-cc;
res=(res+dfs(k+1,now,c,cc))%mod;
now.pop_back();
}
return res;
}
int solve(vi c){
if(f.count(c)) return f[c];
vi owo;
int res=dfs(0,owo,c,mod-1);
f[c]=res;
return res;
}
int main(){
read(n),init();
rep(i,1,n){
read(p[i]);
}
c.resize(n);
f[c]=1;
rep(i,1,n){
if(vis[i]) continue;
int x=p[i],cnt=0;
for(;x!=i;x=p[x]){
vis[x]=1,cnt++;
}
vis[x]=1,cnt++;
// cerr<<"#"<<cnt<<endl;
c[cnt-1]++;
}
cout<<solve(c)<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int p[50];
int val[50], pw[50], cnt[50], tp;
vector <int> sub[1000010];
long long f[50];
long long fac[50], inv[50];
int ttt[50];
int vis[50];
int dp[1000010];
void dfs(int x, int mask, int cur = 0) {
if (x == tp) {
sub[mask].push_back(cur);
return ;
}
for (int i = 0; i <= mask / pw[x] % cnt[x + 1]; i++) {
dfs(x + 1, mask, cur + i * pw[x]);
}
}
long long power(int a, int b) {
if (!b) return 1;
long long tmp = power(a, b >> 1);
return b & 1 ? tmp * tmp % mod * a % mod : tmp * tmp % mod;
}
long long C(int n, int k) {
return fac[n] * inv[k] % mod * inv[n - k] % mod;
}
int main () {
fac[0] = inv[0] = 1;
for (int i = 1; i <= 45; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = power(fac[i], mod - 2);
}
int n; cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
f[i] = (f[i] + 1ll * C(i, j) * fac[j] % mod * fac[n - j - 1]) % mod;
}
}
for (int i = 0; i < n; i++) {
cin >> p[i];
p[i]--;
}
vector <int> cir;
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
int cur = i, cnt = 0;
while (!vis[cur]) vis[cur] = 1, cur = p[cur], cnt++;
cir.push_back(cnt);
}
sort(cir.begin(), cir.end());
val[0] = -1, pw[0] = 1, cnt[0] = 0;
for (int i = 0; i < cir.size(); i++) {
int j = i;
while (j < cir.size() && cir[i] == cir[j]) j++;
val[++tp] = cir[i], pw[tp] = pw[tp - 1] * (j - i + 1), cnt[tp] = j - i + 1;
i = j - 1;
}
for (int mask = 0; mask < pw[tp]; mask++) {
dfs(0, mask);
}
dp[0] = 1;
for (int mask = 1; mask < pw[tp]; mask++) {
for (int i = 0; i < tp; i++) {
ttt[i] = mask / pw[i] % cnt[i + 1];
}
for (int i = 0; i < sub[mask].size(); i++) {
int mmm = sub[mask][i];
if (!mmm) continue;
long long mul = mod - 1;
int c0 = 0, c1 = 0;
for (int j = 0; j < tp; j++) {
int tmp = mmm / pw[j] % cnt[j + 1];
if (tmp & 1) mul = mul ? mod - mul : 0;
c0 += tmp * val[j + 1], c1 += (ttt[j] - tmp) * val[j + 1];
mul = mul * C(ttt[j], tmp) % mod;
}
mul = mul * power(f[c1], c0) % mod;
dp[mask] = (dp[mask] + dp[mask - mmm] * mul) % mod;
}
}
cout << dp[pw[tp] - 1] << endl;
return 0;
}
|
#include<cstdio>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
map<vector<int>,int>Map;
long long Comb[110][110], F[110], Mod = 1000000007, PO[110][110];
int vis[110], w[110];
long long Go(vector<int> T);
int C[50]={0}, ss = 0;
vector<int>ZZ;
void DFS(int pv, vector<vector<int>>&GG, long long t){
if(pv==ss+1){
ZZ.push_back(t);
GG.push_back(ZZ);
ZZ.pop_back();
return;
}
DFS(pv+1,GG,t);
for(int i=1;i<=C[pv];i++){
ZZ.push_back(pv);
DFS(pv+1,GG,t*Comb[C[pv]][i]%Mod);
}
for(int i=1;i<=C[pv];i++)ZZ.pop_back();
}
long long Pow(long long a, long long b){
long long r=1;
while(b){
if(b&1)r=r*a%Mod;
a=a*a%Mod;b>>=1;
}
return r;
}
long long Go(vector<int> T){
if(T.empty())return 1;
if(Map.count(T))return Map[T];
//printf("in\n");
vector<vector<int>>VV;
for(int i=0;i<=40;i++)C[i]=0;
ss=0;
int n =0;
for(auto &t : T){
C[t]++;
ss=max(ss,t);
n+=t;
}
DFS(0,VV,1);
long long ans = 0;
for(auto &t : VV){
if(t.size()==T.size()+1)continue;
vector<int>t2 = t;
long long ccc = t2.back();
t2.pop_back();
int z = n;
int ck=1;
if(T.size()%2==0)ck=-1;
for(auto &u : t2){
z-=u;
ck=-ck;
}
long long r = Go(t2);
//printf("%d\n",ck);
//printf("sub ");
// for(auto &u : t)printf("%d ",u);
// printf(": %lld ",r);
long long ttt = Comb[n][z]*F[z]%Mod;
ttt = Pow(ttt,n-z)*Pow(F[n-1],z)%Mod;
long long tot = r%Mod * ttt%Mod*ccc%Mod;
//printf(": %lld\n",tot);
//rintf("%d %d\n",ck,t2.size());
ans = (ans + tot*ck + Mod)%Mod;
}
Map[T]=ans;
//printf("out\n");
//printf("hey ");
//for(auto &t : T)printf("%d ",t);
//puts("");
//printf("%lld\n",ans);
return ans;
}
void Solve(){
int n, i;
scanf("%d",&n);
for(i=1;i<=n;i++){
scanf("%d",&w[i]);
}
vector<int>T;
for(i=1;i<=n;i++){
if(vis[i])continue;
int a = i, c=0;
while(1){
vis[a]=1;
c++;
a=w[a];
if(a==i)break;
}
T.push_back(c);
}
sort(T.begin(),T.end());
printf("%lld\n",Go(T));
}
int main(){
int TC = 1, i, j;
for(i=0;i<=100;i++){
Comb[i][0]=1;
for(j=1;j<=i;j++){
Comb[i][j]=(Comb[i-1][j-1]+Comb[i-1][j])%Mod;
}
}
for(i=0;i<=100;i++){
PO[i][0]=1;
for(j=1;j<=100;j++){
PO[i][j]=PO[i][j-1]*i%Mod;
}
}
F[0]=1;
for(i=1;i<=100;i++)F[i]=F[i-1]*i%Mod;
//po[0]=1;
//for(i=1;i<=1000000;i++)po[i]=po[i-1]*2%Mod;
while(TC--){
Solve();
}
} |
/* by Hyperhydrochloric Acid */
#include <bits/stdc++.h>
using namespace std;
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define loop(i, n) for(int i = 0; i < (n); ++i)
#define cont(i, n) for(int i = 1; i <= (n); ++i)
#define circ(i, a, b) for(int i = (a); i <= (b); ++i)
#define range(i, a, b, c) for(int i = (a); ((c) > 0 ? i <= (b) : i >= (b)); i += (c))
#define foreach(it, v) for(__typeof((v).begin()) it = (v).begin(); it != (v).end(); ++it)
#define y0 y0O0OO00OO0OO0OO0OOO00OO0OO0O0O000OO0
#define y1 y1II11II11III11I1III11II111IIII1II1I1
#define pub push_back
#define pob pop_back
#define mak make_pair
typedef long long ll;
typedef long double lf;
const int Inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fll;
/* Source code starts here */
const int jt = 1000000007;
int n;
int p[44];
bool lgl[44];
vector<int> cns;
int pre[44];
int ptr, len[44], siz[44];
int jc[44], C[44][44];
int dp[2222], mii[44][44];
int msk, all;
int cs[45];
void dfs(int cur, int nmsk, int siz, int rc) {
if(cur == ptr + 1) {
if(msk != nmsk) dp[msk] = (dp[msk] + 1ll * rc * dp[nmsk] % jt * mii[siz][all - siz]) % jt;
return;
}
loop(i, cs[cur] + 1) {
int mmsk = nmsk + pre[cur - 1] * (cs[cur] - i);
int nsiz = siz + ::siz[cur] * (cs[cur] - i);
int nrc = 1ll * rc * ((i & 1) ? jt - C[cs[cur]][i] : C[cs[cur]][i]) % jt;
dfs(cur + 1, mmsk, nsiz, nrc);
}
}
int main() {
scanf("%d", &n);
cont(i, n) scanf("%d", p + i);
cont(i, n) if(!lgl[i]) {
int j = i, cnt = 0;
while(!lgl[j]) {
lgl[j] = 1;
++cnt;
j = p[j];
}
cns.pub(cnt);
}
sort(all(cns)); pre[0] = 1;
int j = 0;
vector<int> szs;
loop(i, SZ(cns)) {
while(j < SZ(cns) && cns[i] == cns[j]) ++j;
len[++ptr] = j - i;
siz[ptr] = cns[i];
pre[ptr] = pre[ptr - 1] * (len[ptr] + 1);
i = j - 1;
}
jc[0] = 1; cont(i, n) jc[i] = 1ll * jc[i - 1] * i % jt;
loop(i, n + 1) C[i][0] = 1;
cont(i, n) cont(j, i) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % jt;
loop(i, n) {
mii[i][0] = 1;
loop(j, i + 1) mii[i][1] = (mii[i][1] + 1ll * jc[j] * jc[n - j - 1] % jt * C[i][j]) % jt;
circ(j, 2, n) mii[i][j] = 1ll * mii[i][j - 1] * mii[i][1] % jt;
}
dp[0] = 1;
cont(i, pre[ptr] - 1) {
msk = i; all = 0;
cont(j, ptr) cs[j] = i % pre[j] / pre[j - 1], all += cs[j] * siz[j];
dfs(1, 0, 0, jt - 1);
}
printf("%d\n", dp[pre[ptr] - 1]);
return 0;
} |
#include <bits/stdc++.h>
const int N = 1441, mod = 1e9 + 7;
inline int read()
{
int x = 0, f = 0; char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while ( isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
inline void upd(int &a, int b) { a = a + b >= mod ? a + b - mod : a + b; }
int p[N], v[N], c[N], fac[N], inv[N], tr[N][N], g[N][41][41], f[N];
inline int comb(int n, int m) { return 1LL * fac[n] * inv[m] % mod * inv[n - m] % mod; }
int main()
{
int n = read();
for (int i = 1; i <= n; ++i) p[i] = read();
for (int i = 1; i <= n; ++i) if (!v[i])
{
int len = 0, x = i;
for (; !v[x]; x = p[x]) v[x] = 1, ++len;
c[len]++;
}
p[0] = 1;
for (int i = 1; i <= n; ++i) p[i] = p[i - 1] * (c[i] + 1);
fac[0] = fac[1] = inv[0] = inv[1] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1LL * fac[i - 1] * i % mod;
for (int i = 2; i <= n; ++i) inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod;
for (int i = 1; i <= n; ++i) inv[i] = 1LL * inv[i - 1] * inv[i] % mod;
for (int i = 0; i <= n - 1; ++i) for (int j = 0; j <= i; ++j)
upd(tr[i][1], 1LL * fac[i] * inv[i - j] % mod * fac[n - j - 1] % mod);
for (int i = 0; i <= n; ++i) for (int j = 2; j <= n - i; ++j)
tr[i][j] = 1LL * tr[i][j - 1] * tr[i][1] % mod;
for (int i = 0; i <= n; ++i) tr[i][0] = 1;
// g[s][i][j] 已经用了 s 中的数，除掉一层前面有 i 个，这一层填了长度为 1~j 的环
// f[s] * comb(t, s) * (-1) ^ (|t \ s| + 1) * tr[sum(s)][sum(t \ s)] -> f[t]
g[0][0][n] = 1;
for (int s = 0; s < p[n]; ++s)
{
for (int i = 0; i <= n; ++i)
for (int j = 1; j <= n; ++j)
{
int w = s / p[j - 1] % (c[j] + 1);
for (int k = 0, x = 1; k <= c[j] - w; ++k, x = mod - x)
{
int dat = 1LL * g[s][i][j - 1] * tr[i][k * j] % mod * x % mod;
upd(g[s + k * p[j - 1]][i][j], 1LL * dat * comb(k + w, w) % mod);
}
}
int v = 0, _ = 0;
for (int i = 0; i <= n; ++i) upd(v, g[s][i][n]);
for (int i = 1; i <= n; ++i) _ += s / p[i - 1] % (c[i] + 1) * i;
f[s] = v;
g[s][_][0] = mod - f[s];
if (!s) g[0][0][0] = mod - 1;
for (int j = 1; j <= n; ++j)
{
int w = s / p[j - 1] % (c[j] + 1);
for (int k = 1, x = mod - 1; k <= c[j] - w; ++k, x = mod - x)
{
int dat = 1LL * g[s][_][0] * tr[_][k * j] % mod * x % mod;
upd(g[s + k * p[j - 1]][_][j], 1LL * dat * comb(k + w, w) % mod);
}
}
}
// for (int s = 0; s < p[n]; ++s, putchar('\n'))
// for (int i = 0; i <= n; ++i) printf("%d ", g[s][i][n]);
std::cout << f[p[n] - 1] << std::endl;
return 0;
} |
#include<bits/stdc++.h>
clock_t __t=clock();
namespace my_std{
using namespace std;
#define pii pair<int,int>
#define fir first
#define sec second
#define MP make_pair
#define rep(i,x,y) for (int i=(x);i<=(y);i++)
#define drep(i,x,y) for (int i=(x);i>=(y);i--)
#define go(x) for (int i=head[x];i;i=edge[i].nxt)
#define templ template<typename T>
#define sz 1555
#define mod 1000000007ll
typedef long long ll;
typedef double db;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
templ inline T rnd(T l,T r) {return uniform_int_distribution<T>(l,r)(rng);}
templ inline bool chkmax(T &x,T y){return x<y?x=y,1:0;}
templ inline bool chkmin(T &x,T y){return x>y?x=y,1:0;}
templ inline void read(T& t)
{
t=0;char f=0,ch=getchar();double d=0.1;
while(ch>'9'||ch<'0') f|=(ch=='-'),ch=getchar();
while(ch<='9'&&ch>='0') t=t*10+ch-48,ch=getchar();
if(ch=='.'){ch=getchar();while(ch<='9'&&ch>='0') t+=d*(ch^48),d*=0.1,ch=getchar();}
t=(f?-t:t);
}
template<typename T,typename... Args>inline void read(T& t,Args&... args){read(t); read(args...);}
char __sr[1<<21],__z[20];int __C=-1,__zz=0;
inline void Ot(){fwrite(__sr,1,__C+1,stdout),__C=-1;}
inline void print(int x)
{
if(__C>1<<20)Ot();if(x<0)__sr[++__C]='-',x=-x;
while(__z[++__zz]=x%10+48,x/=10);
while(__sr[++__C]=__z[__zz],--__zz);__sr[++__C]='\n';
}
void file()
{
#ifdef NTFOrz
freopen("a.in","r",stdin);
#endif
}
inline void chktime()
{
#ifdef NTFOrz
cout<<(clock()-__t)/1000.0<<'\n';
#endif
}
#ifdef mod
ll ksm(ll x,int y){ll ret=1;for (;y;y>>=1,x=x*x%mod) if (y&1) ret=ret*x%mod;return ret;}
ll inv(ll x){return ksm(x,mod-2);}
#else
ll ksm(ll x,int y){ll ret=1;for (;y;y>>=1,x=x*x) if (y&1) ret=ret*x;return ret;}
#endif
// ll mul(ll x,ll y){ull s=1.0*x/mod*y;ll res=1ull*x*y-s*mod;return (res%mod+mod)%mod;}
}
using namespace my_std;
int n,m;
int cnt[sz],pre[sz],tot[sz],a[sz][44];
ll _fac[sz],fac[sz];
void init()
{
static int p[sz],vis[sz];
rep(i,1,n) read(p[i]);
rep(i,1,n) if (!vis[i]) { vis[i]=1; int len=1; for (int x=p[i];x!=i;x=p[x]) vis[x]=1,++len; ++cnt[len]; }
m=1; rep(i,1,n) m*=(cnt[i]+1);
pre[1]=1; rep(i,2,n+1) pre[i]=pre[i-1]*(cnt[i-1]+1);
rep(i,0,m-1) { int x=i; rep(k,1,n) tot[i]+=(a[i][k]=x%(cnt[k]+1))*k,x/=(cnt[k]+1); }
_fac[0]=fac[0]=1; rep(i,1,sz-1) _fac[i]=inv(fac[i]=fac[i-1]*i%mod);
}
ll dp[sz][44][44][44];
int main()
{
file();
read(n); init();
rep(i,1,m-1) { ll w=ksm(1+tot[i]*inv(n-tot[i])%mod,n-tot[i]); rep(j,1,n) w=w*_fac[a[i][j]]%mod; dp[i][1][0][tot[i]]=w; }
ll ans=0;
rep(s,1,m-1) rep(i,1,n+1) rep(j,0,tot[s]) rep(k,1,n) if (dp[s][i][j][k])
{
ll w=dp[s][i][j][k];
if (i==n+1)
{
if (tot[s]==n) { (ans+=w)%=mod; continue; }
ll t=1+inv(n-tot[s])*j%mod;
w=w*ksm(t,n-tot[s])%mod; t=inv(t); ll cur1=1;
rep(k,1,n)
{
cur1=cur1*t%mod; ll cur=1;
rep(x,1,cnt[k]-a[s][k]) cur=cur*(mod+1-cur1)%mod,(dp[s+x*pre[k]][k+1][x*k][j]+=w*_fac[x]%mod*cur%mod)%=mod;
}
continue;
}
ll t=1+inv(n-tot[s]+j)*k%mod; t=ksm(t,mod-1-i); t=mod+1-t; ll cur=1;
rep(x,0,cnt[i]-a[s][i])
(dp[s+x*pre[i]][i+1][j+x*i][k]+=w*_fac[x]%mod*cur%mod)%=mod,cur=cur*t%mod;
}
chktime();
rep(i,1,n) ans=ans*fac[cnt[i]]%mod;
ans=ans*ksm(fac[n-1],n)%mod;
cout<<ans;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef string str;
#define pb push_back
#define ppp pop_back
#define pii pair<int,int>
#define fi first
#define se second
#define stie std::tie
#define vec vector
#define forn(i, l, r) for (int i=l; i<=r; i++)
#define emp empty
#define beg begin
#define ins insert
#define cle clear
#define era erase
#define que queue
#define pque priority_queue
#define mset multiset
#define deq deque
#define sta stack
#define con const
#define rsz resize
#define ass assign
#define lowb lower_bound
#define uppb upper_bound
template<class T> void mini(T& a, T b) { a = min(a, b); }
template<class T> void maxi(T& a, T b) { a = max(a, b); }
template<class T1, class T2> ostream& operator<<(ostream &out, pair<T1, T2> a) { return out << a.first << " " << a.second; }
template<class T> ostream& operator<<(ostream& out, vector<T> a) { for (auto& i : a) out << i << " "; return out; }
template<class T> ostream& operator<<(ostream& out, set<T> a) { for (auto& i : a) out << i << " "; return out; }
template<class T> ostream& operator<<(ostream& out, multiset<T> a) { for (auto& i : a) out << i << " "; return out; }
template<class T1, class T2> ostream& operator<<(ostream& out, map<T1, T2> a) { for (auto& i : a) out << i << "\n"; return out; }
template<class T1, class T2> ostream& operator<<(ostream& out, unordered_map<T1, T2> a) { for (auto& i : a) out << i << "\n"; return out; }
template<class T> ostream& operator<<(ostream& out, queue<T> a) { while (!a.empty()) { out << a.front() << " "; a.pop(); } return out; }
template<class T> ostream& operator<<(ostream& out, deque<T> a) { while (!a.empty()) { out << a.front() << " "; a.pop_front(); } return out; }
template<class T> ostream& operator<<(ostream& out, priority_queue<T> a) { while (!a.empty()) { out << a.top() << "\n"; a.pop(); } return out; }
template<class T> void out(T a) { cout << a << endl; }
template<class T1, class T2> void out(T1 a, T2 b) { cout << a << " " << b << endl; }
template<class T1, class T2, class T3> void out(T1 a, T2 b, T3 c) { cout << a << " " << b << " " << c << endl; }
template<class T1, class T2, class T3, class T4> void out(T1 a, T2 b, T3 c, T4 d) { cout << a << " " << b << " " << c << " " << d << endl; }
template<class T> void out(vector<vector<T>> a) { for (vector<T> i : a) out(i); }
void out() { cout << "OK" << endl; }
template<class T> void sort(vector<T>& a) { sort(a.begin(), a.end()); }
template<class T> void uniq(vector<T>& a) { sort(a); a.erase(unique(a.begin(), a.end()), a.end()); }
template<class T> vector<T> set_int(vector<T> a, vector<T> b) { sort(a); sort(b); vector<T> res; set_intersection(a.begin(), a.end(), b.begin(), b.end(), back_inserter(res)); return res; }
clock_t start_time; double get_time() { return (double)(clock() - start_time) / CLOCKS_PER_SEC; }
#if __SIZEOF_INT128__ >= 16
typedef __int128 LL;
istream& operator>>(istream& in, __int128& a) { int64_t b; cin >> b; a = b; return in; }
ostream& operator<<(ostream& out, const __int128 a) {
unsigned __int128 b = a < 0 ? -a : a; char buf[128]; char* c = end(buf); do { --c; *c = "0123456789"[b % 10]; b /= 10; } while (b);
if (a < 0) { --c; *c = '-'; } int len = end(buf) - c; out.rdbuf()->sputn(c, len); return out;
}
#endif
template<int m>
struct mint {
int x = 0;
mint(int64_t a = 0) { if (a < 0) a = a % m + m; if (a >= m) a %= m; x = a; }
friend istream& operator>>(istream& in, mint& a) { int64_t y; cin >> y; a = y; return in; }
friend ostream& operator<<(ostream& out, mint a) { return out << a.x; }
explicit operator int() const { return x; }
static int mod_inv(int a, int mod = m) {
// https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm#Example
int g = mod, r = a, z = 0, y = 1;
while (r != 0) { int q = g / r; g %= r; swap(g, r); z -= q * y; swap(z, y); }
return z < 0 ? z + mod : z;
}
mint inv() const { return mod_inv(x, m); }
friend mint binpow(mint a, int64_t b) { mint res = 1; while (b) { if (b & 1) res *= a; b >>= 1; a *= a; } return res; }
mint pow(int64_t b) const { return binpow(*this, b); }
mint operator-() const { return x ? m - x : 0; }
mint& operator+=(const mint& a) { x += a.x; if (x >= m) x -= m; return *this; }
mint& operator-=(const mint& a) { x -= a.x; if (x < 0) x += m; return *this; }
static unsigned fast_mod(uint64_t x, unsigned mod = m) {
#if !defined(_WIN32) || defined(_WIN64)
return x % mod;
#endif
// Optimized mod for Codeforces 32-bit machines.
// x must be less than 2^32 * mod for this to work, so that x / mod fits in a 32-bit integer.
unsigned x_high = x >> 32, x_low = (unsigned) x; unsigned quot, rem;
asm("divl %4\n" : "=a" (quot), "=d" (rem) : "d" (x_high), "a" (x_low), "r" (mod));
return rem;
}
mint& operator*=(const mint& a) { x = fast_mod((uint64_t) x * a.x); return *this; }
mint& operator/=(const mint& a) { return *this *= a.inv(); }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
mint& operator++() { x = x == m - 1 ? 0 : x + 1; return *this; }
mint& operator--() { x = x == 0 ? m - 1 : x - 1; return *this; }
mint operator++(int) { mint a = *this; ++*this; return a; }
mint operator--(int) { mint a = *this; --*this; return a; }
bool operator==(const mint& a) const { return x == a.x; }
bool operator!=(const mint& a) const { return x != a.x; }
};
con int p = 1e9 + 7;
#define mi mint<p>
#define pmm pair<mi, mi>
con int N = 60;
struct state {
int sum = 0;
int last = 0;
int cur = 0;
int ptr = 0;
vec<pii> lens;
state(vec<pii> lens_) : lens(lens_) {}
bool operator<(const state& a) const {
return stie(lens, last, cur, ptr) < stie(a.lens, a.last, a.cur, a.ptr);
}
bool operator==(const state& a) const {
return stie(last, cur, ptr, lens) < stie(a.last, a.cur, a.ptr, a.lens);
}
};
int n;
vec<pii> cycs;
map<state, mi> dp;
mi fac[N];
mi inv[N];
mi pre[N][N][N];
mi C(int a, int b) {
if (b < 0 || a < b) return 0;
return fac[a] * inv[b] * inv[a - b];
}
pmm get_ways(int a, int b) {
if (!a && !b) {
return {fac[n - 1], 0};
}
mi x = 0;
mi y = 0;
int c = n - a - 1;
forn(t, 1, n-c) {
x += C(n - t, c) * fac[c] * C(n - c - 1, b) * fac[b] * fac[a - b];
y += C(n - t, c) * fac[c] * C(n - t - c, b) * fac[b] * fac[a - b];
}
return {x, y};
}
void precalc() {
fac[0] = 1;
forn(i, 1, N-1) {
fac[i] = fac[i-1] * i;
}
inv[N-1] = mi(1) / fac[N-1];
for (int i=N-1; i>=1; i--) {
inv[i-1] = inv[i] * i;
}
forn(i, 0, n-1) {
forn(j, 0, i) {
if (i && !j) continue;
auto [x, y] = get_ways(i, j);
pre[i][j][0] = 1;
mi X = 1;
mi Y = 1;
forn(k, 1, n) {
X *= x;
Y *= y;
pre[i][j][k] = X - Y;
}
}
}
}
mi solve(state& v) {
if (v.sum == n) return 1;
if (dp.count(v)) return dp[v];
if (v.ptr == v.lens.size()) {
if (!v.cur) return dp[v] = 0;
state u = v;
u.sum += u.cur;
u.last = u.cur;
u.cur = 0;
u.ptr = 0;
return dp[v] = solve(u);
}
state u = v;
u.ptr++;
mi res = 0;
mi tmp = 1;
auto [len, cnt] = v.lens[v.ptr];
forn(i, 0, cnt) {
u.cur = v.cur + i * len;
u.lens[v.ptr].se = cnt - i;
res += solve(u) * tmp * C(cnt, i);
tmp *= pre[v.sum][v.last][len];
}
return dp[v] = res;
}
int perm[N];
bool used[N];
vec<int> cyc_lens;
void Solve() {
cin >> n;
precalc();
forn(i, 0, n-1) {
cin >> perm[i];
perm[i]--;
}
forn(i, 0, n-1) {
if (used[i]) continue;
int v = i;
int len = 0;
while (!used[v]) {
len++;
used[v] = 1;
v = perm[v];
}
cyc_lens.pb(len);
}
sort(cyc_lens);
for (int len : cyc_lens) {
if (!cycs.emp() && cycs.back().fi == len) {
cycs.back().se++;
}
else {
cycs.pb({len, 1});
}
}
state start = state(cycs);
mi ans = solve(start);
out(ans);
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
start_time = clock();
Solve();
return 0;
}
|
/* Count # DAGs after shrinking cycles, and accounting for weights. */
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string(string(s)); }
string to_string(bool b) { return to_string(int(b)); }
string to_string(vector<bool>::reference b) { return to_string(int(b)); }
string to_string(char b) { return "'" + string(1, b) + "'"; }
template <typename A, typename B>
string to_string(pair<A, B> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <typename A>
string to_string(A v) {
string res = "{";
for (const auto& x : v) res += (res == "{" ? "" : ", ") + to_string(x);
return res + "}";
}
void debug() { cerr << endl; }
template <typename Head, typename... Tail>
void debug(Head H, Tail... T) {
cerr << " " << to_string(H);
debug(T...);
}
#define db(...) cerr << "[" << #__VA_ARGS__ << "]:", debug(__VA_ARGS__)
#else
#define db(...) 42
#endif
typedef long long ll;
typedef long double ld;
const int MOD = 1000000007;
struct Mint {
int val;
Mint() { val = 0; }
Mint(ll x) {
val = (-MOD <= x && x < MOD) ? x : x % MOD;
if (val < 0) val += MOD;
}
template <typename U>
explicit operator U() const { return (U)val; }
friend bool operator==(const Mint& a, const Mint& b) { return a.val == b.val; }
friend bool operator!=(const Mint& a, const Mint& b) { return !(a == b); }
friend bool operator<(const Mint& a, const Mint& b) { return a.val < b.val; }
Mint& operator+=(const Mint& m) { if ((val += m.val) >= MOD) val -= MOD; return *this; }
Mint& operator-=(const Mint& m) { if ((val -= m.val) < 0) val += MOD; return *this; }
Mint& operator*=(const Mint& m) { val = (ll)val * m.val % MOD; return *this; }
friend Mint modex(Mint a, ll p) {
assert(p >= 0);
Mint ans = 1;
for (; p; p >>= 1, a *= a) if (p & 1) ans *= a;
return ans;
}
Mint& operator/=(const Mint& m) { return *this *= modex(m, MOD - 2); }
Mint& operator++() { return *this += 1; }
Mint& operator--() { return *this -= 1; }
Mint operator++(int) { Mint result(*this); *this += 1; return result; }
Mint operator--(int) { Mint result(*this); *this -= 1; return result; }
Mint operator-() const { return Mint(-val); }
friend Mint operator+(Mint a, const Mint& b) { return a += b; }
friend Mint operator-(Mint a, const Mint& b) { return a -= b; }
friend Mint operator*(Mint a, const Mint& b) { return a *= b; }
friend Mint operator/(Mint a, const Mint& b) { return a /= b; }
friend ostream& operator<<(ostream& os, const Mint& x) { return os << x.val; }
friend string to_string(const Mint& b) { return to_string(b.val); }
};
vector<int> getCycle(int x, const vector<int>& perm) {
int init = x;
vector<int> ret;
do {
ret.push_back(x);
x = perm[x];
} while (x != init);
return ret;
}
vector<Mint> fac(1, 1), invfac(1, 1);
Mint binom(int n, int k) {
if (k < 0 || k > n) return 0;
while (fac.size() <= n) {
fac.push_back(fac.back() * fac.size());
invfac.push_back(1 / fac.back());
}
return fac[n] * invfac[k] * invfac[n - k];
}
int main() {
binom(40, 0);
int n;
scanf("%d", &n);
vector<int> P(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &P[i]);
--P[i];
}
vector<bool> used(n);
vector<int> A;
for (int i = 0; i < n; ++i) {
if (used[i]) continue;
auto cyc = getCycle(i, P);
for (int x : cyc) used[x] = true;
A.push_back(cyc.size());
}
sort(A.begin(), A.end());
auto lens = A;
lens.resize(unique(lens.begin(), lens.end()) - lens.begin());
int m = lens.size();
vector<int> lenCnt(m);
for (int x : A) {
lenCnt[lower_bound(lens.begin(), lens.end(), x) - lens.begin()]++;
}
db(lens, lenCnt);
vector<int> wlen(m + 1, 1);
for (int i = 1; i <= m; ++i) {
wlen[i] = wlen[i - 1] * (lenCnt[i - 1] + 1);
}
db(wlen[m]);
int ns = wlen[m];
vector<vector<int>> subs(ns);
for (int s = 0; s < ns; ++s) {
function<void(int, int)> dfs = [&](int p, int sub) {
if (p == m) {
if (sub) subs[s].push_back(sub);
return;
}
int lim = s / wlen[p] % (lenCnt[p] + 1);
for (int i = 0; i <= lim; ++i) {
dfs(p + 1, sub + wlen[p] * i);
}
};
dfs(0, 0);
}
vector<Mint> dp(ns);
dp[0] = 1;
for (int s = 1; s < ns; ++s) {
for (int ss : subs[s]) {
db(s, ss);
Mint add = -1;
int sumB = 0, sumC = 0;
for (int i = 0; i < m; ++i) {
int ai = s / wlen[i] % (lenCnt[i] + 1);
int bi = ss / wlen[i] % (lenCnt[i] + 1);
assert(bi <= ai);
sumB += lens[i] * bi;
sumC += lens[i] * (ai - bi);
add *= binom(ai, bi);
if (bi & 1) add = -add;
}
assert(sumB > 0);
// Edges
Mint emult = 0;
for (int i = 0; i <= sumC; ++i) {
emult += binom(sumC, i) * fac[i] * fac[n - i - 1];
}
add *= modex(emult, sumB);
dp[s] += dp[s - ss] * add;
}
}
printf("%d\n", dp[ns - 1].val);
}
|
#include<bits/stdc++.h>
using namespace std;
const int N=105,M=1000000007;
const long double PI=3.1415926535897932384626;
int n,i,j,a[N],vis[N],p[N],c[N],u[N],fi;
long long f[55555],fac[N],inv[N];
struct str{
int a[45];
};
long long qpow(long long a,long long b)
{
long long s=a,ans=1;
while(b)
{
if(b&1)
ans=ans*s%M;
s=s*s%M;
b>>=1;
}
return ans;
}
vector<str> g;
void Find(int i)
{
int j;
if(i>=41)
{
str e;
memset(e.a,0,sizeof(e.a));
for(j=1;j<=40;++j)
e.a[j]=u[j];
g.push_back(e);
return;
}
for(j=0;j<=p[i]-c[i];++j)
{
u[i]=j;
Find(i+1);
}
}
long long C(int n,int m)
{
return fac[n]*inv[m]%M*inv[n-m]%M;
}
long long dfs(int i)
{
if(f[i]!=-1)
return f[i];
if(i==fi)
return 1;
int j;
int t=i,s=0;
int cc[45];
for(j=1;j<=40;++j)
{
c[j]=t%(p[j]+1);
cc[j]=p[j]-c[j];
t/=p[j]+1;
s+=c[j]*j;
}
long long as=0;
for(j=0;j<=s;++j)
as=(as+C(s,j)*fac[j]%M*fac[n-j-1])%M;
//cout<<'#'<<i<<' '<<s<<' '<<as<<endl;
g.clear();
Find(1);
vector<str> w=g;
//cout<<i<<endl;
//for(auto it:g)
// cout<<it.a[1]<<' '<<it.a[2]<<endl;
long long ans=0;
for(auto it:w)
{
int su=0,e=-1,s=0;
long long fa=1;
for(j=1;j<=40;++j)
{
su+=it.a[j]*j;
fa=fa*C(cc[j],it.a[j]);
if(it.a[j]&1)
e=-e;
}
for(j=40;j>=1;--j)
s=s*(p[j]+1)+it.a[j];
fa%=M;
if(s)
ans+=fa*qpow(as,su)%M*dfs(i+s)*e%M;
}
//cout<<i<<' '<<ans<<endl;
return f[i]=ans%M;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
scanf("%d",&n);
for(i=1;i<=n;++i)
scanf("%d",&a[i]);
for(i=1;i<=n;++i)
if(!vis[i])
{
int s=0;
for(j=i;!vis[j];j=a[j])
{
vis[j]=1;
++s;
}
++p[s];
}
fac[0]=1;
for(i=1;i<=n;++i)
fac[i]=fac[i-1]*i%M;
for(i=0;i<=n;++i)
inv[i]=qpow(fac[i],M-2);
memset(f,-1,sizeof(f));
for(i=40;i>=1;--i)
fi=fi*(p[i]+1)+p[i];
cout<<(dfs(0)%M+M)%M;
}
|
#include <bits/stdc++.h>
#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 MP make_pair
using namespace std;
typedef long long LL;
typedef pair<int, int> PII;
const int MOD = 1e9 + 7;
int n, perm[45];
bool vis[45];
int cnt[45], val[45], vs;
int ccnt[45];
int ghash()
{
int ret = 0;
rep(i, vs) ret = ret * (1 + cnt[i]) + ccnt[i];
return ret;
}
int fac[45], comb[45][45];
int coef[45][45], dp[2005];
void init_coef()
{
fac[0] = 1;
rep1(i, n) fac[i] = 1LL * fac[i - 1] * i % MOD;
rep(i, n + 1) {
comb[i][0] = 1;
rep1(j, i) comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % MOD;
}
rep(i, n) {
int tmp = 0, ccf = 1;
rep(j, i + 1) tmp = (tmp + 1LL * fac[j] * fac[n - 1 - j] % MOD * comb[i][j]) % MOD;
rep(k, n + 1) {
coef[k][i] = ccf;
ccf = 1LL * ccf * tmp % MOD;
}
}
}
bool inc(int tmp[])
{
rep(i, vs) if(tmp[i] < ccnt[i]) {
tmp[i] ++;
return true;
} else tmp[i] = 0;
return false;
}
int solve()
{
int hs = ghash();
if(dp[hs] != -1) return dp[hs];
int cur = hs == 0, tmp[45] = {};
while(inc(tmp)) {
rep(i, vs) ccnt[i] -= tmp[i];
int ccf = MOD - 1, sum = 0;
rep(i, vs) sum += val[i] * ccnt[i];
rep(i, vs) {
ccf = 1LL * ccf * comb[ccnt[i] + tmp[i]][tmp[i]] % MOD;
rep(j, tmp[i]) ccf = 1LL * ccf * (MOD - coef[val[i]][sum]) % MOD;
}
cur = (cur + 1LL * ccf * solve()) % MOD;
rep(i, vs) ccnt[i] += tmp[i];
}
return dp[hs] = cur;
}
int main()
{
scanf("%d", &n);
rep1(i, n) scanf("%d", &perm[i]);
rep1(i, n) if(!vis[i]) {
int len = 0, j = i;
do {
vis[j] = true;
j = perm[j]; len ++;
} while(j != i);
cnt[len] ++;
}
rep1(i, n) if(cnt[i] != 0) {
cnt[vs] = cnt[i]; val[vs] = i;
vs ++;
}
init_coef();
memset(dp, -1, sizeof(dp));
rep(i, vs) ccnt[i] = cnt[i];
printf("%d\n", solve());
return 0;
} |
/**
* author: tourist
* created: 30.12.2020 19:03:55
**/
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a; swap(a, m);
u -= t * v; swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
else v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const { return static_cast<U>(value); }
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; }
Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; }
template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); }
template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); }
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) { Modular result(*this); *this += 1; return result; }
Modular operator--(int) { Modular result(*this); *this -= 1; return result; }
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type& operator*=(const Modular& rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
asm(
"divl %4; \n\t"
: "=a" (d), "=d" (m)
: "d" (xh), "a" (xl), "r" (mod())
);
value = m;
#else
value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, long long>::value, Modular>::type& operator*=(const Modular& rhs) {
long long q = static_cast<long long>(static_cast<long double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type& operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) { return *this *= Modular(inverse(other.value, mod())); }
friend const Type& abs(const Modular& x) { return x.value; }
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename V, typename U>
friend V& operator>>(V& stream, Modular<U>& number);
private:
Type value;
};
template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value == rhs.value; }
template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs) { return lhs == Modular<T>(rhs); }
template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) == rhs; }
template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value < rhs.value; }
template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template<typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
// U == std::ostream? but done this way because of fastoutput
template <typename U, typename T>
U& operator<<(U& stream, const Modular<T>& number) {
return stream << number();
}
// U == std::istream? but done this way because of fastinput
template <typename U, typename T>
U& operator>>(U& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, long long>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
/*
using ModType = int;
struct VarMod { static ModType value; };
ModType VarMod::value;
ModType& md = VarMod::value;
using Mint = Modular<VarMod>;
*/
constexpr int md = (int) 1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
/*vector<Mint> fact(1, 1);
vector<Mint> inv_fact(1, 1);
Mint C(int n, int k) {
if (k < 0 || k > n) {
return 0;
}
while ((int) fact.size() < n + 1) {
fact.push_back(fact.back() * (int) fact.size());
inv_fact.push_back(1 / fact.back());
}
return fact[n] * inv_fact[k] * inv_fact[n - k];
}*/
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
--p[i];
}
vector<bool> was(n, false);
vector<int> cnt(n + 1, 0);
for (int i = 0; i < n; i++) {
if (was[i]) {
continue;
}
int len = 0;
int x = i;
while (!was[x]) {
len += 1;
was[x] = true;
x = p[x];
}
cnt[len] += 1;
}
int states = 1;
for (int i = 1; i <= n; i++) {
states *= cnt[i] + 1;
}
vector<vector<int>> g(states);
int cnt_edges = 0;
function<void(int, int, int)> Dfs = [&](int i, int x, int y) {
if (i == n + 1) {
if (x != y) {
g[x].push_back(y);
++cnt_edges;
}
return;
}
for (int j = 0; j <= cnt[i]; j++) {
for (int k = j; k <= cnt[i]; k++) {
Dfs(i + 1, x * (cnt[i] + 1) + k, y * (cnt[i] + 1) + j);
}
}
};
Dfs(0, 0, 0);
debug(cnt_edges);
vector<Mint> fact(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i;
}
vector<vector<Mint>> C(n + 1, vector<Mint>(n + 1));
for (int i = 0; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
}
}
vector<vector<Mint>> dp(states, vector<Mint>(n + 1));
for (int state = states - 2; state >= 0; state--) {
vector<int> a(n + 1);
{
int tmp = state;
for (int i = n; i >= 1; i--) {
a[i] = tmp % (cnt[i] + 1);
tmp /= cnt[i] + 1;
}
}
Mint choose = 1;
int elems = 0;
for (int i = 1; i <= n; i++) {
elems += a[i] * i;
choose *= C[cnt[i]][a[i]];
}
assert(elems < n);
dp[state][n - elems] = choose * power(fact[n - 1], n - elems);
for (int other : g[state]) {
vector<int> b(n + 1);
{
int tmp = other;
for (int i = n; i >= 1; i--) {
b[i] = tmp % (cnt[i] + 1);
tmp /= cnt[i] + 1;
}
}
Mint new_choose = 1;
int new_elems = 0;
for (int i = 1; i <= n; i++) {
new_elems += b[i] * i;
assert(b[i] <= a[i]);
new_choose *= C[a[i]][b[i]];
}
assert(new_elems < elems);
for (int last = 1; last <= n; last++) {
if (dp[state][last] == 0) {
continue;
}
Mint coeff = new_choose;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < a[i] - b[i]; j++) {
Mint cur = power(fact[elems + last] / elems, i);
cur -= power(fact[elems + last - 1], i);
coeff *= cur;
}
}
coeff *= power(C[elems + last][elems] * fact[last], new_elems);
dp[other][elems - new_elems] += dp[state][last] * coeff;
}
}
}
Mint ans = 0;
for (int last = 1; last <= n; last++) {
ans += dp[0][last];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 41, P = 1000000007;
int n, m, p[maxn], base[maxn], f[5100];
int fact[maxn], C[maxn][maxn], pw[maxn][maxn], vis[maxn];
vector<int> len, cnt, sub[5100];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]), p[i]--;
}
auto init = [&]() {
vector<int> V;
for (int i = 0; i < n; i++) if (!vis[i]) {
int len = 0;
for (int j = i; !vis[j]; j = p[j]) vis[j] = 1, len++;
V.push_back(len);
}
sort(V.begin(), V.end());
for (int i = 0, j; i < V.size(); i = j) {
for (j = i; j < V.size() && V[i] == V[j]; j++);
len.push_back(V[i]), cnt.push_back(j - i);
}
m = len.size();
for (int i = base[0] = 1; i <= m; i++) {
base[i] = base[i - 1] * (cnt[i - 1] + 1);
}
for (int i = fact[0] = C[0][0] = 1; i <= n; i++) {
fact[i] = 1LL * i * fact[i - 1] % P;
for (int j = C[i][0] = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
}
}
for (int S = 0; S < base[m]; S++) {
function<void(int, int)> dfs = [&](int pos, int T) {
if (pos == m) {
if (T) sub[S].push_back(T); return;
}
for (int i = 0; i <= S / base[pos] % (cnt[pos] + 1); i++) {
dfs(pos + 1, T + i * base[pos]);
}
};
dfs(0, 0);
}
};
auto solve = [&]() {
for (int i = 0; i < n; i++) {
pw[i][0] = 1;
for (int j = 0; j <= i; j++) {
pw[i][1] = (pw[i][1] + 1LL * C[i][j] * fact[j] % P * fact[n - j - 1]) % P;
}
for (int j = 2; j <= n; j++) {
pw[i][j] = 1LL * pw[i][j - 1] * pw[i][1] % P;
}
}
for (int S = f[0] = 1; S < base[m]; S++) {
for (int T : sub[S]) {
int s1 = 0, s2 = 0, s3 = 0;
int coef = 1;
for (int i = 0; i < m; i++) {
int x = S / base[i] % (cnt[i] + 1);
int y = T / base[i] % (cnt[i] + 1);
s1 += len[i] * y, s2 += len[i] * (x - y), s3 += y;
coef = 1LL * coef * C[x][y] % P;
}
if (!(s3 & 1)) coef = P - coef;
f[S] = (f[S] + 1LL * pw[s2][s1] * f[S - T] % P * coef) % P;
}
}
};
init(), solve();
printf("%d\n", f[base[m] - 1]);
return 0;
} |
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
#ifdef DEBUG
#define eprintf(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#else
#define eprintf(...) ;
#endif
#define sz(x) ((int) (x).size())
#define TASK "text"
const int inf = (int) 1.01e9;
const long long infll = (long long) 1.01e18;
const ld eps = 1e-9;
const ld pi = acos((ld) -1);
#ifdef DEBUG
mt19937 mrand(300);
#else
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
#endif
int rnd(int x) {
return mrand() % x;
}
const int mod = (int) 1e9 + 7;
int mul(int a, int b) {
return (long long) a * b % mod;
}
void add(int &a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
const int maxn = 45;
int f[maxn], invs[maxn], finv[maxn];
void precalc() {
f[0] = 1;
for (int i = 1; i < maxn; ++i) {
f[i] = mul(f[i - 1], i);
}
invs[1] = 1;
for (int i = 2; i < maxn; ++i) {
invs[i] = (mod - (long long) (mod / i) * invs[mod % i] % mod) % mod;
}
finv[0] = 1;
for (int i = 1; i < maxn; ++i) {
finv[i] = mul(finv[i - 1], invs[i]);
}
}
int c(int n, int k) {
return mul(f[n], mul(finv[n - k], finv[k]));
}
int n;
int p[maxn];
bool read() {
if (scanf("%d", &n) < 1) {
return false;
}
for (int i = 0; i < n; ++i) {
scanf("%d", &p[i]);
--p[i];
}
return true;
}
map<pair<vector<pair<int, int>>, int>, int> dp;
int getN(const vector<pair<int, int>> &a) {
int n = 0;
for (int i = 0; i < sz(a); ++i) {
n += a[i].first * a[i].second;
}
return n;
}
int rec(const vector<pair<int, int>> &a, int l);
int rec1(int i, const vector<pair<int, int>> &a, vector<pair<int, int>> &b, int l, int n) {
if (i >= sz(a)) {
int m = getN(b);
if (m >= n) {
return 0;
}
int res = rec(b, n - m);
for (int i = 0; i < n - m; ++i) {
res = mul(res, f[n - 1]);
}
for (int i = 0; i < m; ++i) {
res = mul(res, mul(f[n + l], finv[n]));
}
return res;
}
int c = a[i].first;
int val;
if (l) {
int all = 1, bad = 1;
for (int k = 0; k < c; ++k) {
all = mul(all, mul(f[n + l], finv[n]));
bad = mul(bad, mul(f[n + l - 1], finv[n - 1]));
}
val = all;
add(val, mod - bad);
} else {
val = 1;
}
int cur = 1;
b.push_back(make_pair(c, 0));
int res = 0;
for (int x = 0; x < a[i].second; ++x) {
b.back().second = a[i].second - x;
add(res, mul(mul(::c(a[i].second, x), cur), rec1(i + 1, a, b, l, n)));
cur = mul(cur, val);
}
b.pop_back();
add(res, mul(cur, rec1(i + 1, a, b, l, n)));
return res;
}
int rec(const vector<pair<int, int>> &a, int l) {
if (dp.count(make_pair(a, l))) {
return dp[make_pair(a, l)];
}
if (a.empty()) {
return dp[make_pair(a, l)] = 1;
}
vector<pair<int, int>> b;
int res = rec1(0, a, b, l, getN(a));
return dp[make_pair(a, l)] = res;
}
int used[maxn];
void solve() {
for (int i = 0; i < n; ++i) {
used[i] = false;
}
vector<pair<int, int>> a;
for (int s = 0; s < n; ++s) {
if (used[s]) {
continue;
}
int len = 0;
for (int v = s; !used[v]; v = p[v]) {
++len;
used[v] = true;
}
a.push_back(make_pair(len, 1));
}
sort(a.begin(), a.end());
{
int k = 1;
for (int i = 1; i < sz(a); ++i) {
if (a[i].first == a[k - 1].first) {
a[k - 1].second += a[i].second;
} else {
a[k++] = a[i];
}
}
a.resize(k);
}
dp.clear();
printf("%d\n", rec(a, 0));
}
int main() {
precalc();
#ifdef DEBUG
assert(freopen(TASK ".in", "r", stdin));
assert(freopen(TASK ".out", "w", stdout));
#endif
while (read()) {
solve();
#ifdef DEBUG
eprintf("Time %.2f\n", (double) clock() / CLOCKS_PER_SEC);
#endif
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int P=1e9+7;
int n, m, vis[43], A[43], a[43], b[43], cnt[43], L[43];
int C[43][43], coef[43][43], fac[43], f[5003];
void init() {
for(int i=C[0][0]=1;i<=n;++i) {C[i][0]=1; for(int j=1;j<=i;++j) C[i][j]=(C[i-1][j]+C[i-1][j-1])%P;}
fac[0]=1; for(int i=1;i<=n;++i) fac[i]=1ll*fac[i-1]*i%P;
for(int i=0;i<n;++i) {
coef[i][0]=1;
for(int j=0;j<=i;++j) coef[i][1]=(coef[i][1]+1ll*fac[j]*fac[n-j-1]%P*C[i][j]%P)%P;
for(int j=2;j<=n;++j) coef[i][j]=1ll*coef[i][j-1]*coef[i][1]%P;
}
}
int encode() {int val=0; for(int i=1;i<=m;++i) val=val*(cnt[i]+1)+a[i]; assert(val <= 5000); return val;}
bool get_next(int *b) {
for(int i=1;i<=m;++i)
if(b[i]<a[i]) {++b[i]; return 1;}
else b[i]=0;
return 0;
}
int solve() {
int val=encode();if(~f[val]) return f[val];
int all=0, ans=0, b[43]={}; for(int i=1;i<=m;++i) all += L[i]*a[i];
while(get_next(b)) {
int tms=1, now=0, c=-1;
for(int i=1;i<=m;++i) {
now += L[i]*b[i], tms=1ll*tms*C[a[i]][b[i]]%P, a[i] -= b[i];
if(b[i] & 1) c=-c;
}
assert(all >= now);
c=(c+P)%P, ans=(ans+1ll*c*tms%P*coef[all-now][now]%P*solve()%P)%P;
for(int i=1;i<=m;++i) a[i] += b[i];
}
return f[val]=ans;
}
int main() {
cin >> n; for(int i=1;i<=n;++i) cin >> A[i];
for(int i=1;i<=n;++i) if(!vis[i]) {
int now=i, len=0;
do{vis[now]=1, ++len, now=A[now];} while(!vis[now]);
++cnt[len];
}
for(int i=1;i<=n;++i) if(cnt[i]) L[++m]=i, cnt[m]=cnt[i];
init(); for(int i=1;i<=m;++i) a[i]=cnt[i];
memset(f, -1, sizeof(f)); f[0]=1; cout << solve();
return 0;
} |
#define DEBUG 0
#include <bits/stdc++.h>
using namespace std;
#if DEBUG
// basic debugging macros
int __i__,__j__;
#define printLine(l) for(__i__=0;__i__<l;__i__++){cout<<"-";}cout<<endl
#define printLine2(l,c) for(__i__=0;__i__<l;__i__++){cout<<c;}cout<<endl
#define printVar(n) cout<<#n<<": "<<n<<endl
#define printArr(a,l) cout<<#a<<": ";for(__i__=0;__i__<l;__i__++){cout<<a[__i__]<<" ";}cout<<endl
#define print2dArr(a,r,c) cout<<#a<<":\n";for(__i__=0;__i__<r;__i__++){for(__j__=0;__j__<c;__j__++){cout<<a[__i__][__j__]<<" ";}cout<<endl;}
#define print2dArr2(a,r,c,l) cout<<#a<<":\n";for(__i__=0;__i__<r;__i__++){for(__j__=0;__j__<c;__j__++){cout<<setw(l)<<setfill(' ')<<a[__i__][__j__]<<" ";}cout<<endl;}
// advanced debugging class
// debug 1,2,'A',"test";
class _Debug {
public:
template<typename T>
_Debug& operator,(T val) {
cout << val << endl;
return *this;
}
};
#define debug _Debug(),
#else
#define printLine(l)
#define printLine2(l,c)
#define printVar(n)
#define printArr(a,l)
#define print2dArr(a,r,c)
#define print2dArr2(a,r,c,l)
#define debug
#endif
// define
#define MAX_VAL 999999999
#define MAX_VAL_2 999999999999999999LL
#define EPS 1e-6
#define mp make_pair
#define pb push_back
// typedef
typedef unsigned int UI;
typedef long long int LLI;
typedef unsigned long long int ULLI;
typedef unsigned short int US;
typedef pair<int,int> pii;
typedef pair<LLI,LLI> plli;
typedef vector<int> vi;
typedef vector<LLI> vlli;
typedef vector<pii> vpii;
typedef vector<plli> vplli;
// ---------- END OF TEMPLATE ----------
#define MOD 1000000007
int modPow(int b,int e) {
int r = 1;
while (e > 0) {
if (e & 1) r = ((LLI) r*b) % MOD;
e >>= 1;
b = ((LLI) b*b) % MOD;
}
return r;
}
int fact[41],C[41][41],ways[40];
int p[40],v[40],occ[41],occ2[41];
int dp[1000000];
int main() {
int i;
int n;
scanf("%d",&n);
for (i = 0; i < n; i++) scanf("%d",&p[i]),p[i]--;
int j,k;
fact[0] = 1;
for (i = 1; i <= n; i++) fact[i] = ((LLI) i*fact[i-1]) % MOD;
for (i = 0; i <= n; i++) {
C[i][0] = 1;
for (j = 1; j <= i; j++) C[i][j] = (C[i-1][j-1]+C[i-1][j]) % MOD;
}
for (i = 0; i < n; i++) {
for (j = 0; j <= i; j++) {
ways[i] += ((((LLI) C[i][j]*fact[j]) % MOD)*fact[n-j-1]) % MOD;
ways[i] %= MOD;
}
}
for (i = 0; i < n; i++) {
if (!v[i]) {
int u = i,c = 0;
while (!v[u]) v[u] = 1,u = p[u],c++;
occ[c]++;
}
}
int s = 1;
for (i = 1; i <= n; i++) s *= occ[i]+1;
dp[0] = 1;
for (i = 1; i < s; i++) {
int t = i,s2 = 1,sum = 0;
for (j = 1; j <= n; j++) {
occ2[j] = t % (occ[j]+1),s2 *= occ2[j]+1,sum += occ2[j]*j;
t /= occ[j]+1;
}
for (j = 1; j < s2; j++) {
int t2 = j,sum2 = 0,num = 0,j2 = 0,pp = 1;
LLI c = 1;
for (k = 1; k <= n; k++) {
int occ3 = t2 % (occ2[k]+1);
c *= C[occ2[k]][occ3],c %= MOD,num += occ3,sum2 += occ3*k;
j2 += (occ2[k]-occ3)*pp;
t2 /= occ2[k]+1,pp *= occ[k]+1;
}
if (!(num & 1)) c = MOD-c;
c *= dp[j2],c %= MOD;
dp[i] += (c*modPow(ways[sum-sum2],sum2)) % MOD,dp[i] %= MOD;
}
}
printf("%d\n",dp[s-1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__);
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a; swap(a, m);
u -= t * v; swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
else v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const { return static_cast<U>(value); }
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; }
Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; }
template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); }
template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); }
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) { Modular result(*this); *this += 1; return result; }
Modular operator--(int) { Modular result(*this); *this -= 1; return result; }
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type& operator*=(const Modular& rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
asm(
"divl %4; \n\t"
: "=a" (d), "=d" (m)
: "d" (xh), "a" (xl), "r" (mod())
);
value = m;
#else
value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value, Modular>::type& operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type& operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) { return *this *= Modular(inverse(other.value, mod())); }
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value == rhs.value; }
template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs) { return lhs == Modular<T>(rhs); }
template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) == rhs; }
template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value < rhs.value; }
template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template<typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
/*
using ModType = int;
struct VarMod { static ModType value; };
ModType VarMod::value;
ModType& md = VarMod::value;
using Mint = Modular<VarMod>;
*/
constexpr int md = (int) 1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
Mint dp[1100][50][25][20];
int sum[1100][50][25][20];
int n;
int main() {
cin >> n;
vector<Mint> fact(n + 1);
vector<Mint> inv_fact(n + 1);
fact[0] = inv_fact[0] = 1;
for(int i = 1; i <= n; i++) {
fact[i] = fact[i - 1] * i;
inv_fact[i] = 1 / fact[i];
}
auto C = [&](int x, int y) {
if(y < 0 || y > x) return Mint(0);
return fact[x] * inv_fact[y] * inv_fact[x - y];
};
vector<int> a(n);
for(int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
vector<int> dead(n);
vector<int> cyc(max(4, n + 1));
for(int i = 0; i < n; i++) {
if(dead[i]) continue;
int v = a[i];
dead[i] = 1;
int cnt = 1;
while(v != i) {
dead[v] = 1;
cnt++;
v = a[v];
}
cyc[cnt]++;
}
int p1 = cyc[1], p2 = cyc[2], p3 = cyc[3];
vector<int> re;
for(int i = 4; i <= n; i++) for(int j = 0; j < cyc[i]; j++) re.push_back(i);
int R = re.size();
for(int a1 = 0; a1 <= p1; a1++) {
for(int a2 = 0; a2 <= p2; a2++) {
for(int a3 = 0; a3 <= p3; a3++) {
for(int mask = 0; mask < (1 << R); mask++) {
int s = a1 + 2 * a2 + 3 * a3;
for(int i = 0; i < R; i++) if((mask >> i) & 1) s += re[i];
sum[mask][a1][a2][a3] = s;
}
}
}
}
dp[0][0][0][0] = 1;
vector<vector<Mint>> var(n, vector<Mint>(n + 1));
for(int i = 0; i < n; i++) {
Mint ft = C(n, i) * fact[i] * fact[n - i - 1];
for(int j = 0; j <= n; j++) {
var[i][j] = power(ft, j);
}
}
for(int a1 = 0; a1 <= p1; a1++) {
for(int a2 = 0; a2 <= p2; a2++) {
for(int a3 = 0; a3 <= p3; a3++) {
for(int mask = 0; mask < (1 << R); mask++) {
for(int b1 = 0; b1 <= a1; b1++) {
for(int b2 = 0; b2 <= a2; b2++) {
for(int b3 = 0; b3 <= a3; b3++) {
for(int sub = mask; ~sub; sub = (sub == 0 ? -1 : (sub - 1) & mask)) {
if(sub + b1 + b2 + b3 == mask + a1 + a2 + a3) continue;
Mint ft = dp[sub][b1][b2][b3];
if(ft == 0) continue;
int mu = (a1 + a2 + a3 + b1 + b2 + b3 + __builtin_popcount(mask ^ sub)) & 1 ? 1 : -1;
int s = sum[sub][b1][b2][b3];
int S = sum[mask][a1][a2][a3];
dp[mask][a1][a2][a3] += ft * var[s][S - s] * C(p1 - b1, p1 - a1) * C(p2 - b2, p2 - a2) * C(p3 - b3, p3 - a3) * mu;
}
}
}
}
}
}
}
}
cout << dp[(1 << R) - 1][p1][p2][p3];
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define pii pair < int , int >
const int P = 1e9 + 7; int N , val[41][41] , fac[41] , ifac[41] , nxt[41];
int poww(long long a , int b){int tms = 1; while(b){if(b & 1) tms = tms * a % P; a = a * a % P; b >>= 1;} return tms;}
int binom(int a , int b){return 1ll * fac[a] * ifac[b] % P * ifac[a - b] % P;}
#define ull unsigned long long
map < ull , int > ans;
ull qhash(vector < pii > &cnt){ull sum = 0; for(auto t : cnt){sum = (sum * 41 + t.first) * 41 + t.second;} return sum;}
int solve(vector < pii >);
int dfs(vector < pii > &cnt , int pos , vector < pii > &pot , int all , int in , int tms , int num){
if(pos == cnt.size()) return num ? (num & 1 ? 1ll : P - 1ll) * tms % P * val[all - in][in] % P * solve(pot) % P : 0;
int t = cnt[pos].first , c = cnt[pos].second , sum = dfs(cnt , pos + 1 , pot , all , in + t * c , tms , num + c);
for(int i = 1 ; i <= c ; ++i){
pot.push_back(pii(t , i)); sum = (sum + dfs(cnt , pos + 1 , pot , all , in + t * (c - i) , 1ll * tms * binom(c , i) % P , num + c - i)) % P;
pot.pop_back();
}
return sum;
}
int solve(vector < pii > cnt){
if(cnt.empty()) return 1;
ull val = qhash(cnt); if(ans.find(val) != ans.end()) return ans[val];
int sz = 0; for(auto t : cnt) sz += t.first * t.second;
vector < pii > tmp; return ans[val] = dfs(cnt , 0 , tmp , sz , 0 , 1 , 0);
}
int main(){
vector < int > pot; cin >> N; for(int i = 1 ; i <= N ; ++i) cin >> nxt[i];
for(int i = 1 ; i <= N ; ++i) if(nxt[i]){int p = i , cnt = 0; do{++cnt; int r = nxt[p]; nxt[p] = 0; p = r;}while(p != i); pot.push_back(cnt);}
sort(pot.begin() , pot.end()); vector < pii > cnt;
for(auto t : pot) if(cnt.empty() || cnt.back().first != t) cnt.push_back(make_pair(t , 1)); else ++cnt.back().second;
fac[0] = 1; for(int i = 1 ; i <= N ; ++i) fac[i] = 1ll * fac[i - 1] * i % P;
ifac[N] = poww(fac[N] , P - 2); for(int i = N - 1 ; ~i ; --i) ifac[i] = ifac[i + 1] * (i + 1ll) % P;
for(int j = 0 ; j < N ; ++j){
for(int k = 0 ; k <= j ; ++k)
val[j][1] = (val[j][1] + 1ll * binom(j , k) * fac[k] % P * fac[N - k - 1]) % P;
for(int k = 2 ; k + j <= N ; ++k) val[j][k] = 1ll * val[j][1] * val[j][k - 1] % P;
}
cout << solve(cnt); return 0;
} |
//#pragma GCC target("avx,avx2")
#include<bits/stdc++.h>
//#include<immintrin.h>
using namespace std;
template <typename T> void chmin(T&x,const T &y)
{
if(x>y)x=y;
}
template <typename T> void chmax(T &x,const T &y)
{
if(x<y)x=y;
}
typedef int64_t s64;
typedef uint64_t u64;
typedef uint32_t u32;
typedef pair<int,int> pii;
#define rep(i,l,r) for(int i=l;i<=r;++i)
#define per(i,r,l) for(int i=r;i>=l;--i)
#define rep0(i,l,r) for(int i=l;i<r;++i)
#define gc (c=getchar())
char readc()
{
char c;
while(isspace(gc));
return c;
}
int read()
{
char c;
while(gc<'-');
if(c=='-')
{
int x=gc-'0';
while(gc>='0')x=x*10+c-'0';
return -x;
}
int x=c-'0';
while(gc>='0')x=x*10+c-'0';
return x;
}
#undef gc
const int N=40+5,U=1440+5,D=1e9+7;
s64 dp[U],f[N][N],C[N][N],jie[N];
int sz[U];
int p[N],cnt_of_len[N],prod[N];
bool vis[N];
int main()
{
#ifdef kcz
freopen("1.in","r",stdin);//freopen("1.out","w",stdout);
#endif
/* int n=40;
rep(i,0,n)dp[i]=1;
rep(sz,1,n)
per(i,n,sz)
rep(j,1,i/sz)chmax(dp[i],dp[i-j*sz]*(j+1));
cout<<dp[n]<<endl;*/
int n;
cin>>n;
rep(i,1,n)cin>>p[i];
rep(i,1,n)
if(!vis[i])
{
int len=0;
for(int j=i;!vis[j];j=p[j])
{
vis[j]=1;
++len;
}
++cnt_of_len[len];
}
rep(i,0,n)
{
C[i][0]=1;
rep(j,1,i)C[i][j]=(C[i-1][j]+C[i-1][j-1])%D;
}
jie[0]=1;
rep(i,1,n)jie[i]=jie[i-1]*i%D;
rep(y,0,n-1)
{
rep(i,0,y)(f[y][1]+=C[y][i]*jie[i]%D*jie[n-1-i])%=D;
f[y][0]=1;
rep(x,2,n)f[y][x]=f[y][x-1]*f[y][1]%D;
}
prod[0]=1;
rep(i,1,n)prod[i]=prod[i-1]*(cnt_of_len[i]+1);
int u=prod[n]-1;
dp[0]=1;
rep(s,1,u)
{
static int q[U];
static s64 w[U];
int t=0;
q[0]=0;w[0]=-1;
rep(i,1,n)
{
int t0=t;
int nmx=(s/prod[i-1])%(cnt_of_len[i]+1);
sz[s]+=nmx*i;
per(j,nmx,1)
rep(h,0,t0)
{
q[++t]=q[h]+j*prod[i-1];
w[t]=(j%2?-1:1)*w[h]*C[nmx][j]%D;
}
}
s64 ans=0;
rep(h,1,t)
(ans+=w[h]*dp[s-q[h]]%D*f[sz[s]-sz[q[h]]][sz[q[h]]])%=D;
dp[s]=ans;
}
cout<<(dp[u]%D+D)%D<<endl;
}
/* stuff you should look for
* int overflow, array bounds, uppercase/lowercase
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
* DON'T GET STUCK ON ONE APPROACH
*/
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = long double; // or double, if TL is tight
using str = string; // yay python!
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using pd = pair<db,db>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<db>;
using vs = vector<str>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
#define tcT template<class T
#define tcTU tcT, class U
// ^ lol this makes everything look weird but I'll try it
tcT> using V = vector<T>;
tcT, size_t SZ> using AR = array<T,SZ>;
tcT> using PR = pair<T,T>;
// pairs
#define mp make_pair
#define f first
#define s second
// vectors
// oops size(x), rbegin(x), rend(x) need C++17
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) bg(x), end(x)
#define rall(x) x.rbegin(), x.rend()
#define sor(x) sort(all(x))
#define rsz resize
#define ins insert
#define ft front()
#define bk back()
#define pb push_back
#define eb emplace_back
#define pf push_front
#define lb lower_bound
#define ub upper_bound
tcT> int lwb(V<T>& a, const T& b) { return int(lb(all(a),b)-bg(a)); }
// loops
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define trav(a,x) for (auto& a: x)
const int MOD = 1e9+7; // 998244353;
const int MX = 2e5+5;
const ll INF = 1e18; // not too close to LLONG_MAX
const db PI = acos((db)-1);
const int dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1}; // for every grid problem!!
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;
// bitwise ops
// also see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
constexpr int bits(int x) { // assert(x >= 0); // make C++11 compatible until USACO updates ...
return x == 0 ? 0 : 31-__builtin_clz(x); } // floor(log2(x))
constexpr int p2(int x) { return 1<<x; }
constexpr int msk2(int x) { return p2(x)-1; }
ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down
tcT> bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0; } // set a = min(a,b)
tcT> bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0; }
tcTU> T fstTrue(T lo, T hi, U f) {
hi ++; assert(lo <= hi); // assuming f is increasing
while (lo < hi) { // find first index such that f is true
T mid = lo+(hi-lo)/2;
f(mid) ? hi = mid : lo = mid+1;
}
return lo;
}
tcTU> T lstTrue(T lo, T hi, U f) {
lo --; assert(lo <= hi); // assuming f is decreasing
while (lo < hi) { // find first index such that f is true
T mid = lo+(hi-lo+1)/2;
f(mid) ? lo = mid : hi = mid-1;
}
return lo;
}
tcT> void remDup(vector<T>& v) { // sort and remove duplicates
sort(all(v)); v.erase(unique(all(v)),end(v)); }
tcTU> void erase(T& t, const U& u) { // don't erase
auto it = t.find(u); assert(it != end(t));
t.erase(it); } // element that doesn't exist from (multi)set
// INPUT
#define tcTUU tcT, class ...U
tcT> void re(complex<T>& c);
tcTU> void re(pair<T,U>& p);
tcT> void re(V<T>& v);
tcT, size_t SZ> void re(AR<T,SZ>& a);
tcT> void re(T& x) { cin >> x; }
void re(double& d) { str t; re(t); d = stod(t); }
void re(long double& d) { str t; re(t); d = stold(t); }
tcTUU> void re(T& t, U&... u) { re(t); re(u...); }
tcT> void re(complex<T>& c) { T a,b; re(a,b); c = {a,b}; }
tcTU> void re(pair<T,U>& p) { re(p.f,p.s); }
tcT> void re(V<T>& x) { trav(a,x) re(a); }
tcT, size_t SZ> void re(AR<T,SZ>& x) { trav(a,x) re(a); }
tcT> void rv(int n, V<T>& x) { x.rsz(n); re(x); }
// TO_STRING
#define ts to_string
str ts(char c) { return str(1,c); }
str ts(const char* s) { return (str)s; }
str ts(str s) { return s; }
str ts(bool b) {
// #ifdef LOCAL
// return b ? "true" : "false";
// #else
return ts((int)b);
// #endif
}
tcT> str ts(complex<T> c) {
stringstream ss; ss << c; return ss.str(); }
str ts(V<bool> v) {
str res = "{"; F0R(i,sz(v)) res += char('0'+v[i]);
res += "}"; return res; }
template<size_t SZ> str ts(bitset<SZ> b) {
str res = ""; F0R(i,SZ) res += char('0'+b[i]);
return res; }
tcTU> str ts(pair<T,U> p);
tcT> str ts(T v) { // containers with begin(), end()
#ifdef LOCAL
bool fst = 1; str res = "{";
for (const auto& x: v) {
if (!fst) res += ", ";
fst = 0; res += ts(x);
}
res += "}"; return res;
#else
bool fst = 1; str res = "";
for (const auto& x: v) {
if (!fst) res += " ";
fst = 0; res += ts(x);
}
return res;
#endif
}
tcTU> str ts(pair<T,U> p) {
#ifdef LOCAL
return "("+ts(p.f)+", "+ts(p.s)+")";
#else
return ts(p.f)+" "+ts(p.s);
#endif
}
// OUTPUT
tcT> void pr(T x) { cout << ts(x); }
tcTUU> void pr(const T& t, const U&... u) {
pr(t); pr(u...); }
void ps() { pr("\n"); } // print w/ spaces
tcTUU> void ps(const T& t, const U&... u) {
pr(t); if (sizeof...(u)) pr(" "); ps(u...); }
// DEBUG
void DBG() { cerr << "]" << endl; }
tcTUU> void DBG(const T& t, const U&... u) {
cerr << ts(t); if (sizeof...(u)) cerr << ", ";
DBG(u...); }
#ifdef LOCAL // compile with -DLOCAL, chk -> fake assert
#define dbg(...) cerr << "Line(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#define chk(...) if (!(__VA_ARGS__)) cerr << "Line(" << __LINE__ << ") -> function(" \
<< __FUNCTION__ << ") -> CHK FAILED: (" << #__VA_ARGS__ << ")" << "\n", exit(0);
#else
#define dbg(...) 0
#define chk(...) 0
#endif
void setPrec() { cout << fixed << setprecision(15); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
// FILE I/O
void setIn(str s) { freopen(s.c_str(),"r",stdin); }
void setOut(str s) { freopen(s.c_str(),"w",stdout); }
void setIO(str s = "") {
unsyncIO(); setPrec();
// cin.exceptions(cin.failbit);
// throws exception when do smth illegal
// ex. try to read letter into int
if (sz(s)) setIn(s+".in"), setOut(s+".out"); // for USACO
}
/**
* Description: modular arithmetic operations
* Source:
* KACTL
* https://codeforces.com/blog/entry/63903
* https://codeforces.com/contest/1261/submission/65632855 (tourist)
* https://codeforces.com/contest/1264/submission/66344993 (ksun)
* also see https://github.com/ecnerwala/cp-book/blob/master/src/modnum.hpp (ecnerwal)
* Verification:
* https://open.kattis.com/problems/modulararithmetic
*/
template<int MOD, int RT> struct mint {
static const int mod = MOD;
static constexpr mint rt() { return RT; } // primitive root for FFT
int v; explicit operator int() const { return v; } // explicit -> don't silently convert to int
mint() { v = 0; }
mint(ll _v) { v = int((-MOD < _v && _v < MOD) ? _v : _v % MOD);
if (v < 0) v += MOD; }
friend bool operator==(const mint& a, const mint& b) {
return a.v == b.v; }
friend bool operator!=(const mint& a, const mint& b) {
return !(a == b); }
friend bool operator<(const mint& a, const mint& b) {
return a.v < b.v; }
friend void re(mint& a) { ll x; re(x); a = mint(x); }
friend str ts(mint a) { return ts(a.v); }
mint& operator+=(const mint& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this; }
mint& operator-=(const mint& m) {
if ((v -= m.v) < 0) v += MOD;
return *this; }
mint& operator*=(const mint& m) {
v = int((ll)v*m.v%MOD); return *this; }
mint& operator/=(const mint& m) { return (*this) *= inv(m); }
friend mint pow(mint a, ll p) {
mint ans = 1; assert(p >= 0);
for (; p; p /= 2, a *= a) if (p&1) ans *= a;
return ans; }
friend mint inv(const mint& a) { assert(a.v != 0);
return pow(a,MOD-2); }
mint operator-() const { return mint(-v); }
mint& operator++() { return *this += 1; }
mint& operator--() { return *this -= 1; }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
};
typedef mint<MOD,5> mi; // 5 is primitive root for both common mods
typedef vector<mi> vmi;
typedef pair<mi,mi> pmi;
typedef vector<pmi> vpmi;
vector<vmi> scmb; // small combinations
void genComb(int SZ) {
scmb.assign(SZ,vmi(SZ)); scmb[0][0] = 1;
FOR(i,1,SZ) F0R(j,i+1)
scmb[i][j] = scmb[i-1][j]+(j?scmb[i-1][j-1]:0);
}
// mi dp[][];
int N;
map<pair<vi,pi>,mi> dp;
// vi x;
// int bef, rem;
mi perm[45][45];
// mi no(int len) {
// return pow(perm[bef-1][rem],len);
// }
// mi whatever(int len) {
// return pow(perm[bef][rem],len);
// }
// mi yes(int len) {
// return whatever(len)-no(len);
// // return rem*perm[bef-1][rem-1];
// }
vi cyc_len;
// void dfs_add(vi y, mi num, int ind) {
// if (ind == sz(x)) {
// dp[{x,y}] += num;
// return;
// }
// num *= pow(whatever(cyc_len[ind]),y[ind]);
// int dif = x[ind]-y[ind];
// mi YES = yes(cyc_len[ind]), NO = no(cyc_len[ind]);
// F0R(j,dif+1) {
// mi mul = num*scmb[dif][j]*pow(YES,j)*pow(NO,dif-j);
// vi Y = y; Y[ind] = y[ind]+j;
// dfs_add(Y,mul,ind+1);
// }
// // y[ind] are available: do whatever
// // perm(bef,rem)
// // x[ind]-y[ind] are not
// // either rem*perm(bef-1,rem-1) -> make available
// // or perm(bef-1,rem) -> not make available
// }
void dfs_add(vi rem, pi lst, mi ways, int ind, int nex_lst) {
if (ind == sz(cyc_len)) {
if (nex_lst) dp[{rem,{lst.f+lst.s,nex_lst}}] += ways;
return;
}
mi whoops;
if (lst == mp(0,0)) {
whoops = pow(perm[N-1][N-1],cyc_len[ind]);
} else {
whoops = pow(perm[N][lst.f]*perm[N-lst.f][lst.s] *perm[N-1-lst.f-lst.s][N-1-lst.f-lst.s],cyc_len[ind]);
whoops -= pow(perm[N][lst.f]*perm[N-1-lst.f][lst.s]*perm[N-1-lst.f-lst.s][N-1-lst.f-lst.s],cyc_len[ind]);
// perm[N][lst.f]
// perm[N-lst.f][lst.s]: first
// perm[N-1-lst.f][lst.s]: not first
// perm[N-1-lst.f-lst.s][N-1-lst.f-lst.s]
}
// dbg(lst,whoops);
// mi whoops = ways_to_assign();
F0R(i,rem[ind]+1) {
vi REM = rem; REM[ind] -= i;
dfs_add(REM,lst,ways*pow(whoops,i)*scmb[rem[ind]][i],ind+1,nex_lst+i*cyc_len[ind]);
}
}
int sum(vi v) { // OK
int res = 0;
F0R(i,sz(v)) res += v[i]*cyc_len[i];
return res;
}
int main() {
setIO();
re(N);
genComb(45);
F0R(i,45) {
perm[i][0] = 1;
FOR(j,1,i+1) perm[i][j] = perm[i][j-1]*(i+1-j);
}
// dbg(perm[4][3], perm[4][2]);
vi P(N); re(P);
trav(t,P) --t;
vb vis(N);
map<int,int> cyc;
F0R(i,N) if (!vis[i]) {
int cnt = 0;
int cur = i;
while (!vis[cur]) {
vis[cur] = 1;
++cnt;
cur = P[cur];
}
++ cyc[cnt];
}
vi st;
trav(t,cyc) {
cyc_len.pb(t.f);
st.pb(t.s);
}
// how many left, how many processed on previous round
dp[{st,{0,0}}] = 1;
assert(sum(st) == N);
mi ans = 0;
while (sz(dp)) {
auto it = prev(end(dp));
pair<pair<vi,pi>,mi> a = *it; dp.erase(it);
if (sum(a.f.f) == 0) {
assert(a.f.s.f+a.f.s.s == N);
ans += a.s;
} else {
dfs_add(a.f.f,a.f.s,a.s,0,0);
}
// dbg("DOING",a);
// int ind = 0; while (ind < sz(a.f.s) && a.f.s[ind] == 0) ++ind;
// bef = sum(a.f.f);
// if (ind == sz(a.f.s)) { // none to remove
// if (bef == 0) ans += a.s;
// continue;
// }
// { // just ignore it
// x = a.f.f; --a.f.s[ind];
// dp[{x,a.f.s}] += a.s;
// }
// --x[ind];
// rem = cyc_len[ind]; // # that were removed
// a.s *= pow(perm[bef-1][bef-1],rem);
// dfs_add(a.f.s,a.s,0);
}
ps(ans);
// you should actually read the stuff at the bottom
}
/* stuff you should look for
* int overflow, array bounds
* special cases (n=1?)
* do smth instead of nothing and stay organized
* WRITE STUFF DOWN
* DON'T GET STUCK ON ONE APPROACH
*/
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
struct mint {
int val = 0;
mint() {}
mint(int a) : val(a) {
while (val < 0) {
val += M;
}
while (val >= M) {
val -= M;
}
}
mint(long long a) : val(a % M) {
if (val < 0) {
val += M;
}
}
mint operator+=(mint oth) {
val += oth.val;
val -= (val >= M) ? M : 0;
return *this;
}
mint operator-=(mint oth) {
val -= oth.val;
val += (val < 0) ? M : 0;
return *this;
}
mint operator*=(mint oth) {
val = 1LL * val * oth.val % M;
return *this;
}
void operator++() {
++val;
if (val == M) {
val = 0;
}
}
void operator--() {
--val;
if (val == -1) {
val = M - 1;
}
}
mint operator-() {
mint res;
res.val = (val == 0) ? 0 : M - val;
return res;
}
friend mint operator+(mint a, mint b) {
return mint(a) += b;
}
friend mint operator-(mint a, mint b) {
return mint(a) -= b;
}
friend mint operator*(mint a, mint b) {
return mint(a) *= b;
}
friend bool operator==(mint a, mint b) {
return a.val == b.val;
}
friend bool operator!=(mint a, mint b) {
return a.val != b.val;
}
friend ostream& operator<<(ostream &out, mint a) {
out << a.val;
return out;
}
friend mint pow(mint b, long long e = M - 2) {
mint res = 1;
while (e > 0) {
if (e % 2 == 1) {
res *= b;
}
b *= b;
e /= 2;
}
return res;
}
};
const int N = 40 + 1;
using state = tuple<int, int, int, int, map<int, int>>;
mint choose[N][N], fact[N];
bool visited[N];
int perm[N], n;
mint calc(int k) {
return choose[n][k + 1] * fact[k] * fact[n - k - 1];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
for (int i = 0; i < N; ++i) {
choose[i][0] = choose[i][i] = 1;
fact[i] = (i == 0) ? 1 : fact[i - 1] * i;
for (int j = 1; j < i; ++j) {
choose[i][j] = choose[i - 1][j - 1] + choose[i - 1][j];
}
}
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> perm[i];
--perm[i];
}
map<int, int> cycles;
for (int i = 0; i < n; ++i) {
if (!visited[i]) {
int j = i, l = 0;
while (!visited[j]) {
visited[j] = true;
j = perm[j];
++l;
}
++cycles[l];
}
}
mint ans = 0;
cycles[n + 1] = 0;
map<state, mint> ways;
ways.insert({{0, cycles.begin()->first, 0, 0, cycles}, 1});
while (!ways.empty()) {
auto [s, x] = *ways.begin();
auto [i, j, p, c, count] = s;
ways.erase(ways.begin());
if (j > n) {
if (c > 0) {
if (i + c == n) {
ans += x;
} else {
state t = {i + c, count.begin()->first, c, 0, count};
ways[t] += x;
}
}
} else {
mint y = pow(calc(n - i - 1), j);
if (p > 0) {
y -= pow(calc(n - i - 1 + p), j);
}
state t = {i, count.upper_bound(j)->first, p, c, count};
for (int k = 0; k <= count[j]; ++k) {
ways[t] += x * pow(y, k) * choose[count[j]][k];
get<3>(t) += j;
--get<4>(t)[j];
}
}
}
cout << ans << "\n";
}
|
#include<bits/stdc++.h>
#define For(i,j,k) for (int i=(int)(j);i<=(int)(k);i++)
#define Rep(i,j,k) for (int i=(int)(j);i>=(int)(k);i--)
#define pii pair<int,int>
#define fi first
#define se second
#define PB push_back
#define ll long long
#define ull unsigned long long
using namespace std;
const int mo=1000000007;
const int N=55;
int fac[N],C[N][N],tr[N][N];
int n,p[N],vis[N],tab[N];
int prod[N],sz[N*N*N];
int f[N*N*N];
void init(){
fac[0]=1;
For(i,0,N-1) C[i][0]=1;
For(i,1,N-1) fac[i]=1ll*fac[i-1]*i%mo;
For(i,1,N-1) For(j,1,i) C[i][j]=(C[i-1][j]+C[i-1][j-1])%mo;
For(i,0,n-1){
tr[i][0]=1;
For(j,0,i) tr[i][1]=(tr[i][1]+1ll*C[i][j]*fac[j]%mo*fac[n-j-1])%mo;
For(j,2,N-1) tr[i][j]=1ll*tr[i][j-1]*tr[i][1]%mo;
}
}
int main(){
scanf("%d",&n);
For(i,1,n) scanf("%d",&p[i]);
For(i,1,n) if (!vis[i]){
int x=i,s=0;
for (;!vis[x];vis[x]=1,x=p[x],++s);
++tab[s];
}
init();
prod[0]=f[0]=1;
For(i,1,n) prod[i]=prod[i-1]*(tab[i]+1);
For(S,0,prod[n]-1){
static int q[N*N*N],w[N*N*N];
int t=1;
q[1]=0; w[1]=mo-1;
For(i,1,n){
int tmp=t;
int v=(S/prod[i-1])%(tab[i]+1);
sz[S]+=i*v;
For(j,1,v) For(h,1,tmp){
q[++t]=q[h]+j*prod[i-1];
w[t]=1ll*w[h]*(j&1?mo-1:1)%mo*C[v][j]%mo;
}
}
int ans=0;
For(i,2,t) f[S]=(f[S]+1ll*f[S-q[i]]*w[i]%mo*tr[sz[S]-sz[q[i]]][sz[q[i]]])%mo;
}
cout<<f[prod[n]-1]<<endl;
} |
#include<bits/stdc++.h>
clock_t __t=clock();
namespace my_std{
using namespace std;
#define pii pair<int,int>
#define fir first
#define sec second
#define MP make_pair
#define rep(i,x,y) for (int i=(x);i<=(y);i++)
#define drep(i,x,y) for (int i=(x);i>=(y);i--)
#define go(x) for (int i=head[x];i;i=edge[i].nxt)
#define templ template<typename T>
#define sz 1555
#define mod 1000000007ll
typedef long long ll;
typedef double db;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
templ inline T rnd(T l,T r) {return uniform_int_distribution<T>(l,r)(rng);}
templ inline bool chkmax(T &x,T y){return x<y?x=y,1:0;}
templ inline bool chkmin(T &x,T y){return x>y?x=y,1:0;}
templ inline void read(T& t)
{
t=0;char f=0,ch=getchar();double d=0.1;
while(ch>'9'||ch<'0') f|=(ch=='-'),ch=getchar();
while(ch<='9'&&ch>='0') t=t*10+ch-48,ch=getchar();
if(ch=='.'){ch=getchar();while(ch<='9'&&ch>='0') t+=d*(ch^48),d*=0.1,ch=getchar();}
t=(f?-t:t);
}
template<typename T,typename... Args>inline void read(T& t,Args&... args){read(t); read(args...);}
char __sr[1<<21],__z[20];int __C=-1,__zz=0;
inline void Ot(){fwrite(__sr,1,__C+1,stdout),__C=-1;}
inline void print(int x)
{
if(__C>1<<20)Ot();if(x<0)__sr[++__C]='-',x=-x;
while(__z[++__zz]=x%10+48,x/=10);
while(__sr[++__C]=__z[__zz],--__zz);__sr[++__C]='\n';
}
void file()
{
#ifdef NTFOrz
freopen("a.in","r",stdin);
#endif
}
inline void chktime()
{
#ifdef NTFOrz
cout<<(clock()-__t)/1000.0<<'\n';
#endif
}
#ifdef mod
ll ksm(ll x,int y){ll ret=1;for (;y;y>>=1,x=x*x%mod) if (y&1) ret=ret*x%mod;return ret;}
ll inv(ll x){return ksm(x,mod-2);}
#else
ll ksm(ll x,int y){ll ret=1;for (;y;y>>=1,x=x*x) if (y&1) ret=ret*x;return ret;}
#endif
// ll mul(ll x,ll y){ull s=1.0*x/mod*y;ll res=1ull*x*y-s*mod;return (res%mod+mod)%mod;}
}
using namespace my_std;
int n,m;
int cnt[sz],pre[sz],tot[sz],a[sz][44];
ll _fac[sz],fac[sz];
void init()
{
static int p[sz],vis[sz];
rep(i,1,n) read(p[i]);
rep(i,1,n) if (!vis[i]) { vis[i]=1; int len=1; for (int x=p[i];x!=i;x=p[x]) vis[x]=1,++len; ++cnt[len]; }
m=1; rep(i,1,n) m*=(cnt[i]+1);
pre[1]=1; rep(i,2,n+1) pre[i]=pre[i-1]*(cnt[i-1]+1);
rep(i,0,m-1) { int x=i; rep(k,1,n) tot[i]+=(a[i][k]=x%(cnt[k]+1))*k,x/=(cnt[k]+1); }
_fac[0]=fac[0]=1; rep(i,1,sz-1) _fac[i]=inv(fac[i]=fac[i-1]*i%mod);
}
ll dp[sz][44][44][44];
int main()
{
file();
read(n); init();
rep(i,1,m-1) { ll w=1; rep(j,1,n) w=w*_fac[a[i][j]]%mod; dp[i][n+1][tot[i]][tot[i]]=w; }
ll ans=0;
rep(s,1,m-1) rep(i,1,n+1) rep(j,0,tot[s]) rep(k,1,n) if (dp[s][i][j][k])
{
ll w=dp[s][i][j][k];
if (i==n+1)
{
w=w*ksm(n-tot[s]+j,mod-1-j)%mod;
if (tot[s]==n) { (ans+=w)%=mod; continue; }
int s1=n-tot[s],s2=n-tot[s]+j; s2=inv(s2);
rep(k,1,n)
{
ll t=mod+1-ksm(1ll*s1*s2%mod,k); ll cur=1;
rep(x,1,cnt[k]-a[s][k]) cur=cur*t%mod,(dp[s+x*pre[k]][k+1][x*k][j]+=w*_fac[x]%mod*cur%mod)%=mod;
}
continue;
}
int s1=n-tot[s]+j,s2=s1+k; s2=inv(s2);
ll t=mod+1-ksm(1ll*s1*s2%mod,i),cur=1;
rep(x,0,cnt[i]-a[s][i]) (dp[s+x*pre[i]][i+1][j+x*i][k]+=w*_fac[x]%mod*cur%mod)%=mod,cur=cur*t%mod;
}
chktime();
rep(i,1,n) ans=ans*fac[cnt[i]]%mod;
ans=ans*ksm(fac[n],n)%mod;
cout<<ans;
return 0;
} |
#include <cassert>
#include <cstdio>
#include <iostream>
using namespace std;
const int _ = 40 + 7;
const int M = 3931649;
const int mod = 1e9 + 7;
bool be;
int n, a[_], num[_], S[_], T[_], idS, idR, sumS, sumT, f[M + 7][_];
bool vis[_];
int fac[_], ifac[_], inv[_], pwfac[_][_], pwinv[_][_], pwpri[_][_];
int pri[_] = { 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173 };
bool en;
int Pw(int a, int p) {
int res = 1;
while (p) {
if (p & 1) res = 1ll * res * a % mod;
a = 1ll * a * a % mod;
p >>= 1;
}
return res;
}
int C(int n, int m) { return 1ll * fac[n] * ifac[m] % mod * ifac[n - m] % mod; }
void DfsT(int k, int coef, int numT) {
if (k > n) {
//int tmp = 1ll * coef * pwfac[sumS][sumT] % mod * pwinv[sumT][sumT] % mod * f[idR] % mod;
if (idR == 1) return;
//cerr << "T: "; for (int i = 1; i <= n; ++i) cerr << T[i] << ' '; cerr << endl;
for (int i = 0; i <= n - sumS; ++i) {
//int t1 = Pw(1ll * fac[sumS + i] * inv[sumT + i] % mod - fac[sumS + i - 1], sumT);
int tmp = 1;
for (int j = 1; j <= n; ++j) {
if (!T[j]) continue;
int t1 = Pw(1ll * fac[sumS + i] * inv[sumT + i] % mod, j);
int t2 = Pw(fac[sumS + i - 1], j);
tmp = 1ll * tmp * Pw(t1 - t2 + mod, T[j]) % mod;
}
tmp = 1ll * tmp * coef % mod * f[idR][i + sumT] % mod;
if (numT & 1) f[idS][i] = (f[idS][i] + tmp) % mod;
else f[idS][i] = (f[idS][i] + mod - tmp) % mod;
//if (i == 0) cerr << ' ' << tmp << ' ' << f[idR][i + sumT] << endl;
}
return;
}
int tmp = idR;
for (int i = 0; i <= S[k]; ++i) {
T[k] = i, sumT += i * k, idR = 1ll * tmp * pwpri[k][S[k] - i] % M;
DfsT(k + 1, 1ll * coef * C(S[k], i) % mod, numT + i);
T[k] = 0, sumT -= i * k;
}
}
void DfsS(int k) {
if (k > n) {
assert(!f[idS][0]);
idR = 1;
DfsT(1, 1, 0);
//cerr << f[idS][0] << endl;
for (int i = 0; i <= n - sumS; ++i)
f[idS][i] = (f[idS][i] + Pw(fac[sumS + i - 1], sumS)) % mod;
//for (int i = 1; i <= n; ++i) cerr << S[i] << ' '; cerr << endl;
//cerr << idS << ": ";
//for (int i = 0; i <= n - sumS; ++i) cerr << f[idS][i] << ' '; cerr << endl;
//cerr << endl;
return;
}
int tmp = idS;
for (int i = 0; i <= num[k]; ++i) {
S[k] = i, sumS += i * k, idS = 1ll * tmp * pwpri[k][i] % M;
DfsS(k + 1);
S[k] = 0, sumS -= i * k;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) {
if (vis[i]) continue;
int sz = 0;
while (!vis[i]) vis[i] = 1, i = a[i], ++sz;
++num[sz];
}
fac[0] = ifac[0] = inv[1] = 1;
for (int i = 1; i <= n; ++i) {
fac[i] = 1ll * fac[i - 1] * i % mod;
if (i != 1) inv[i] = 1ll * inv[mod % i] * (mod - mod / i) % mod;
ifac[i] = 1ll * ifac[i - 1] * inv[i] % mod;
pwfac[i][0] = pwinv[i][0] = pwpri[i][0] = 1;
for (int j = 1; j <= n; ++j) {
pwfac[i][j] = 1ll * pwfac[i][j - 1] * fac[i] % mod;
pwinv[i][j] = 1ll * pwinv[i][j - 1] * inv[i] % mod;
pwpri[i][j] = 1ll * pwpri[i][j - 1] * pri[i] % mod;
}
}
idS = 1;
DfsS(1);
int id = 1;
for (int i = 1; i <= n; ++i) id = 1ll * id * pwpri[i][num[i]] % M;
cout << f[id][0] << endl;
cerr << 1.0 * (&en - &be) / (1 << 20) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 44, mod = 1e9 + 7;
ll qpow(ll n,ll k){
ll res = 1;
while(k){
if(k&1) res = res * n % mod;
n = n * n % mod;
k >>= 1;
}
return res;
}
ll fac[N],C[N][N];
map<vector<array<int,2>>,ll> f;
ll solve(vector<array<int,2>> v){
if(f.count(v)) return f[v];
if(v.empty()) return f[v] = 1;
int tot = 0, cur = 0, cnt = 0;
for(auto i: v) tot += i[0] * i[1];
ll ans = 0;
vector<array<int,2>> rem;
function<void(int,int)> dfs = [&](int dep,ll w){
if(dep==(int)v.size()){
if(!cnt) return;
ll tmp = w * qpow(fac[tot-1],cur) % mod * qpow(C[tot][cur] * fac[cur] % mod, tot-cur) % mod * solve(rem) % mod;
if(cnt&1) ans = (ans + tmp) % mod;
else ans = (ans + mod - tmp) % mod;
}
else{
int len = v[dep][0], num = v[dep][1];
for(int i=0;i<=num;i++){
if(i<num) rem.push_back({len,num-i});
dfs(dep+1,C[num][i]*w%mod);
if(i<num) rem.pop_back();
cur += len, cnt++;
}
cur -= len * (num + 1);
cnt -= num + 1;
}
};
dfs(0,1);
return f[v] = ans;
}
int main(){
fac[0] = C[0][0] = 1;
for(int i=1;i<N;i++) fac[i] = fac[i-1] * i % mod;
for(int i=1;i<N;i++){
C[i][0] = 1;
for(int j=1;j<=i;j++) C[i][j] = (C[i-1][j-1] + C[i-1][j]) % mod;
}
int n; cin>>n;
vector<int> a(n+1), vis(n+1);
for(int i=1;i<=n;i++) cin>>a[i];
map<int,int> cnt;
for(int i=1;i<=n;i++) if(!vis[i]){
int len = 0;
for(int j=i;!vis[j];j=a[j]) vis[j] = 1, len++;
cnt[len]++;
}
vector<array<int,2>> init;
for(auto [k,v]: cnt) init.push_back({k,v});
cout<<solve(init)<<endl;
} |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <set>
#include <map>
using namespace std;
#define MOD 1000000007
#define ADD(X,Y) ((X) = ((X) + (Y)%MOD) % MOD)
#define SUB(X,Y) ((X) = ((X) + MOD - (Y)%MOD) % MOD)
typedef long long i64; typedef vector<int> ivec; typedef vector<string> svec;
i64 modpow(i64 x, int p = MOD - 2) {
if (p == 0) return 1;
i64 tmp = modpow(x, p / 2);
tmp = tmp * tmp % MOD;
if (p % 2 == 1) tmp = tmp * x % MOD;
return tmp;
}
int N, P[44];
int uf[505050];
int root(int p) {
return uf[p] < 0 ? p : (uf[p] = root(uf[p]));
}
bool join(int p, int q) {
p = root(p);
q = root(q);
if (p == q) return false;
uf[p] += uf[q];
uf[q] = p;
return true;
}
vector<int> szs;
i64 pows[10000];
i64 sub[42][42];
map<vector<int>, i64> memo;
i64 solve(const vector<int>& seq);
void solve_sub(const vector<int>& seq, vector<int>& new_seq, int p, i64& sto) {
if (p == seq.size()) {
if (seq == new_seq) return;
i64 base = solve(new_seq);
int used = 0;
for (int i = 0; i < seq.size(); ++i) used += szs[i] * (seq[i] - new_seq[i]);
for (int i = 0; i < seq.size(); ++i) {
i64 tmp = pows[used * szs[i]] - 1;
for (int j = 0; j < new_seq[i]; ++j) base = base * tmp % MOD;
}
ADD(sto, base);
return;
}
for (int i = 0; i <= seq[p]; ++i) {
new_seq[p] = i;
solve_sub(seq, new_seq, p + 1, sto);
}
}
i64 fact[44], facti[44];
i64 C[44][44];
i64 solve(const vector<int>& seq) {
if (memo.count(seq)) return memo[seq];
bool flg = true;
for (int i = 0; i < seq.size(); ++i) {
if (seq[i] != 0) flg = false;
}
if (flg) {
return memo[seq] = 1;
}
/*
vector<int> seq2(seq.size(), -1);
solve_sub(seq, seq2, 0, ret);
*/
vector<vector<int>> nxseq; // take as "maximum"
vector<i64> val;
int n_pat = 1;
for (int i = 0; i < seq.size(); ++i) n_pat *= seq[i] + 1;
for (int i = 0; i < n_pat; ++i) {
vector<int> tmp;
int w = i;
for (int j = 0; j < seq.size(); ++j) {
tmp.push_back(w % (seq[j] + 1));
w /= seq[j] + 1;
}
nxseq.push_back(tmp);
if (i == 0) val.push_back(0);
else {
int up = 0, dw = 0;
i64 v = 1;
for (int j = 0; j < seq.size(); ++j) {
dw += szs[j] * (seq[j] - tmp[j]);
}
for (int j = 0; j < seq.size(); ++j) {
v = v * sub[dw][szs[j] * tmp[j]] % MOD * C[seq[j]][tmp[j]] % MOD;
}
for (int j = 0; j < seq.size(); ++j) nxseq[i][j] = seq[j] - nxseq[i][j];
v = v * solve(nxseq[i]) % MOD;
// ADD(ret, solve(nxseq[i]) * val[i]);
for (int j = 0; j < seq.size(); ++j) nxseq[i][j] = seq[j] - nxseq[i][j];
val.push_back(v);
}
}
//printf("now");
//for (int i = 0; i < seq.size(); ++i) printf(" %d", seq[i]);
//puts("");
i64 adder = 1;
for (int i = 0; i < seq.size(); ++i) {
// for (int j = 0; j < nxseq.size(); ++j) {
for (int j = nxseq.size() - 1; j >= 0; --j) {
for (int k = nxseq[j][i] + 1; k <= seq[i]; ++k) {
SUB(val[j], val[j + adder * (k - nxseq[j][i])] * C[k][nxseq[j][i]]);
}
}
adder *= seq[i] + 1;
}
/*for (int i = 0; i < nxseq.size(); ++i) {
for (int j = 0; j < seq.size(); ++j) printf(" %d", nxseq[i][j]);
printf(" -> %lld\n", val[i]);
}*/
i64 ret = 0;
for (int i = 1; i < nxseq.size(); ++i) {
/*
for (int j = 0; j < seq.size(); ++j) nxseq[i][j] = seq[j] - nxseq[i][j];
ADD(ret, solve(nxseq[i]) * val[i]);
for (int j = 0; j < seq.size(); ++j) nxseq[i][j] = seq[j] - nxseq[i][j];
*/
ADD(ret, val[i]);
}
//for (int i = 0; i < seq.size(); ++i) printf("%d ", seq[i]);
//printf("-> %lld\n", ret);
return memo[seq] = ret;
}
void precomp() {
pows[0] = 1;
for (int i = 1; i < 10000; ++i) {
pows[i] = pows[i - 1] * 2 % MOD;
if (pows[i] == 1) puts("angry");
}
fact[0] = 1;
for (int i = 1; i <= 40; ++i) fact[i] = fact[i - 1] * i % MOD;
for (int i = 0; i <= 40; ++i) facti[i] = modpow(fact[i]);
for (int i = 0; i <= 40; ++i) {
for (int j = 0; j <= i; ++j) C[i][j] = fact[i] * facti[j] % MOD * facti[i - j] % MOD;
}
for (int i = 0; i <= N - 1; ++i) {
i64 tmp = 0;
for (int j = 0; j <= i; ++j) {
ADD(tmp, fact[i] * facti[i - j] % MOD * fact[N - 1 - j]);
}
sub[i][0] = 1;
for (int j = 1; j <= 40; ++j) sub[i][j] = sub[i][j - 1] * tmp % MOD;
}
}
int main()
{
map<int, int> by_size;
if (false) {
by_size.emplace(1, 7);
by_size.emplace(2, 4);
by_size.emplace(3, 2);
by_size.emplace(4, 2);
by_size.emplace(5, 1);
by_size.emplace(6, 1);
N = 40;
} else {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", P + i);
--P[i];
uf[i] = -1;
}
for (int i = 0; i < N; ++i) join(i, P[i]);
vector<int> cycs;
for (int i = 0; i < N; ++i) {
if (root(i) == i) cycs.push_back(-uf[i]);
}
for (int c : cycs) by_size[c] += 1;
}
precomp();
vector<int> init;
for (auto& p : by_size) {
szs.push_back(p.first);
init.push_back(p.second);
}
printf("%lld\n", solve(init));
return 0;
}
|
#include <bits/stdc++.h>
template <int MOD_> struct modnum {
static constexpr int MOD = MOD_;
static_assert(MOD_ > 0, "MOD must be positive");
private:
using ll = long long;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) { if (v < 0) v += MOD; }
explicit operator int() const { return v; }
friend std::ostream& operator << (std::ostream& out, const modnum& n) { return out << int(n); }
friend std::istream& operator >> (std::istream& in, modnum& n) { ll v_; in >> v_; n = modnum(v_); return in; }
friend bool operator == (const modnum& a, const modnum& b) { return a.v == b.v; }
friend bool operator != (const modnum& a, const modnum& b) { return a.v != b.v; }
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
friend modnum inv(const modnum& m) { return m.inv(); }
modnum neg() const {
modnum res;
res.v = v ? MOD-v : 0;
return res;
}
friend modnum neg(const modnum& m) { return m.neg(); }
modnum operator- () const {
return neg();
}
modnum operator+ () const {
return modnum(*this);
}
modnum& operator ++ () {
v ++;
if (v == MOD) v = 0;
return *this;
}
modnum& operator -- () {
if (v == 0) v = MOD;
v --;
return *this;
}
modnum& operator += (const modnum& o) {
v -= MOD-o.v;
v = (v < 0) ? v + MOD : v;
return *this;
}
modnum& operator -= (const modnum& o) {
v -= o.v;
v = (v < 0) ? v + MOD : v;
return *this;
}
modnum& operator *= (const modnum& o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum& operator /= (const modnum& o) {
return *this *= o.inv();
}
friend modnum operator ++ (modnum& a, int) { modnum r = a; ++a; return r; }
friend modnum operator -- (modnum& a, int) { modnum r = a; --a; return r; }
friend modnum operator + (const modnum& a, const modnum& b) { return modnum(a) += b; }
friend modnum operator - (const modnum& a, const modnum& b) { return modnum(a) -= b; }
friend modnum operator * (const modnum& a, const modnum& b) { return modnum(a) *= b; }
friend modnum operator / (const modnum& a, const modnum& b) { return modnum(a) /= b; }
};
template <typename T> T pow(T a, long long b) {
assert(b >= 0);
T r = 1; while (b) { if (b & 1) r *= a; b >>= 1; a *= a; } return r;
}
int main() {
using namespace std;
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int N; cin >> N;
vector<int> A(N); for (auto& a : A) { cin >> a; a--; }
using num = modnum<int(1e9)+7>;
vector<num> fact(N+1);
fact[0] = 1;
for (int i = 1; i <= N; i++) fact[i] = fact[i-1] * num(i);
vector<num> ifact(N+1);
ifact[N] = inv(fact[N]);
for (int i = N; i >= 1; i--) ifact[i-1] = ifact[i] * num(i);
vector<num> p2(N*N+1);
p2[0] = 1;
for (int i = 1; i < int(p2.size()); i++) p2[i] = p2[i-1] + p2[i-1];
using state = array<int, 41>;
vector<map<state, num>> dp(N+1);
array<int, 41> tgt; tgt.fill(0);
for (int i = 0; i < N; i++) {
if (A[i] == -1) continue;
int sz = 0;
for (int j = i; A[j] != -1; ) {
sz++;
int k = A[j];
A[j] = -1;
j = k;
}
tgt[sz]++;
}
vector<num> num_ways(N, num(0));
for (int a = 0; a < N; a++) {
for (int v = 0; v <= a; v++) {
num_ways[a] += (fact[a] * ifact[a-v]) * fact[N-1-v];
}
}
state EMPTY; EMPTY.fill(0);
dp[0][EMPTY] = 1;
for (int ab = 1; ab <= N; ab++) {
if (tgt[ab]) {
state cur; cur.fill(0);
cur[ab] = 1;
dp[ab][cur] = 0;
}
for (int a = ab-1, b = 1; a >= 0; a--, b++) {
num weight = pow(num_ways[a], b);
for (const auto& [sa, va] : dp[a]) {
for (const auto& [sb, _] : dp[b]) {
state ns; ns.fill(0);
int num_b = 0;
num nv = va;
for (int i = 1; i <= N; i++) {
if (sa[i] + sb[i] > tgt[i]) {
goto bad;
}
num_b ^= sb[i];
ns[i] = sa[i]+sb[i];
nv *= fact[ns[i]] * ifact[sa[i]] * ifact[sb[i]];
}
nv *= weight;
nv = (num_b & 1) ? nv : -nv;
dp[ab][ns] += nv;
bad:;
}
}
}
}
num ans = dp[N][tgt];
cout << ans << '\n';
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
void problem_solver() {
int n, u, v;
cin >> n >> u >> v;
vector<int> a(n);
bool t1 = false, t2 = false, t3 = false;
for(int i=0; i<n; i++) cin >> a[i];
for(int i=0; i<n-1; i++) {
if(abs(a[i] - a[i+1]) > 1) {
cout << 0;
return;
}
if(a[i] - a[i+1] == 0) t1 = true;
if(abs(a[i] - a[i+1]) == 1) t2 = true;
}
int cost = INT_MAX;
if(t1) {
cost = 2 * v;
cost = min(cost, u + v);
}
if(t2) {
cost = min(cost, min(u, v));
}
cout << cost;
}
int main() {
int tt;
cin >> tt;
for(int t=1; t<=tt; t++) {
problem_solver();
cout << "\n";
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define fastread ios_base::sync_with_stdio(false),cin.tie(NULL)
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define yes printf("YES\n")
#define no printf("NO\n")
#define mx (ll)3000003
#define pb push_back
ll ar[mx];
int main()
{
fastread;
ll test,i,j;
cin>>test;
for(ll t=1;t<=test;t++)
{
ll n,u,v,f=0;
cin>>n>>u>>v;
for(i=1;i<=n;i++)
{
cin>>ar[i];
}ll f2=0;
for(i=1;i<n;i++)
{
if(abs(ar[i]-ar[i+1])>=2)f=1;
if(abs(ar[i]-ar[i+1])>=1)f2=1;
}
if(f==1)cout<<0<<endl;
else if(f2==1)
{
cout<<min(u,v)<<endl;
}
else
{
cout<<min(u+v,2*v)<<endl;
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);
void sol(){
int n,u,v;
int f=0;
cin>>n>>u>>v;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin>>a[i];
if(i){
f=max(f,abs(a[i]-a[i-1]));
}
}
if(f>1)cout<<0;
else if(f==0) cout<<min(2*v,u+v);
else cout<<min(u,v);
}
signed main(){
//fast;
int t=1; cin>>t;
while(t--){
sol();
cout<<"\n";
}
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef long double ld;
#define FOR(i, a, b) for(int i = a; i < b; i++)
#define ROF(i, a, b) for(int i = a; i >= b; i--)
#define ms memset
#define pb push_back
#define F first
#define S second
ll MOD = 1000000007;
ll power(ll base, ll n){
if (n == 0) return 1;
if (n == 1) return base;
ll halfn = power(base, n/2);
if (n % 2 == 0) return (halfn * halfn) % MOD;
return (((halfn * halfn) % MOD) * base) % MOD;
}
ll inverse(ll n){
return power(n, MOD-2);
}
ll add(ll a, ll b){
return (a+b) % MOD;
}
ll mul(ll a, ll b){
return (a*b) % MOD;
}
int main(){
ios::sync_with_stdio(false);
int TC; cin >> TC;
while (TC--){
int n, u, v; cin >> n >> u >> v;
vi a(n); FOR(i, 0, n) cin >> a[i];
int maxi = 0; FOR(i, 1, n) maxi = max(maxi, abs(a[i]-a[i-1]));
if (maxi == 0){
cout << min(2*v, u+v) << '\n'; continue;
}
if (maxi == 1){
cout << min(u, v) << '\n'; continue;
}
cout << 0 << '\n';
}
return 0;
}
|
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define TEST int t; cin>>t; while(t--)
#define pb push_back
#define mii map <int, int>
#define umii unordered_map <int,int>
#define pii pair <int, int>
#define vi vector <int>
#define ff first
#define ss second
#define vpii vector <pair <int, int> >
#define vvi vector <vector <int> >
#define vb vector <bool>
#define mp make_pair
#define rep(i,a,b) for (int i = a; i < (b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define dbg(x); {cout<<#x<<"="<<x<<", ";}
#define in(x); { for (auto &to : x) cin>>to;}
#define out(x); { for (auto &to : x) cout<<to<<" ";cout<<'\n'; }
#define endl "\n"
#define MAX 1e18
#define MIN INT_MIN
#define mod 1000000007
//----------------------------------SEIVE---------------------------------------------//
vector<int>prime;
bitset<1000030>vis;
void seive()
{
vis.set();
vis[0] = false;
vis[1] = false;
vis[2] = true;
prime.pb(2);
for (int i = 3; i <= 1000030; i += 2)
{
if (vis[i] == 1)
{
prime.pb(i);
for (int j = i * i; j <= 1000030; j += i)
{
vis[j] = 0;
}
}
}
}
//----------------------------------SEIVE---------------------------------------------//
//--------------------------------CHECKPRIME------------------------------------------//
bool isPrime(int n)
{
if (n < 2) return false;
if (n < 4) return true;
if (!(n & 1)) return false;
if (n % 3 == 0) return false;
int lim = sqrt(n);
for (int i = 5; i <= lim; i += 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
//--------------------------------CHECKPRIME------------------------------------------//
//-------------------------------PRIME FACTORS----------------------------------------//
map<int, int> primeFact(int n) {
map<int, int> mp;
while (n % 2 == 0) {
mp[2]++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
mp[i]++;
n = n / i;
}
}
if (n > 2) {
mp[n]++;
}
return mp;
}
//-------------------------------PRIME FACTORS----------------------------------------//
//----------------------------BINOMIAL COEFFICIENT------------------------------------//
int binomialCoeff(int n, int k)
{
if (k > n)return 0;
int C[n + 1][k + 1];
int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] % (mod) + C[i - 1][j] % (mod)) % (mod);
}
}
return C[n][k];
}
//----------------------------BINOMIAL COEFFICIENT------------------------------------//
int countDivisors(int n) {
int cnt = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i)cnt++;
else {
cnt += 2;
}
}
}
return cnt;
}
int reverse_number(int n) {
int rev = 0, r;
while (n != 0) {
r = n % 10;
rev = rev * 10 + r;
n /= 10;
}
return rev;
}
void solve() {
int n, u, v;
cin >> n >> u >> v;
int a[n + 1];
rep(i, 1, n + 1)cin >> a[i];
int mn = MAX;
for (int i = 2; i <= n; i++) {
if (abs(a[i - 1] - a[i]) >= 2) {
cout << 0 << endl; return;
}
if (a[i] == a[i - 1]) {
int c = MAX;
if (i >= 3) {
if (a[i] != a[i - 2] && a[i] != a[i - 1]) {
c = 2 * u;
}
}
mn = min(mn, min(v + u, min(2 * v, c)));
}
else {
mn = min(mn, min(u, v));
}
}
cout << mn << endl;
}
signed main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false); cin.tie(0);
//seive();
TEST
solve();
//for graph see start vertex is 1 or 0(mistake done many times).
// so for applying dfs iter from 1 to n(when root is 1)
// Be alert while using unordered-map (if TLE this might be reason).
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int min(int a,int b)
{
return a<b?a:b;
}
int main()
{
int t;
cin>>t;
while(t--)
{
int x[100005];
int n,u,v,flag;
cin>>n>>u>>v;
for(int i=0;i<n;i++)
cin>>x[i];
for(int i=0;i<n-1;i++)
{
int ans=abs(x[i]-x[i+1]);
if(ans==0)
{
flag=0;
break;
}
}
for(int i=0;i<n-1;i++)
{
int ans=abs(x[i]-x[i+1]);
if(ans==1)
{
flag=1;
break;
}
}
for(int i=0;i<n-1;i++)
{
int ans=abs(x[i]-x[i+1]);
if(ans>=2)
{
flag=2;
break;
}
}
if(flag==0)
cout<<v+min(v,u)<<endl;
else if(flag==1)
cout<<min(v,u)<<endl;
else
cout<<0<<endl;
}
return 0;
}
|
#include <iostream>
#include<bits/stdc++.h>
#define lli long long int
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define fr(i,n) for(i=0;i<n;i++)
#define F first
#define S second
#define ios ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define mod 998244353
#define pi 3.14159265
using namespace std;
int main() {
ios
long long int t,i,x,y,m,n,j,k,ans=0,count=0,tot=0,flag,od,ev,sum,ma,mi;
cin>>t;
while(t--)
{
cin>>n>>x>>y;
lli a[n];
flag=0;
cin>>a[0];
tot=a[0];
ans=0;
fr(i,n-1)
{
cin>>a[i+1];
if(a[i+1]!=tot)
{
flag=1;
}
if(abs(a[i+1]-a[i])>1)
{
ans=1;
}
}
if(ans==1)
{
cout<<"0\n";
}
else if(flag==1)
{
cout<<min(x,y)<<"\n";
}
else
{
cout<<min(x+y,y+y)<<"\n";
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define vl vector<long>
#define pb push_back
#define jaldi ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define loop(i,a,b) for(int i=a;i<b;i++)
typedef long long ll;
typedef vector<vector<ll>> matrix;
typedef priority_queue<ll> max_heap;
typedef priority_queue<ll, vector<ll>, greater<ll> > min_heap;
vector<ll> segmentedSieve(ll n);
long long lcm(ll a, ll b);
int gcd(ll a, ll b);
ll nCr(ll n, ll k);
const ll MOD = 1000000000;
int main(){
jaldi;
// file_mathi_input; //(input.txt) ( this mode is only available for main() )
// file_ma_output; //(output.txt) ( this mode is only available for main() )
int t;
cin>>t;
while(t--){
ll n;
cin>>n;
ll u,v;
cin>>u>>v;
ll arr[n];
bool needed = true;
//u niche v aju baaju
loop(i,0,n){
cin>>arr[i];
}
loop(i,1,n){
if(i != 0){
if(arr[i-1] == arr[i]){
//straight
}
else{
if( abs(arr[i-1] - arr[i] ) >= 2){
needed = false;
break;
}
}
}
}
bool straight = true;
loop(i,1,n){
if(arr[i-1] != arr[i] ){
straight = false;
break;
}
}
//cout<<straight<<" "<<endl;
if(needed){
if(!straight){
ll cost = min( u,v );
cout<<cost<<endl;
}
else{
ll cost = min(u+v, 2*v);
cout<<cost<<endl;
}
}
else cout<<0<<endl;
}
return 0;
}
void simpleSieve(ll limit, vector<ll> &prime)
{
bool mark[limit+1];
memset(mark, true, sizeof(mark));
for (ll p=2; p*p<limit; p++)
{
if (mark[p] == true)
{
for (ll i=p*p; i<limit; i+=p)
mark[i] = false;
}
}
for (int p=2; p<limit; p++)
{
if (mark[p] == true)
{
prime.push_back(p);
//cout << p << " ";
}
}
}
vector<ll> segmentedSieve(ll n)
{
int limit = floor(sqrt(n))+1;
vector<ll> prime;
simpleSieve(limit, prime);
vector<ll> ans = prime;
int low = limit;
int high = 2*limit;
while (low < n)
{
if (high >= n)
high = n;
bool mark[limit+1];
memset(mark, true, sizeof(mark));
for (int i = 0; i < prime.size(); i++)
{
int loLim = floor(low/prime[i]) * prime[i];
if (loLim < low)
loLim += prime[i];
for (int j=loLim; j<high; j+=prime[i])
mark[j-low] = false;
}
for (int i = low; i<high; i++)
if (mark[i - low] == true) ans.push_back(i);
low = low + limit;
high = high + limit;
}
return ans;
}
int gcd(ll a, ll b)
{
// Everything divides 0
if (a == 0)
return b;
if (b == 0)
return a;
// base case
if (a == b)
return a;
// a is greater
if (a > b)
return gcd(a-b, b);
return gcd(a, b-a);
}
long long lcm(ll a, ll b)
{ return (a / gcd(a, b)) * b; }
ll nCr(ll n, ll k)
{
ll res = 1;
if (k > n - k)
k = n - k;
for (int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
|
#include <bits/stdc++.h>
#define DB double
#define LL long long
#define MST(a,b) memset((a),(b),sizeof(a))
#ifdef _DEBUG_
#define MRK() cout<<"Mark"<<endl;
#define WRT(x) cout<<#x<<" = "<<(x)<<endl;
#else
#define MRK() ;
#define WRT(x) ;
#endif
#define MAXN 1010000
#define MAXM 2010000
#define MOD 998244353 //1000000007
#define INF 0x3f3f3f3f
#define LLINF 0x3f3f3f3f3f3f3f3f
#define EPS 1e-5
#define _ 0
using namespace std;
int n,u,v;
int a[MAXN];
void init()
{
}
void work()
{
scanf("%d%d%d",&n,&u,&v);
for (int i=1;i<=n;i++)
scanf("%d",&a[i]);
bool f1=false;
for (int i=2;i<=n;i++)
{
if (abs(a[i]-a[i-1])>=2)
{
printf("%d\n",0);
return;
}
if (abs(a[i]-a[i-1])==1)
{
f1=true;
}
}
int ans=0;
if (f1==false)
{
ans=min(u+v,v+v);
}
else
{
ans=min(u,v);
}
printf("%d\n",ans);
}
int main()
{
#ifdef _DEBUG_
freopen("C:/Users/DELL/Documents/Dev-C++/sample.in","r",stdin);
#endif
init();
int casenum=1;
scanf("%d",&casenum);
for (int testcase=1;testcase<=casenum;testcase++)
{
#ifdef _DEBUG_
printf("Case #%d:\n",testcase);
#endif
work();
}
return ~~(0^_^0);
}
|
#include<bits/stdc++.h>
#define M 1000000007
#define ll long long
#define pb push_back
#define pi pair<int,int>
#define mp make_pair
#define vi vector<int>
#define vb vector<bool>
#define vll vector <long long>
#define tests int tc; cin>>tc; while(tc--)
#define defsort(arr) sort(arr.begin(), arr.end());
#define csort(arr, cmp) sort(arr.begin(), arr.end(), cmp);
#define printArray(a) for(auto num : a){cout<<num<<" ";}cout<<"\n";
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL);
using namespace std;
int main(){
// fastio;
int t = 1;
tests{
int i,n;
ll u,v;
cin>>n>>u>>v;
vi a(n);
for(i=0;i<n;i++){
cin>>a[i];
}
// cout<<"tests "<<t++<<": ";
// check if no wall
for(i=1;i<n;i++){
if(abs(a[i]-a[i-1]) > 1){
break;
}
}
if(i < n){
cout<<"0\n";
continue;
}
// need to break wall
ll minCost = INT_MAX;
for(i=1;i<n;i++){
if(abs(a[i]-a[i-1]) == 1){
minCost = min({minCost, u, v});
}
else if(abs(a[i]-a[i-1]) == 0){
minCost = min(minCost, v+min(u,v));
}
}
cout<<minCost<<"\n";
}
return 0;
} |
#include<bits/stdc++.h>
typedef long long int ll;
typedef long double ld;
#define mp make_pair
#define pb push_back
#define P pair<ll,ll>
#define F first
#define S second
#define vll vector<ll>
#define vpll vector<P>
#define vvll vector<vll>
#define vvpll vector<vpll>
#define mll map<ll,ll>
#define M map
#define V vector
#define mod2 998244353
#define mod 1000000007
#define C cout<<fixed<<setprecision(5)
using namespace std;
ll calculate(ll p, ll q) { ll modx = 998244353, expo; expo = modx - 2; while (expo) { {if (expo & 1)p = (p * q) % modx;}q = (q * q) % modx; expo >>= 1; } return p%modx; }
ll power(ll x, ll y, ll p) { ll res = 1; x = x % p; if (x == 0) return 0; while (y > 0) { if (y & 1) {res = (res*x) % p;} y = y>>1;x = (x*x) % p; } return res; }
int main()
{
ios_base:: sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll t;
cin >> t;
while (t--){
ll n,u,v,k=0;
cin>>n>>u>>v;
ll a[n];
for(ll i=0;i<n;i++) cin>>a[i];
for(ll i=1;i<n;i++){
if(a[i]!=a[i-1]) {k=1; break;}
}
if(k==0) cout<<min(u+v,v+v)<<"\n";
else{
for(ll i=1;i<n;i++){
if(abs(a[i]-a[i-1])>1) {k=0; break;}
}
if(k==0) cout<<0<<"\n";
else cout<<min(u,v)<<"\n";
}
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned int u_int;
struct ostacolo_t{
int i, j;
};
vector<int> ostacoli;
int main(){
//freopen("input.txt", "r", stdin);
int T, N, U, V;
cin>>T;
while(T--){
cin>>N>>U>>V;
for(int i = 0; i < N; i++){
int j; cin>>j;
ostacoli.push_back(j);
}
int min_cost = INT_MAX;
for(int i = 1; i < N; i++){
int prec = ostacoli[i-1];
int j = ostacoli[i];
if(prec == j){
min_cost = min(min_cost, min(U+V, V+V));
}else if(prec == j+1 || prec == j-1){
min_cost = min(min_cost, min(U, V));
}else{
min_cost = 0;
}
}
cout<<min_cost<<endl;
ostacoli.clear();
}
return 0;
} |
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstdlib>
using namespace std;
typedef long long ll;
const int M=1e6+5;
int n,u,v;
ll ans;
int A[M];
void check(int line){
if(A[line]==A[line-1]&&line>1)ans=min(ans,min(0ll+u+v,0ll+v+v));
if(abs(A[line]-A[line-1])>=1)ans=min(ans,min(0ll+v,0ll+u));
}
int main(){
int T;
scanf("%d",&T);
while(T--&&scanf("%d %d %d",&n,&u,&v)){
ans=1e15+7;
for(int i=1;i<=n;i++){
scanf("%d",&A[i]);
}
A[0]=A[1];
bool flag=false;
for(int i=1;i<=n;i++){
if(abs(A[i]-A[i-1])>=2){
puts("0");
flag=true;break;
}
}
if(flag)continue;
for(int i=1;i<=n;i++){
check(i);
}
printf("%lld\n",ans);
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define mp make_pair
#define pb push_back
#define ll long long int
#define sd(x) scanf("%lld",&x)
#define inf 1e18+9
#define pll pair<ll,ll>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
const int MAXN = 1e5+5;
int main() {
fastio;
int test;cin>>test;
while(test--) {
int n;ll u,v;
cin>>n>>u>>v;
vector<int> a(n);
for(int i=0;i<n;i++){
cin>>a[i];
}
bool check = false, check2 = false;;
for(int i=1;i<n;i++) {
if(abs(a[i]-a[i-1])>1) {
check = true;
break;
} else if(abs(a[i]-a[i-1])==1) {
check2 = true;
}
}
if(check) {
cout<<0<<endl;
continue;
}
if(check2) {
cout<<min(u,v)<<endl;
} else {
cout<<v+min(u,v)<<endl;
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.