text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
const long long oo = (long long)1e9;
const double eps = 1e-9;
const long long MODE = 1000000007;
int numbers[31625];
vector<long long> primes;
void sieve() {
numbers[0] = numbers[1] = 1;
for (long long i = 2; (long long)i < 31625; i++) {
if (!numbers[i]) {
for (long long j = (long long)i * i; j < 31625; j += i) {
numbers[j] = 1;
}
}
}
for (int i = 2; i < 31625; i++) {
if (!numbers[i]) primes.push_back(i);
}
}
long long comp[15010][510];
map<int, int> m;
long long ncr(long long n, long long r) {
if (r == 0 || n == r) return 1;
if (comp[n][r] != -1) return comp[n][r];
return comp[n][r] =
((ncr(n - 1, r) % MODE) + (ncr(n - 1, r - 1) % MODE)) % MODE;
}
int main() {
sieve();
memset(comp, -1, sizeof(comp));
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
for (int idx = 0; idx < ((long long)primes.size()); idx++) {
int pf = primes[idx];
if ((long long)pf * pf > x || x == 1) break;
if (x % pf == 0) {
int cnt = 0;
while (x % pf == 0) {
cnt++;
x /= pf;
}
m[pf] += cnt;
}
}
if (x != 1) m[x]++;
}
long long res = 1;
for (map<int, int>::iterator it = m.begin(); it != m.end(); it++) {
res *= (ncr(n + it->second - 1, n - 1) % MODE);
res %= MODE;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
long long c[509][509 * 32];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<long long> v(n);
map<int, int> m;
for (int i = 0; i < n; i++) {
cin >> v[i];
int x = v[i];
for (int j = 2; j * j <= x; j++)
while (x % j == 0) m[j]++, x /= j;
if (x > 1) m[x]++;
}
for (int i = 0; i < 509 * 32; i++) {
for (int j = 0; j <= min(i, 508); j++)
c[j][i] = (j == 0 || i == 0 ? 1 : c[j][i - 1] + c[j - 1][i - 1]) % M;
}
long long ans = 1;
for (auto i : m) ans = ans * c[n - 1][i.second + n - 1] % M;
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
inline int Input() {
int ret = 0;
bool isN = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') isN = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ret = ret * 10 + c - '0';
c = getchar();
}
return isN ? -ret : ret;
}
inline void Output(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
int len = 0, data[20];
while (x) {
data[len++] = x % 10;
x /= 10;
}
if (!len) data[len++] = 0;
while (len--) putchar(data[len] + 48);
putchar('\n');
}
#pragma comment(linker, "/STACK:124000000,124000000")
using namespace std;
long long shit[20005], fac[20005];
long long fast(long long num, int ci) {
long long ans = 1;
while (ci) {
if (ci & 1) ans = ans * num % 1000000007;
num = num * num % 1000000007;
ci = ci >> 1;
}
return ans;
}
int prime[100005];
bool flag[100005];
int sum[100005];
int t;
int q[100005], top;
void pre() {
fac[0] = fac[1] = shit[0] = shit[1] = 1;
for (int i = 2; i <= 20000; i++) {
fac[i] = i * fac[i - 1] % 1000000007;
shit[i] = shit[i - 1] * fast(i, 1000000007 - 2) % 1000000007;
}
memset(flag, 0, sizeof(flag));
int i, j;
t = 0;
for (int i = 2; i <= 100000; i++) {
if (!flag[i]) prime[t++] = i;
for (int j = 0; j < t && i * prime[j] <= 100000; j++) {
flag[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
}
long long C(int x, int y) {
if (y == 0) return 1;
if (x < y) return 0;
return fac[x] * shit[y] % 1000000007 * shit[x - y] % 1000000007;
}
int main() {
pre();
int n;
scanf("%d", &n);
memset(sum, 0, sizeof(sum));
top = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
for (int j = 0; j < t; j++) {
if (x % prime[j] == 0) {
while (x % prime[j] == 0) {
sum[j]++;
x = x / prime[j];
}
}
if (x == 1) break;
}
if (x != 1) {
q[top++] = x;
}
}
long long ans = 1;
for (int i = 0; i < t; i++) {
ans = ans * C(n + sum[i] - 1, sum[i]) % 1000000007;
if (ans == 0) {
printf("%d %d %d\n", n, i, sum[i]);
break;
}
}
sort(q, q + top);
q[top] = -1;
int cnt = 1;
if (ans == 0) printf("ss");
for (int i = 1; i <= top; i++) {
if (q[i] == q[i - 1]) {
cnt++;
} else {
if (C(n + cnt - 1, cnt) == 0) {
printf("%d %lld\n", cnt, ans);
break;
}
ans = ans * C(n + cnt - 1, cnt) % 1000000007;
cnt = 1;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
long long divlist[100001];
long long L = 0;
long long Fact[100001];
long long FastPow(long long k, long long p) {
if (p == 0) return 1;
long long POW = FastPow(k, p / 2);
if (p % 2 == 0)
return (POW * POW) % 1000000007;
else
return (((POW * POW) % 1000000007) * k) % 1000000007;
}
long long C(long long n, long long k) {
long long top, bottom;
long long div;
top = Fact[n];
bottom = Fact[n - k] * Fact[k];
bottom %= 1000000007;
div = FastPow(bottom, 1000000007 - 2);
return (top * div) % 1000000007;
}
long long Solve(long long k) { return C(n + k - 1, n - 1); }
int main() {
long long i, j;
long long a;
long long b;
long long ctr = 0;
long long Ans = 1;
long long mult;
Fact[0] = 1;
for (i = 1; i <= 100000; i++) {
Fact[i] = Fact[i - 1] * i;
Fact[i] %= 1000000007;
}
scanf("%I64d", &n);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a);
b = a;
for (j = 2; j * j <= a; j++) {
while (b % j == 0) {
L++;
divlist[L] = j;
b /= j;
}
}
if (b > 1) {
L++;
divlist[L] = b;
}
}
sort(divlist + 1, divlist + 1 + L);
ctr = 1;
for (i = 2; i <= L; i++) {
if (divlist[i] == divlist[i - 1]) {
ctr++;
} else {
mult = Solve(ctr);
Ans *= mult;
Ans %= 1000000007;
ctr = 1;
}
}
if (L > 0) {
mult = Solve(ctr);
Ans *= mult;
Ans %= 1000000007;
}
printf("%I64d\n", Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1e5;
int n;
map<int, int> m;
long long f[N];
void add(int a) {
for (int j = 2; j * j <= a; j++) {
while (a % j == 0) {
a /= j;
m[j]++;
}
}
if (a != 1) m[a]++;
}
long long F(int n) {
if (n <= 1) return f[n] = 1;
if (f[n] != 0) return f[n];
return f[n] = n * F(n - 1) % MOD;
}
long long fpow(long long x, long long p) {
long long res = 1;
while (p > 0) {
if (p % 2 == 0)
x = x * x % MOD, p /= 2;
else
res = res * x % MOD, p--;
}
return res;
}
long long C(int n, int k) {
return F(n) * fpow(F(k), MOD - 2) % MOD * fpow(F(n - k), MOD - 2) % MOD;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
add(a);
}
long long ans = 1;
for (auto it = m.begin(); it != m.end(); it++) {
ans = ans * C(n + it->second - 1, it->second) % MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007LL;
long long eleva(long long a, long long b) {
if (b == 0) return 1;
long long aux = eleva(a, b / 2);
aux *= aux;
aux %= MOD;
if (b & 1) aux *= a;
aux %= MOD;
return aux;
}
vector<vector<long long> > B;
long long calcula(long long num, long long n) {
if (n > num) return 0LL;
long long lol = 1;
for (long long i = num - n + 1; i <= num; ++i) {
lol *= i;
lol %= MOD;
}
for (long long i = 1; i <= n; ++i) {
lol *= eleva(i, MOD - 2);
lol %= MOD;
}
return lol;
}
int main() {
long long NN = 505;
B = vector<vector<long long> >(NN, vector<long long>(NN));
B[0][0] = 1;
for (long long i = 1; i < NN; ++i) {
for (int j = 0; j < NN; j++) {
B[i][j] += B[i - 1][j];
B[i][j] %= MOD;
if (j) {
B[i][j] += B[i - 1][j - 1];
B[i][j] %= MOD;
}
}
}
long long n, aux;
cin >> n;
map<long long, long long> M;
for (int i = 0; i < n; i++) {
cin >> aux;
for (long long i = 2; i * i <= aux; ++i) {
while (aux % i == 0) {
M[i]++;
aux /= i;
}
}
if (aux > 1) M[aux]++;
}
long long res = 1;
for (map<long long, long long>::iterator it = M.begin(); it != M.end();
++it) {
long long num = it->second + n - 1;
if (num < NN)
res *= B[(it->second) + n - 1][n - 1];
else {
long long lol = calcula(num, n - 1);
res *= lol;
res %= MOD;
}
res %= MOD;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e14 + 9;
int facts[200009];
long long mult(long long a, long long b) { return a * b % 1000000007; }
long long fastpow(long long a, long long b) {
long long calc = 1;
for (; b >= 1LL; b /= 2LL) {
if ((b & 1LL)) calc = mult(calc, a);
a = mult(a, a);
}
return calc;
}
long long soma(long long a, long long b) {
if (a + b >= 1000000007)
return a + b - 1000000007;
else
return a + b;
}
long long subt(long long a, long long b) {
if (a - b < 0)
return a - b + 1000000007;
else
return a - b;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
facts[0] = 1;
for (long long i = 1; i < (200009); ++i) {
facts[i] = mult(facts[i - 1], i);
}
long long n;
cin >> n;
int prims = 0;
map<int, int> cont;
for (long long i = 0; i < (n); ++i) {
long long a;
cin >> a;
for (long long j = 2; j < (sqrt(a) + 1); ++j) {
if (a % j == 0) {
while (a % j == 0) {
cont[j]++;
a /= j;
}
}
}
if (a != 1) cont[a]++;
}
long long ans = 1;
for (auto e : cont) {
ans = mult(ans, mult(facts[n - 1 + e.second],
fastpow(mult(facts[n - 1], facts[e.second]),
1000000007 - 2)));
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int maxn = 2e5;
long long n, k, a[maxn], fact[maxn];
map<long long, long long> cnt;
map<long long, long long>::iterator it;
long long ans = 1;
long long binnn(long long a, long long n) {
if (n == 0) return 1;
long long z = binnn(a, n / 2);
z = (z * z) % 1000000007;
if (n & 1) z = (z * a) % 1000000007;
return z;
}
long long cnk(long long e1, long long e4) {
if (e1 < e4) return 0;
if (e1 < 0 || e4 < 0) return 0;
long long x = binnn(fact[e1 - e4], 1000000007 - 2) % 1000000007;
long long y = binnn(fact[e4], 1000000007 - 2) % 1000000007;
return (((x * fact[e1]) % 1000000007) * y) % 1000000007;
}
int main() {
fact[0] = 1;
for (int i = 1; i <= 1e5; i++) fact[i] = (fact[i - 1] * i) % 1000000007;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 2; j * j <= a[i]; j++) {
while (a[i] % j == 0) {
a[i] /= j;
cnt[j]++;
}
}
if (a[i] > 1) cnt[a[i]]++;
}
for (it = cnt.begin(); it != cnt.end(); it++) {
long long x = it->second;
ans = (ans * cnk(x + n - 1, n - 1)) % 1000000007;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 550, maxc = 18000, maxp = 100050, maxps = 11000,
mod = 1000000007;
int p[maxps], s, s0;
bool whe[maxp] = {0};
long long f[maxc][maxn] = {0}, c[maxc] = {0}, ans = 1;
int n, fac[maxps] = {0}, cmax;
void init() {
int i, j;
for (i = 2; i < maxp; i++) {
if (!whe[i]) p[s++] = i;
for (j = 0; j < s && i * p[j] < maxp; j++) {
whe[i * p[j]] = 1;
if (!(i % p[j])) break;
}
}
c[0] = 1, c[1] = n;
for (i = 1; i <= n; i++) f[1][i] = 1;
for (i = 2; i < maxc; i++) {
f[i][1] = 1;
for (j = 1; j <= n; j++) {
f[i][j] = (f[i][j - 1] + f[i - 1][j]) % mod;
c[i] += f[i][j], c[i] %= mod;
}
}
}
int main() {
int i, j, k, t;
scanf("%d", &n);
init();
s0 = s;
for (i = 0; i < n; i++) {
scanf("%d", &t);
for (j = 0; j < s && t > 1; j++)
while (!(t % p[j])) fac[j]++, t /= p[j];
if (t > 1) p[s] = t, fac[s]++, s++;
}
for (i = 0; i < s; i++) ans *= c[fac[i]], ans %= mod;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> m;
long long fact[20005];
long long inv[20005];
long long powmod(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res = (res * a) % 1000000007;
}
a = (a * a) % 1000000007;
b /= 2;
}
return res;
}
void compute() {
fact[0] = 1;
inv[0] = 1;
for (long long i = 1; i < 20005; i++) {
fact[i] = fact[i - 1] * i;
fact[i] = fact[i] % 1000000007;
inv[i] = powmod(fact[i], 1000000007 - 2);
}
}
void factorize(long long a) {
while (a % 2 == 0) {
m[2]++;
a /= 2;
}
for (long long i = 3; i * i <= a; i += 2) {
while (a % i == 0) {
m[i]++;
a /= i;
}
}
if (a > 1) {
m[a]++;
}
}
signed main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long a;
long long ans = 1;
for (long long i = 0; i < n; i++) {
cin >> a;
factorize(a);
}
compute();
for (auto& i : m) {
long long z1 = i.second;
long long z2 = n - 1;
ans *= fact[z1 + z2];
ans = ans % 1000000007;
ans *= inv[z1];
ans = ans % 1000000007;
ans *= inv[z2];
ans = ans % 1000000007;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
bool notPrime[100005] = {};
long long c[17000][503] = {};
const long long mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
c[0][0] = c[1][0] = c[1][1] = 1;
for (int i = 1; i <= 16500; i++) {
c[i][0] = 1;
for (int j = 1; j <= 501; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
for (int i = 2; i <= 400; i++) {
if (!notPrime[i]) {
primes.push_back(i);
for (int j = 2 * i; j <= 1e5; j += i) notPrime[j] = true;
}
}
for (int i = 401; i <= 1e5; i++) {
if (!notPrime[i]) {
primes.push_back(i);
}
}
vector<int> l;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
for (int p : primes) {
while (a % p == 0) {
a /= p;
l.push_back(p);
}
}
if (a > 1) l.push_back(a);
}
long long ans = 1;
if (l.size() != 0) {
sort(l.begin(), l.end());
int cnt = 1;
for (int i = 1; i < l.size(); i++) {
if (l[i] != l[i - 1]) {
ans = (ans * c[cnt + n - 1][n - 1]) % mod;
cnt = 1;
} else
cnt++;
}
ans = (ans * c[cnt + n - 1][n - 1]) % mod;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int arr[501];
long long int c[31 * 501][600];
map<long long int, long long int> mp;
void primefactcalc(long long int n) {
long long int no = 0;
while (n % 2 == 0) {
n = n / 2;
no++;
}
if (no > 0) mp[2] += no;
for (int i = 3; i * i <= n; i += 2) {
no = 0;
while (n % i == 0) {
n /= i;
no++;
}
if (no > 0) {
mp[i] += no;
}
}
if (n > 2) mp[n] += 1;
}
void init() {
for (int i = 0; i < 31 * 501; i++) {
for (int j = 0; j <= min(i, 500); j++) {
if (i == 0 || j == i)
c[i][j] = 1;
else {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
init();
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i];
primefactcalc(arr[i]);
}
long long int res = 1;
for (auto it : mp) {
long long int temp = it.second;
res = (res * (c[N + temp - 1][N - 1])) % 1000000007;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20004, MOD = 1000000007;
int f[N];
int power(int x, int y) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = (res * 1ll * x) % MOD;
}
x = (x * 1ll * x) % MOD;
y /= 2;
}
return res;
}
int c(int n, int r) {
return f[n] * 1ll * power(f[n - r] * 1ll * f[r] % MOD, MOD - 2) % MOD;
}
void factorize(int x, map<int, int> &pf) {
for (int i = 2; i * i <= x; ++i) {
int cnt = 0;
while (x % i == 0) {
x /= i;
++cnt;
}
pf[i] += cnt;
}
++pf[x];
}
int main() {
int n;
scanf("%d", &n);
map<int, int> pf;
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
factorize(a, pf);
}
f[0] = 1;
for (int i = 1; i < N; ++i) {
f[i] = (f[i - 1] * 1ll * i) % MOD;
}
int res = 1;
for (auto k : pf) {
if (k.first > 1 && k.second) {
res = (res * 1ll * c(k.second + n - 1, n - 1)) % MOD;
}
}
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 2 * acos(0);
const long double eps = 1e-15;
const int inf = 1e9 + 7;
const long long Linf = (long long)1e18 + 7;
const int MOD = 1e9 + 7;
const int LMAX = 1e6 + 7;
const int MAX = 1e5 + 7;
const int BASE = 1e9 + 7;
int dx[] = {-1, 0, 0, 1};
int dy[] = {0, -1, 1, 0};
long long POW(long long a, long long b) {
if (b == 0) return 1;
long long p = POW(a, b / 2);
p *= p;
p %= BASE;
if (b & 1)
return p * a % BASE;
else
return p % BASE;
}
long long inverse_mod(long long a) { return POW(a, BASE - 2); }
long long nCk(long long n, long long k) {
long long N = 1, K = 1, NK = 1;
for (int i = (1); i <= (n); i++) {
N = N * i % BASE;
if (i <= k) K = K * i % BASE;
if (i <= n - k) NK = NK * i % BASE;
}
K = K * NK % BASE;
return N * inverse_mod(K) % BASE;
}
map<long long, long long> a;
set<long long> s;
long long n;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = (1); i <= (n); i++) {
long long tmp;
cin >> tmp;
for (int j = (2); j <= (sqrt(tmp)); j++) {
if (tmp % j == 0) {
s.insert(j);
while (tmp % j == 0) {
a[j]++;
tmp /= j;
}
}
}
if (tmp != 1) {
s.insert(tmp);
a[tmp]++;
}
}
long long res = 1;
for (typeof(s.begin()) i = s.begin(); i != s.end(); i++) {
long long tmp = (*i);
tmp = a[tmp];
res *= nCk(tmp + n - 1, tmp);
res %= BASE;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC diagnostic ignored "-Wwrite-strings"
using namespace std;
template <class T, class U>
ostream &operator<<(ostream &out, const pair<T, U> &A) {
out << A.first << "_" << A.second;
return out;
}
template <template <typename, typename> class ContainerT, typename ValueT>
ostream &operator<<(ostream &out,
const ContainerT<ValueT, std::allocator<ValueT> > &A) {
for (__typeof((A).begin()) i = (A).begin(); i != (A).end(); ++i)
out << *i << " ";
return out;
}
template <template <typename, typename> class ContainerT, typename ValueT,
typename ValueU>
ostream &operator<<(
ostream &out, const ContainerT<pair<ValueT, ValueU>,
std::allocator<pair<ValueT, ValueU> > > &A) {
for (__typeof((A).begin()) i = (A).begin(); i != (A).end(); ++i)
out << *i << " ";
return out;
}
template <class T>
void mini(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
void maxi(T &a, const T &b) {
if (b > a) a = b;
}
const int MAX = 1e5;
const long long MOD = 1000000007;
map<int, int> M;
const int MAX_N = 500 * 30 + 1;
const int MAX_R = 500 + 1;
vector<vector<int> > comb(MAX_N + 1, vector<int>());
void calcComb() {
for (int n = (1); n <= (MAX_N); ++n) {
comb[n].push_back(1);
for (int r = (1); r <= (min(n - 1, MAX_R)); ++r)
comb[n].push_back((comb[n - 1][r] + comb[n - 1][r - 1]) % MOD);
if (n < MAX_R) comb[n].push_back(1);
}
}
long long harmony(int n, int r) {
assert(min(r, n - 1) <= MAX_R);
return comb[n + r - 1][min(r, n - 1)];
}
vector<pair<int, int> > naive_factori(long long A) {
if (not A) return vector<pair<int, int> >();
assert(A <= MAX * MAX);
vector<pair<int, int> > ret;
for (int i = 2; i * i <= A; ++i) {
int cnt = 0;
while (A % i == 0 and ++cnt) A /= i;
if (cnt) ret.push_back(make_pair(i, cnt));
}
if (A > 1) ret.push_back(make_pair(A, 1));
return ret;
}
int N;
long long solve() {
M.clear();
cin >> N;
vector<long long> A(N);
for (int i = 0; i < (N); ++i) cin >> A[i];
vector<vector<pair<int, int> > > C;
for (__typeof((A).begin()) i = (A).begin(); i != (A).end(); ++i)
C.push_back(naive_factori(*i));
for (__typeof((C).begin()) i = (C).begin(); i != (C).end(); ++i)
for (int j = 0; j < ((int)(*i).size()); ++j)
M[(*i)[j].first] += (*i)[j].second;
long long ans = 1;
for (__typeof((M).begin()) i = (M).begin(); i != (M).end(); ++i) {
ans *= harmony(N, (*i).second);
ans %= MOD;
}
return ans;
}
int main() {
calcComb();
cout << solve() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<unsigned long long> primos;
map<unsigned long long, unsigned long long> pan;
unsigned long long yu = 1;
unsigned long long gcd(unsigned long long a, unsigned long long b) {
if (a < b) {
unsigned long long tmp = a;
a = b;
b = tmp;
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
unsigned long long combi(unsigned long long a, unsigned long long b) {
if (b == 0 or b == a) {
yu = yu * 1;
return 0;
}
if (b == 1 or b == a - 1) {
yu = (yu * a) % 1000000007;
return 0;
}
unsigned long long c = a - b;
if (c > b) {
unsigned long long tmp = c;
c = b;
b = tmp;
}
vector<unsigned long long> product;
for (unsigned long long i = b + 1; i <= a; i++) {
product.push_back(i);
}
for (unsigned long long i = 1; i <= c; i++) {
unsigned long long moho = i;
unsigned long long k = 0;
while (moho != 1) {
unsigned long long d = gcd(product[k], moho);
if (d > 1) {
product[k] = product[k] / d;
moho = moho / d;
}
k++;
}
}
for (unsigned long long i = 0; i < product.size(); i++) {
yu = (yu * product[i]) % 1000000007;
}
}
unsigned long long descomponer(unsigned long long a) {
if (a == 1) {
return 0;
} else if (a == 2) {
pan[2]++;
return 0;
} else if (a == 3) {
pan[3]++;
return 0;
}
unsigned long long k = 0;
while (primos[k] <= sqrt(a) and k < primos.size()) {
while (a % primos[k] == 0) {
pan[primos[k]]++;
a = a / primos[k];
}
k++;
}
if (a != 1) {
pan[a]++;
}
return 0;
}
int main() {
long long jeur;
unsigned long long ji = sqrt(1000000000);
vector<unsigned long long> vec(ji);
primos.push_back(2);
for (unsigned long long i = 3; i <= ji; i = i + 2) {
if (vec[i] == 0) {
primos.push_back(i);
unsigned long long k = i * i;
while (k <= ji) {
vec[k] = 1;
k = k + 2 * i;
}
}
}
unsigned long long h;
cin >> h;
for (unsigned long long i = 0; i < h; i++) {
unsigned long long g;
cin >> g;
descomponer(g);
}
for (std::map<unsigned long long, unsigned long long>::iterator i =
pan.begin();
i != pan.end(); i++) {
combi(h + (i->second) - 1, i->second);
}
cout << yu << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:64000000")
const int infi = 1e9 + 7;
const long long infl = 1e18 + 7;
long long fc[100500];
long long fc_inv[100500];
void get_fact(long long a, vector<long long> &ans) {
for (long long i = 2; i * i <= a; ++i) {
if (a % i) continue;
while (a % i == 0) {
a /= i;
ans.push_back(i);
}
}
if (a > 1) {
ans.push_back(a);
}
return;
}
long long pow(long long a, long long p, long long mod) {
long long ans = 1;
p %= mod - 1;
while (p) {
if (p & 1LL) {
ans *= a;
ans %= mod;
}
a *= a;
a %= mod;
p >>= 1;
}
return ans % mod;
}
long long get_inv(long long a, long long mod) { return pow(a, mod - 2, mod); }
const long long mod = 1e9 + 7;
long long mult(long long a, long long b) { return (a * b) % mod; }
long long get(long long n, long long cnt) {
return mult(mult(fc[n + cnt - 1], fc_inv[n - 1]), fc_inv[cnt]);
}
vector<long long> all;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
fc[0] = 1;
for (int i = 1; i < 100500; ++i) fc[i] = mult(fc[i - 1], i);
for (int i = 0; i < (100500); ++i) fc_inv[i] = get_inv(fc[i], mod);
int n;
cin >> n;
for (int i = 0; i < (n); ++i) {
int a;
cin >> a;
get_fact(a, all);
}
sort(all.begin(), all.end());
int cnt = 0;
long long ans = 1;
for (int i = 0; i < (int)all.size(); ++i) {
if (!i || all[i] == all[i - 1]) {
++cnt;
} else {
ans = mult(ans, get(n, cnt));
cnt = 1;
}
}
ans = mult(ans, get(n, cnt));
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, fac[333333];
map<int, int> ma;
map<int, int>::iterator it;
vector<int> x;
long long ans = 1ll, cur;
int BinPow(int w, int v) {
if (!v) return 1;
int cnt = BinPow(w, v / 2);
cnt = (cnt * 1ll * cnt) % 1000000007;
if (v & 1) cnt = (cnt * 1ll * w) % 1000000007;
return cnt;
}
int solve(int w) {
return (((fac[w - 1] * cur) % 1000000007) * 1ll *
BinPow(fac[w - n], 1000000007 - 2)) %
1000000007;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
for (int i = 2; i * i <= a; i++)
if (a % i == 0) {
int cur = 0;
while (a % i == 0) a /= i, cur++;
ma[i] += cur;
}
if (a > 1) ma[a]++;
}
fac[0] = 1;
for (int i = 1; i < 300000; i++) fac[i] = (fac[i - 1] * 1ll * i) % 1000000007;
cur = BinPow(fac[n - 1], 1000000007 - 2);
for (it = ma.begin(); it != ma.end(); it++) x.push_back(it->second);
for (size_t i = 0; i < x.size(); i++)
ans = (ans * 1ll * solve(x[i] + n)) % 1000000007;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long fact[100005], inv_fact[100005], x;
map<long long, long long> memo;
void decomp(long long n) {
long long i = 2;
while (i * i <= n) {
while (n % i == 0) {
if (memo.find(i) == memo.end()) {
memo[i] = 1;
} else {
++memo[i];
}
n /= i;
}
++i;
}
if (n != 1) {
if (memo.find(n) == memo.end()) {
memo[n] = 1;
} else {
++memo[n];
}
}
}
long long my_pow(long long a, long long b) {
long long ret = 1;
while (b > 0) {
if (b % 2 == 1) {
ret = (ret * a) % 1000000007;
}
a = (a * a) % 1000000007;
b /= 2;
}
return (ret);
}
long long inv(long long a) { return (my_pow(a, 1000000007 - 2)); }
long long sum(long long n) { return (n * (n - 1) / 2); }
long long comb(long long n, long long m) {
long long ret = (fact[n] * inv_fact[m]) % 1000000007;
ret = (ret * inv_fact[n - m] + 1000000007) % 1000000007;
return (ret);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
cin >> x;
decomp(x);
}
fact[0] = 1;
inv_fact[0] = inv(fact[0]);
for (int i = 1; i < 100005; ++i) {
fact[i] = (i * fact[i - 1]) % 1000000007;
inv_fact[i] = inv(fact[i]);
}
long long ans = 1;
for (auto c : memo) {
ans = (ans * comb(c.second + n - 1, n - 1)) % 1000000007;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int INF = 1 << 28;
const double EPS = 1e-8;
const int MOD = 1000000007;
long long int C[15010][510];
long long int comb(int n, int k) {
if (k < 0 || k > n) return 0;
if (n == 0) return 1;
if (C[n][k] > 0) return C[n][k];
C[n][k] = (comb(n - 1, k - 1) + comb(n - 1, k)) % MOD;
return C[n][k];
}
int main() {
scanf("%d", &n);
map<int, int> pl;
for (int i = 0; i < (int)(n); i++) {
int x;
cin >> x;
for (int i = 2; i * i <= x; i++) {
while (x % i == 0) {
pl[i]++;
x /= i;
}
}
if (x != 1) pl[x]++;
}
long long int sum = 1;
for (__typeof((pl).begin()) it = (pl).begin(); it != (pl).end(); ++it)
(sum *= comb(it->second + n - 1, n - 1)) %= MOD;
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e4;
long long n, x, mod = 1e9 + 7, fact[N], inv[N];
map<long long, long long> mp;
long long fast_power(long long num, long long base, long long mod) {
long long ans = 1;
while (base) {
if (base & 1) ans = (ans * num) % mod;
base >>= 1;
num = (num * num) % mod;
}
return ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
fact[0] = 1;
inv[0] = fast_power(fact[0], mod - 2, mod);
for (long long i = 1; i < N; i++)
fact[i] = (fact[i - 1] * i) % mod,
inv[i] = fast_power(fact[i], mod - 2, mod);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
for (int i = 2; i <= sqrt(x); i++) {
while (x % i == 0) {
x /= i;
mp[i]++;
}
}
if (x >= 2) mp[x]++;
}
long long ans = 1;
for (auto i : mp)
ans = (ans *
((((fact[i.second + n - 1] * inv[n - 1]) % mod) * inv[i.second]) %
mod)) %
mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
T pow_mod(T a, U b, int mod) {
T r = 1;
for (; b > 0; b >>= 1) {
if (b & 1) r = (long long)r * a % mod;
a = (long long)a * a % mod;
}
return r;
}
const int mod = 1e9 + 7, N = 31 * 500;
int fac[N], ifac[N];
void init() {
fac[0] = ifac[0] = 1;
for (int i = 1; i < N; ++i) {
fac[i] = (long long)fac[i - 1] * i % mod;
ifac[i] = pow_mod(fac[i], mod - 2, mod);
}
}
int comb(int n, int k) {
return (long long)fac[n] * ifac[n - k] % mod * ifac[k] % mod;
}
int starsandbars(int n, int k) { return comb(n + k - 1, k - 1); }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
map<int, int> mp;
for (int i = 0, x; i < n; ++i) {
cin >> x;
for (int j = 2; j * j <= x; ++j)
if (x % j == 0) {
int c = 0;
while (x % j == 0) x /= j, ++c;
mp[j] += c;
}
if (x > 1) ++mp[x];
}
init();
int ans = 1;
for (auto i : mp) ans = (long long)ans * starsandbars(i.second, n) % mod;
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Solution {
int C[20000];
map<int, int> mp;
void factor(int x) {
for (int p = 2; p * p <= x; ++p) {
if (x % p == 0) {
int t = 0;
while (x % p == 0) x /= p, ++t;
mp[p] += t;
}
}
if (x > 1) ++mp[x];
}
const int MOD = 1e9 + 7;
int powM(int x, int b) {
int ans = 1;
for (int cur = x; b; cur = 1ll * cur * cur % MOD, b >>= 1) {
if (b & 1) ans = 1ll * cur * ans % MOD;
}
return ans;
}
void init(int n) {
C[0] = 1;
for (int a = 1; a < 20000; ++a)
C[a] = 1ll * C[a - 1] * (a + n - 1) % MOD * powM(a, MOD - 2) % MOD;
}
public:
void run(istream &in, ostream &out) {
int n;
in >> n;
init(n);
int ans = 1;
for (int i = 0; i < n; ++i) {
int x;
in >> x;
factor(x);
}
for (auto x : mp) {
ans = 1ll * ans * C[x.second] % MOD;
}
out << ans << '\n';
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
Solution().run(cin, cout);
};
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const long long INF = (long long)5e18;
const int MOD = 1e9 + 7;
int _abs(int x) { return x < 0 ? -x : x; }
int add(int x, int y) {
x += y;
return x >= MOD ? x - MOD : x;
}
int sub(int x, int y) {
x -= y;
return x < 0 ? x + MOD : x;
}
void Add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
void Sub(int &x, int y) {
x -= y;
if (x < 0) x += MOD;
}
void Mul(int &x, int y) { x = (long long)(x) * (y) % MOD; }
int qpow(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = (long long)(ret) * (x) % MOD;
x = (long long)(x) * (x) % MOD;
y >>= 1;
}
return ret;
}
void checkmin(int &x, int y) {
if (x > y) x = y;
}
void checkmax(int &x, int y) {
if (x < y) x = y;
}
void checkmin(long long &x, long long y) {
if (x > y) x = y;
}
void checkmax(long long &x, long long y) {
if (x < y) x = y;
}
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
const int N = 200005;
map<int, int> mp;
int n, fac[N], ifac[N], ans = 1;
int C(int n, int m) {
return (long long)(fac[n]) * ((long long)(ifac[m]) * (ifac[n - m]) % MOD) %
MOD;
}
void calc(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
if (!mp.count(i)) mp[i] = 0;
while (x % i == 0) mp[i]++, x /= i;
}
}
if (x != 1)
if (!mp.count(x))
mp[x] = 1;
else
mp[x]++;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int x = read();
calc(x);
}
fac[0] = 1;
for (int i = 1; i < N; i++) fac[i] = (long long)(fac[i - 1]) * (i) % MOD;
ifac[N - 1] = qpow(fac[N - 1], MOD - 2);
for (int i = N - 2; i >= 0; i--)
ifac[i] = (long long)(ifac[i + 1]) * (i + 1) % MOD;
for (auto &u : mp) {
Mul(ans, C(u.second + n - 1, n - 1));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
long long dp[510][15010];
int a[10100];
int z[100100];
int np, pri[100100];
int tempa[10100];
void mergesort(int *a, int n1, int n2);
int main(void) {
int n, i, ii, j;
long long sum;
long long mod = 1000000007;
long long ans;
int m;
int aa;
int pp;
for (i = 3; i <= 100000; i += 2) {
z[i] = 1;
z[i + 1] = 0;
}
z[2] = 1;
z[1] = 0;
np = 1;
pri[1] = 2;
for (i = 3; i <= 400; i += 2) {
if (z[i]) {
pri[++np] = i;
for (j = i * i; j <= 100000; j += i) {
z[j] = 0;
}
}
}
for (i = i; i <= 100000; i += 2) {
if (z[i]) {
pri[++np] = i;
}
}
for (j = 0; j <= 15000; j++) {
dp[1][j] = 1;
}
for (i = 2, ii = 1; i <= 500; i++, ii++) {
sum = 0;
for (j = 0; j <= 15000; j++) {
sum = (sum + dp[ii][j]) % mod;
dp[i][j] = sum;
}
}
while (scanf("%d", &n) != EOF) {
m = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &aa);
for (j = 1; j <= np; j++) {
pp = pri[j];
if (pp * pp > aa) {
break;
}
while (aa % pp == 0) {
aa /= pp;
a[++m] = pp;
}
}
if (aa > 1) {
a[++m] = aa;
}
}
mergesort(a, 1, m);
ans = 1;
for (i = 1; i <= m; i = ii) {
aa = a[i];
for (ii = i + 1; ii <= m; ii++) {
if (a[ii] != aa) {
break;
}
}
ans = (ans * dp[n][ii - i]) % mod;
}
printf("%I64d\n", ans);
}
return 0;
}
void mergesort(int *a, int n1, int n2) {
int a1, a2, n12;
int i, j;
if (n1 < n2) {
n12 = (n1 + n2) / 2;
mergesort(a, n1, n12);
mergesort(a, n12 + 1, n2);
for (i = n1; i <= n2; i++) {
tempa[i] = a[i];
}
a1 = n1;
a2 = n12 + 1;
for (i = n1; (a1 <= n12 && a2 <= n2); i++) {
if (tempa[a1] <= tempa[a2]) {
a[i] = tempa[a1];
a1++;
} else {
a[i] = tempa[a2];
a2++;
}
}
if (a1 > n12) {
for (j = a2; j <= n2; j++, i++) {
a[i] = tempa[j];
}
} else {
for (j = a1; j <= n12; j++, i++) {
a[i] = tempa[j];
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e4, MAXP = 4e4;
const int MOD = 1e9 + 7;
bool prime[MAXP + 5];
int fact[MAXN + 5], invfact[MAXN + 5];
int cnt[MAXP + 5];
vector<pair<int, int>> myst;
vector<int> primes;
int n, a, ans = 1;
int add(int a, int b) {
int c = a + b;
if (c >= MOD) {
c -= MOD;
}
return c;
}
int mul(int a, int b) { return 1LL * a * b % MOD; }
int pwr(int a, int b) {
if (!b) {
return 1;
}
int res = pwr(a, b >> 1);
res = mul(res, res);
if (b & 1) {
res = mul(res, a);
}
return res;
}
int inv(int a) { return pwr(a, MOD - 2); }
int C(int a, int b) {
int res = fact[b];
res = mul(res, invfact[a]);
res = mul(res, invfact[b - a]);
return res;
}
void ex(int a) {
for (int i = 0; i < myst.size(); i++) {
if (myst[i].first == a) {
myst[i].second++;
return;
}
}
myst.push_back({a, 1});
}
void count_log_number(int a) {
for (int i = 0; i < primes.size(); i++) {
int count = 0;
while (a % primes[i] == 0) {
count++;
a /= primes[i];
}
cnt[primes[i]] += count;
}
if (a != 1) {
ex(a);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
memset(prime, 1, sizeof prime);
prime[1] = false;
for (int i = 2; i <= MAXP; i++) {
if (prime[i]) {
primes.push_back(i);
for (long long j = 1LL * i * i; j <= MAXP; j += i) {
prime[j] = false;
}
}
}
fact[0] = 1;
for (int i = 1; i <= MAXN; i++) {
fact[i] = mul(fact[i - 1], i);
}
for (int i = 0; i <= MAXN; i++) {
invfact[i] = inv(fact[i]);
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
count_log_number(a);
}
for (int i = 2; i <= MAXP; i++) {
int res = C(n - 1, cnt[i] + n - 1);
ans = mul(ans, res);
}
for (int i = 0; i < myst.size(); i++) {
int res = C(n - 1, myst[i].second + n - 1);
ans = mul(ans, res);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
bool primes[32000];
long long factorial[15001];
vector<long long> primesV;
long long pow(long long base, long long power) {
if (power == 0) return 1;
long long ans = pow(base, power / 2);
long long ans2 = (ans * ans) % MOD;
if (power % 2)
return (ans2 * base) % MOD;
else
return ans2;
}
long long nCk(long long n, long long k) {
return (factorial[n] *
pow((factorial[k] * factorial[n - k]) % MOD, MOD - 2)) %
MOD;
}
int main() {
int n;
cin >> n;
map<long long, int> higherPrimes;
for (long long i = 2; i < 32000; i++) {
if (primes[i]) continue;
primesV.push_back(i);
for (long long j = i * i; j < 32000; j += i) primes[j] = true;
}
factorial[0] = factorial[1] = 1;
for (int i = 2; i <= 15000; i++) {
factorial[i] = i * factorial[i - 1];
factorial[i] %= MOD;
}
for (long long j = 0; j < n; j++) {
long long x;
scanf("%I64d", &x);
for (long long i = 0; i < primesV.size() && primesV[i] * primesV[i] <= x;
i++) {
while (x % primesV[i] == 0) {
higherPrimes[primesV[i]]++;
x /= primesV[i];
}
}
if (x > 1) higherPrimes[x]++;
}
long long sum = 1;
map<long long, int>::iterator it = higherPrimes.begin();
while (it != higherPrimes.end()) {
sum *= nCk(n + it->second - 1, n - 1);
sum %= MOD;
it++;
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
bool ascending(int i, int j) { return (i < j); }
bool descending(int i, int j) { return (i > j); }
using namespace std;
long long mod = 1000 * 1000 * 1000 + 7;
const long long MAX = 50000;
long long fact[MAX];
void PreCalc() {
fact[0] = 1;
fact[1] = 1;
for (int(i) = (2); (i) < (MAX); (i)++) fact[i] = (fact[i - 1] * i) % mod;
}
long long countFact(long long n, long long p) {
long long k = 0;
while (n >= p) {
k += n / p;
n /= p;
}
return k;
}
long long powmod(long long a, long long b, long long m) {
long long x = a, p = 1;
while (b > 0) {
if (b % 2) p = ((p % m) * (x % m)) % m;
b /= 2;
x = ((x % m) * (x % m)) % m;
}
return p;
}
long long inverse(long long n, long long p) { return powmod(n, p - 2, p); }
long long C(long long n, long long k, long long p) {
if (countFact(n, p) > countFact(k, p) + countFact(n - k, p)) return 0;
return (fact[n] * ((inverse(fact[k], p) * inverse(fact[n - k], p)) % p)) % p;
}
long long f(long long n, long long m, long long i) {
if (n < 0 || m < 0) return 0;
if (i <= 0) return 0;
return C(n + m, n, mod);
}
long long MOD(long long a) {
while (a < 0) a += mod;
return a % mod;
}
map<int, int> pr;
int main() {
PreCalc();
int n;
cin >> n;
for (int(i) = 0; (i) < (n); (i)++) {
int l;
cin >> l;
for (int j = 2; j * j <= l; j++)
while (l % j == 0) {
pr[j]++;
l /= j;
}
if (l != 1) pr[l]++;
}
long long ret = 1;
for (map<int, int>::iterator it = pr.begin(); it != pr.end(); it++) {
ret = ((ret % mod) * C(n + it->second - 1, n - 1, mod)) % mod;
}
cout << ret << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long pow_(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % MOD;
b >>= 1;
a = a * a % MOD;
}
return ans;
}
long long ncr(long long n, long long r) {
if (r > n - r) return ncr(n, n - r);
long long num = 1, den = 1;
long long c = 0;
while (c < r) {
num = num * (c + 1) % MOD;
den = den * (n - c) % MOD;
c += 1;
}
swap(num, den);
num = num * pow_(den, MOD - 2) % MOD;
return num;
}
int main() {
int n, m;
cin >> n;
map<int, int> mp;
for (int k = 0; k < (n); ++k) {
int x;
cin >> x;
for (int i = 2; i * i <= x; ++i) {
int ct = 0;
while (x % i == 0) {
x /= i;
ct += 1;
}
if (ct > 0) mp[i] += ct;
}
if (x > 1) mp[x] += 1;
}
long long ans = 1;
for (auto it = mp.begin(); it != mp.end(); ++it) {
long long a = it->second;
ans = ans * ncr(n + a - 1, n - 1) % MOD;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const long long SIEVE_UPPERBOUND = 10000000;
const int FACT_UPPER = 20000;
long long sieveSize;
bitset<SIEVE_UPPERBOUND> bs;
vector<long long> primes;
long long fact[FACT_UPPER] = {1};
void sieve(long long upperbound) {
sieveSize = upperbound + 1;
bs.set();
bs[0] = 0, bs[1] = 0;
for (long long i = 2; i <= sieveSize; i++) {
if (bs[i]) {
for (long long j = i * i; j <= sieveSize; j += i) {
bs[j] = 0;
}
primes.push_back(i);
}
}
}
void primeFactors(long long N, map<long long, long long> &factors) {
for (int i = 2; i * i <= N; i++) {
while (N % i == 0) {
factors.count(i) ? factors[i]++ : factors[i] = 1;
N /= i;
}
}
if (N != 1) factors.count(N) ? factors[N]++ : factors[N] = 1;
}
void extendedEuclidMOD(long long a, long long b, long long &x, long long &y,
long long &gcd) {
if (b == 0) {
gcd = a;
y = 0;
x = 1;
return;
}
extendedEuclidMOD(b, a % b, x, y, gcd);
long long nx = y, ny = (x - ((a / b) * y)) % MOD;
x = nx;
y = ny;
}
long long modPow(long long num, long long pow, long long mod) {
num %= mod;
if (pow == 0) return 1;
long long currVal = modPow(num, pow / 2, mod);
currVal = (currVal * currVal) % mod;
if (pow % 2 != 0) currVal = (currVal * num) % mod;
return currVal;
}
long long primeModularInverse(long long a, long long b) {
return modPow(a, b - 2, b);
}
long long modInverse(long long a, long long m) {
long long x, y, gcd;
extendedEuclidMOD(a, m, x, y, gcd);
if (gcd == 1) {
if (x < 0) x += m;
return x % m;
} else
return -1;
}
long long getNumSplits(long long nOccur, int n) {
long long inv = primeModularInverse(fact[n - 1] * fact[nOccur] % MOD, MOD);
return (fact[nOccur + n - 1] * inv) % MOD;
}
int main() {
int n;
map<long long, long long> pFactors;
vector<long long> a;
for (int i = 1; i < FACT_UPPER; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long accum = 1;
for (int i = 0; i < n; i++) {
primeFactors(a[i], pFactors);
}
for (map<long long, long long>::iterator iter = pFactors.begin();
iter != pFactors.end(); ++iter) {
long long factor = iter->first, nOccur = iter->second;
accum = (accum * getNumSplits(nOccur, n)) % MOD;
}
cout << accum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int n, i, j;
map<int, int> cnt;
long long fact[15005], in[15005];
long long ncr(int l, int r) {
return (((fact[l] * in[l - r]) % MOD) * in[r]) % MOD;
}
long long mypow(int a, int lv) {
if (lv == 0) return 1LL;
long long tmp = mypow(a, lv / 2);
tmp = (tmp * tmp) % MOD;
if (lv & 1) tmp = (tmp * a) % MOD;
return tmp;
}
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
int x;
scanf("%d", &x);
int v = sqrt(x);
for (j = 2; j <= v; j++) {
while (x % j == 0) {
cnt[j]++;
x /= j;
}
}
if (x > 1) cnt[x]++;
}
fact[0] = 1LL;
for (i = 1; i <= 15000; i++) fact[i] = (fact[i - 1] * i) % MOD;
for (i = 0; i <= 15000; i++) in[i] = mypow(fact[i], MOD - 2);
long long res = 1LL;
for (auto k : cnt) {
long long num = ncr(n + k.second - 1, n - 1);
res = (res * num) % MOD;
}
printf("%lld\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> x;
map<int, int>::iterator it;
const int lmt = 32000;
int f[lmt + 50], sta[lmt + 50], top;
int n;
const long long mod = 1000000007;
long long jc[20005];
long long ksm(long long x, long long y) {
long long ans = 1;
for (; y; y /= 2, x = (x * x) % mod)
if (y & 1) ans = (ans * x) % mod;
return ans;
}
long long C(int n, int m) {
long long ans = jc[n];
ans = (ans * ksm(jc[m], mod - 2)) % mod;
ans = (ans * ksm(jc[n - m], mod - 2)) % mod;
return ans;
}
int main() {
for (int i = 2; i <= lmt; i++)
if (!f[i]) {
for (int j = 2; i * j <= lmt; j++) f[i * j] = 1;
sta[++top] = i;
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int v;
scanf("%d", &v);
for (int j = 1; j <= top; j++) {
while (v % sta[j] == 0) {
x[sta[j]]++;
v /= sta[j];
}
}
if (v != 1) x[v]++;
}
jc[0] = 1;
for (int i = 1; i <= 16000; i++) jc[i] = (jc[i - 1] * i) % mod;
long long ans = 1;
for (it = x.begin(); it != x.end(); it++) {
int a = it->first, m = it->second;
ans = (ans * C(m + n - 1, m)) % mod;
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const unsigned gen_seed =
std::chrono::system_clock::now().time_since_epoch().count();
std::mt19937_64 gen(gen_seed);
int main() {
vector<std::vector<long long> > cnk(20002, std::vector<long long>(501, 0));
for (int i = 0; i < 20002; i++) cnk[i][0] = 1;
for (int i = 1; i < 20002; i++) {
for (int j = 1; j < min(i + 1, 501); j++) {
cnk[i][j] = (cnk[i - 1][j] + cnk[i - 1][j - 1]) % mod;
}
}
const int LIMIT = 40000;
std::vector<bool> isp(LIMIT + 1, true);
std::vector<int> mindiv(LIMIT + 1, 0);
for (int i = 0; i < LIMIT + 1; i++) mindiv[i] = i;
int upbound = (int)sqrt((double)LIMIT);
std::vector<int> p;
for (int m = 2; m <= upbound; m++) {
if (isp[m]) {
p.push_back(m);
for (int k = m * m; k <= LIMIT; k += m) {
isp[k] = false;
mindiv[k] = min(mindiv[k], m);
}
}
}
for (int m = upbound + 1; m <= LIMIT; m++) {
if (isp[m]) {
p.push_back(m);
}
}
map<int, int> d;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
for (auto pr : p) {
while (x % pr == 0) {
d[pr]++;
x /= pr;
}
}
if (x > 1) d[x]++;
}
long long ans = 1;
for (auto x : d) {
int l = x.second;
ans = ans * cnk[l + n - 1][n - 1] % mod;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> p;
map<int, int> u;
bool is[10000010];
long long mod = 1e9 + 7;
void sieve() {
memset(is, 0, sizeof is);
for (int i = 2; i < 10000010; i++) {
if (!is[i]) {
p.push_back(i);
for (int j = 2 * i; j <= 10000010; j += i) is[j] = 1;
}
}
}
bool isprime(int n) {
if (n < 10000010) return !is[n];
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return 0;
}
return 1;
}
void factorize(int k) {
int ind = 0;
while (ind < p.size() && !isprime(k)) {
while (ind < p.size() && k % p[ind]) ind++;
if (ind >= p.size()) break;
k /= p[ind];
u[p[ind]]++;
}
u[k]++;
}
long long pw(long long b, long long p) {
if (!p) return 1;
if (p == 1) return b % mod;
if (p % 2) return (b * pw((b * b) % mod, (p - 1) / 2) % mod) % mod;
return pw((b * b) % mod, p / 2) % mod;
}
long long C(long long n, long long r) {
if (!r) return 1;
long long ret = 1;
for (long long i = 1; i <= r; i++) {
ret = (ret * n--) % mod;
ret = (ret * pw(i, mod - 2)) % mod;
}
return ret;
}
int main() {
sieve();
int n;
scanf("%d", &n);
;
u.clear();
for (int i = 0; i < n; i++) {
int tmp;
scanf("%d", &tmp);
;
factorize(tmp);
}
long long res = 1;
for (map<int, int>::iterator it = u.begin(); it != u.end(); it++) {
if (it->first == 1) continue;
res = (res * C(it->second + n - 1, n - 1)) % mod;
}
printf("%I64d\n", res);
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535897932384626;
const long long mod = 1000000007;
const long long D = 5e4;
long long fac[D], ifac[D];
long long mmul(long long a, long long b) { return (a % mod * b % mod) % mod; }
long long inv(long long x, long long M = mod) {
if (x == 0) return 0;
x %= M;
long long ans = 1, n = M - 2;
while (n > 0) {
if (n & 1) ans = (ans * x) % M;
n >>= 1, x = (x * x) % M;
}
return ans % M;
}
long long nCr(long long n, long long k) {
if (n < k) return 0;
long long ans = (ifac[k] * ifac[n - k]) % mod;
return (ans * fac[n]) % mod;
}
void init() {
fac[0] = 1;
for (long long i = 1; i < D; i++) fac[i] = (i * fac[i - 1]) % mod;
ifac[D - 1] = inv(fac[D - 1]);
for (long long i = D - 1; i >= 1; i--) ifac[i - 1] = (i * ifac[i]) % mod;
}
void solve() {
long long n;
cin >> n;
map<long long, long long> P;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
for (long long j = 2; j < D; j++) {
while (a % j == 0) {
P[j]++;
a /= j;
}
}
if (a > 1) P[a]++;
}
long long ans = 1;
for (auto p : P) {
long long k = p.second;
ans = mmul(ans, nCr(k + n - 1, k));
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 1;
init();
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long fac[30007], recFac[30007];
int n, a[30007], mark[100007];
map<int, long long> mp;
long long inv(long long num, long long x) {
long long ret = 1;
while (x) {
if (x & 1) {
ret *= num;
ret %= mod;
}
num *= num;
num %= mod;
x >>= 1;
}
return ret;
}
void init() {
fac[0] = 1;
for (long long i = 1; i < 30007; i++) {
fac[i] = fac[i - 1] * i;
fac[i] %= mod;
recFac[i] = inv(fac[i], mod - 2);
}
memset(mark, 0, sizeof(mark));
mark[1] = mark[0] = 1;
for (int i = 2; i * i < 30007; i++) {
if (mark[i]) continue;
for (int j = i * i; j < 30007; j += i) mark[j] = 1;
}
}
void handle(int num) {
for (int i = 2; i * i <= num; i++) {
if (num % i) continue;
if (mark[i]) continue;
while (num % i == 0) {
num /= i;
mp[i]++;
}
}
if (num > 1) mp[num]++;
}
long long C(int n, int m) {
if (m == 0) return 1;
return fac[n] * recFac[n - m] % mod * recFac[m] % mod;
}
int main() {
init();
while (~scanf("%d", &n)) {
mp.clear();
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
handle(a[i]);
}
long long ans = 1;
map<int, long long>::iterator it = mp.begin();
for (; it != mp.end(); it++) {
int x = it->second;
ans *= C(x + n - 1, n - 1);
ans %= mod;
}
printf("%I64d\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long bin(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1) {
res = res * a % 1000000007;
}
a = a * a % 1000000007;
b /= 2;
}
return res;
}
inline long long inver(long long a) { return bin(a, 1000000007 - 2); }
long long fact[20000], inv[20000];
long long c(long long n, long long k) {
if (inv[k] == 0) {
inv[k] = inver(fact[k]);
}
if (inv[n - k] == 0) {
inv[n - k] = inver(fact[n - k]);
}
return fact[n] * inv[k] % 1000000007 * inv[n - k] % 1000000007;
}
int n;
map<int, int> m;
long long ans = 1;
void init() {
cin >> n;
for (int a, i = 0; i < n; ++i) {
cin >> a;
for (int j = 2; j * j <= a; ++j) {
while (a % j == 0) {
++m[j], a /= j;
}
}
if (a != 1) {
++m[a];
}
}
fact[0] = 1;
for (long long i = 1; i < 20000; ++i) {
fact[i] = fact[i - 1] * i % 1000000007;
}
}
int main() {
init();
for (map<int, int>::iterator it = m.begin(); it != m.end(); ++it) {
ans = ans * c(it->second + n - 1, n - 1) % 1000000007;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 505, P = 1000000007;
map<int, int> s;
long long ans = 1, c[N * 32][N];
int n, x;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
for (int j = 2; j * j <= x; ++j)
while (x % j == 0) ++s[j], x /= j;
if (x > 1) ++s[x];
}
for (int i = 0; i < n * 31 + 1; ++i)
for (int j = 0; j < i + 1; ++j)
if (j <= n) c[i][j] = i && j ? (c[i - 1][j - 1] + c[i - 1][j]) % P : 1;
for (map<int, int>::iterator i = s.begin(); i != s.end(); ++i)
ans = ans * c[n + i->second - 1][n - 1] % P;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500 * 30 * 2, mod = 1e9 + 7;
int fac[N], inv[N];
void factorize(int n, map<int, int> &m) {
for (int i = 2; i * i <= n; i++) {
int cnt = 0;
while (n % i == 0) n /= i, cnt++;
if (cnt) m[i] += cnt;
}
if (n > 1) m[n]++;
}
int fp(int a, int p) {
if (!p) return 1;
int t = fp(a, p >> 1);
t = (t * 1ll * t) % mod;
if (p & 1) t = (t * 1ll * a) % mod;
return t;
}
int ncr(int n, int r) {
return ((fac[n] * 1ll * inv[r]) % mod * inv[n - r]) % mod;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
fac[0] = inv[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = (fac[i - 1] * 1ll * i) % mod;
inv[i] = fp(fac[i], mod - 2);
}
int n;
cin >> n;
map<int, int> mp;
for (int i = 0, a; i < n; i++) {
cin >> a;
factorize(a, mp);
}
int ans = 1;
for (auto it : mp) ans = (ans * 1ll * ncr(it.second + n - 1, n - 1)) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int add(int a, int b) {
long long x = a + b;
if (x >= 1000000007) x -= 1000000007;
if (x < 0) x += 1000000007;
return x;
}
long long mul(long long a, long long b) { return (a * b) % 1000000007; }
long long pw(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
long long fact[100002], inv[100002];
map<int, int> primes;
long long combi(long long n, long long k) {
long long ans = (fact[n] * inv[k]) % 1000000007;
ans = (ans * inv[n - k]) % 1000000007;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
fact[0] = inv[0] = 1;
for (int i = 1; i <= 100000; ++i) {
fact[i] = (fact[i - 1] * i) % 1000000007;
inv[i] = pw(fact[i], 1000000007 - 2);
}
for (int i = 1; i <= n; ++i) {
int nr;
cin >> nr;
for (int j = 2; j * j <= nr; ++j)
while (nr % j == 0) {
primes[j]++;
nr /= j;
}
if (nr > 1) primes[nr]++;
}
map<int, int>::iterator it;
long long ans = 1;
for (it = primes.begin(); it != primes.end(); ++it) {
long long countter = it->second;
ans = (ans * combi(countter + n - 1, countter)) % 1000000007;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 512, PNmax = 20 * 512, MOD = 1000000007;
int n, in[Nmax], ps[PNmax][2], pn = 0;
void insert(int p, int num) {
for (int i = 0; i < pn; ++i) {
if (ps[i][0] == p) ps[i][1] += num, p = 0;
}
if (p) {
ps[pn][0] = p, ps[pn][1] = num;
pn++;
}
}
const int PMmax = Nmax * 33;
long long f[Nmax][PMmax];
void calcuf() {
for (int i = 0; i < PMmax; ++i) f[1][i] = 1;
for (int i = 2; i <= n; ++i) {
f[i][0] = 1;
long long sum = 1;
for (int j = 1; j < PMmax; ++j) {
sum = (sum + f[i - 1][j]) % MOD;
f[i][j] = sum;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", in + i);
calcuf();
for (int i = 0; i < n; ++i) {
int x = in[i];
int up = (int)sqrt(x);
for (int j = 2; j <= up && j < x; ++j) {
if (x % j) continue;
int num = 0;
while (!(x % j)) {
x /= j;
num++;
}
insert(j, num);
}
if (x > 1) insert(x, 1);
}
long long re = 1;
for (int i = 0; i < pn; ++i) re = (re * f[n][ps[i][1]]) % MOD;
if (re < 0) re += MOD;
printf("%I64d\n", re);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 17000;
const int M = 505;
const int mod = 1e9 + 7;
int n, k;
long long c[N][M];
map<int, int> base;
void init() {
c[0][0] = 1;
for (int i = 1; i < N; i++) {
for (int j = 0; j <= i && j < M; j++) {
if (j == 0 || j == i)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
}
void getfactor(long long k) {
for (int j = 2; j <= sqrt(k); j++) {
if (k % j == 0) {
int cnt = 0;
while (k % j == 0) {
k /= j;
cnt++;
}
base[j] += cnt;
}
}
if (k > 1) base[k] += 1;
}
int main() {
init();
while (scanf("%d", &n) == 1) {
base.clear();
for (int i = 0; i < n; i++) {
scanf("%d", &k);
getfactor(k);
}
long long ans = 1;
map<int, int>::iterator i;
for (i = base.begin(); i != base.end(); i++) {
int t = (*i).second;
ans = (ans * c[t + n - 1][n - 1]) % mod;
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 17000;
const int M = 1000;
const int mod = 1e9 + 7;
int n, k;
long long c[N][M];
map<int, int> g;
void init() {
c[0][0] = 1;
for (int i = 1; i < N; i++) {
for (int j = 0; j <= i && j < M; j++) {
if (j == 0 || j == i)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
}
void solve(long long k) {
for (int j = 2; j * j <= k; j++)
if (k % j == 0) {
int cnt = 0;
while (k % j == 0) {
k /= j;
cnt++;
}
g[j] += cnt;
}
if (k > 1) g[k] += 1;
}
int main() {
init();
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &k);
solve(k);
}
long long ans = 1;
for (map<int, int>::iterator i = g.begin(); i != g.end(); i++) {
int t = (*i).second;
ans = (ans * c[t + n - 1][n - 1]) % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 1000000007;
int fast_exp(int n, int exp) {
auto result = 1;
while (exp != 0) {
if (exp % 2 == 1) result = 1LL * result * n % p;
exp /= 2;
n = 1LL * n * n % p;
}
return result;
}
int inverse(int n) { return fast_exp(n, p - 2); }
int binomial(int n, int k, int factorial) {
auto result = factorial;
for (auto i = 1; i <= k; i++) result = 1LL * result * (n - i + 1) % p;
return result;
}
int main() {
ios_base::sync_with_stdio(false);
short n;
cin >> n;
int max = 1, result = 1;
vector<int> a(n, 0);
for (auto i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > max) max = a[i];
}
map<int, int> count;
for (auto current : a) {
for (auto i = 2; current != 1 && i <= current / i; i++)
while (current % i == 0) {
count[i] = (count[i] + 1) % p;
current /= i;
}
if (current != 1) {
count[current] = (count[current] + 1) % p;
}
}
auto factorial = 1;
for (auto i = 2; i < n; i++) factorial = 1LL * factorial * i % p;
factorial = inverse(factorial);
for (auto i : count)
result = (1LL * result * binomial(n + i.second - 1, n - 1, factorial)) % p;
cout << result;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long read() {
long long s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * f;
}
map<long long, long long> mp;
long long f[555][20000];
const long long mod = 1e9 + 7;
signed main() {
n = read();
for (long long i = 1, iend = n; i <= iend; ++i) {
long long x = read();
for (long long j = 2; j * j <= x; ++j) {
while (x % j == 0) ++mp[j], x /= j;
}
if (x == 1) continue;
mp[x]++;
}
for (long long i = 0, iend = 17000; i <= iend; ++i) {
for (long long j = 0, jend = min(i, 520ll); j <= jend; ++j) {
if (j == 0 || i == 0)
f[j][i] = 1;
else
f[j][i] = (f[j - 1][i - 1] + f[j][i - 1]) % mod;
}
}
long long ans = 1;
for (auto i : mp) ans *= f[n - 1][i.second - 1 + n], ans %= mod;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N0 = 1e5 + 10;
long long const H = 1e9 + 7;
map<int, int>::iterator it;
map<int, int> cnt;
bool isP[N0];
int cntP, P[N0];
long long C[15000][510];
void init() {
memset(isP, true, sizeof isP);
for (int i = 2; i <= 1e5; i++) {
if (isP[i]) P[++cntP] = i;
for (int j = 1; j <= cntP; j++) {
if (i * P[j] > 1e5) break;
isP[i * P[j]] = false;
if (i % P[j] == 0) break;
}
}
for (int i = 0; i < 15e3; i++) C[i][0] = 1;
for (int i = 1; i < 15e3; i++)
for (int j = 1; j <= i && j <= 500; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % H;
}
int n;
int main() {
init();
scanf("%d", &n);
for (int owo = 1; owo <= n; owo++) {
int x;
scanf("%d", &x);
for (int i = 1; i <= cntP; i++)
while (x % P[i] == 0) cnt[P[i]]++, x /= P[i];
if (x != 1) cnt[x]++;
}
long long ans = 1;
for (it = cnt.begin(); it != cnt.end(); it++)
ans *= C[it->second + n - 1][n - 1], ans %= H;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
bool Mark[100005];
void seive() {
memset(Mark, 1, sizeof Mark);
for (long long i = 2; i < 100005; i++) {
if (Mark[i]) {
primes.push_back(i);
for (long long j = i * i; j < 100005; j += i) Mark[j] = false;
}
}
return;
}
long long dp[505][15005];
int n;
int solve(int index, int have) {
if (index == n - 1) return 1;
long long &ans = dp[index][have];
if (ans != -1) return ans;
ans = 0;
if (have > 0) {
ans = solve(index, have - 1);
}
ans = (ans + solve(index + 1, have)) % 1000000007;
return ans;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
seive();
map<int, int> freq;
long long ans = 1;
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
for (auto &x : primes) {
while (a % x == 0) {
freq[x]++;
a /= x;
}
}
if (a != 1) freq[a]++;
}
memset(dp, -1, sizeof dp);
for (auto &x : freq) {
ans = (ans * solve(0, x.second)) % 1000000007;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
const T& max(const T& a, const T& b, const T& c) {
return max(a, max(b, c));
}
template <class T>
const T& min(const T& a, const T& b, const T& c) {
return min(a, min(b, c));
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long poww(long long a, long long b) {
if (b == 0) return 1;
long long tmp = poww(a, b / 2);
return (b & 1 ? a * tmp * tmp : tmp * tmp);
}
long long sumOfDigs(string s) {
long long sum = 0;
for (int i = 0; i < s.length(); i++) sum += s[i] - '0';
return sum;
}
long long sumOfDigs(long long n) {
return (n < 10 ? n : n % 10 + sumOfDigs(n / 10));
}
string itos(long long i) {
string s = "";
while (i) {
s += char(i % 10 + '0');
i /= 10;
}
reverse(s.begin(), s.end());
return s;
}
long long stoi(string& s) {
long long tot = 0;
for (int i = (int)s.length() - 1, j = 1; i >= 0; i--, j *= 10) {
tot += j * (s[i] + '0');
}
return tot;
}
int months[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
using namespace std;
void t() { freopen("test.txt", "r", stdin); }
long long mod = 1000 * 1000 * 1000 + 7;
;
long long modpower(long long x, long long y, long long p) {
x %= mod;
if (!y) return 1;
long long res = 1;
if (y & 1) {
res *= x;
res %= p;
}
long long z = modpower(x, y / 2, p);
z %= p;
z *= z;
z %= mod;
res *= z;
res %= p;
return res;
}
int dp[15001][501];
int ncr(int n, int r) {
if (dp[n][r] != -1) return dp[n][r];
if (n < r) return 0;
if (r == 0) return 1;
int& res = dp[n][r];
res = ncr(n - 1, r - 1) % mod + ncr(n - 1, r) % mod;
res %= mod;
return res;
}
int main() {
memset(dp, -1, sizeof(dp[0][0]) * 15001 * 501);
int n;
cin >> n;
map<int, int> mpp;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
for (int j = 2; j * j <= x; j++) {
while (x % j == 0) {
x /= j;
mpp[j]++;
}
}
if (x > 1) mpp[x]++;
}
long long tot = 1;
for (auto itr = mpp.begin(); itr != mpp.end(); ++itr) {
long long k = itr->second;
tot *= ncr(n + k - 1, n - 1);
tot %= mod;
}
cout << tot % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
long long gcd(long long n, long long m) { return m ? gcd(m, n % m) : n; }
pair<int, int> ppi[1005];
vector<int> g[1005];
long long y, k, d, b, t, m, s, ans;
int n, x;
char str[1005];
int sum[1005];
long long a[1005], c[501 * 32 + 1][1005];
map<int, int> fac;
bool cmp(int a, int b) { return a > b; }
int find(int x) {
if (x != sum[x]) return sum[x] = find(sum[x]);
}
void search(int x, int y) {
int fx = find(x), fy = find(y);
if (fx != fy) sum[fy] = fx;
}
int main() {
for (int i = 0; i <= 501 * 32; i++)
for (int j = 0; j <= min(i, 505); j++)
c[i][j] = (i && j) ? (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007 : 1;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
for (int j = 2; j * j <= x; j++)
while (x % j == 0) fac[j]++, x /= j;
if (x > 1) fac[x]++;
}
ans = 1;
for (map<int, int>::iterator it = fac.begin(); it != fac.end(); it++)
ans = (ans * c[it->second + n - 1][n - 1]) % 1000000007;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int maxn = 3e5 + 4;
const int INF = 1e9;
bool IsPrime[maxn];
vector<int> Primes;
long long fact[maxn];
map<int, long long> cnt;
void pre() {
fact[0] = 1;
for (long long i = 1; i < maxn; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
}
}
long long pw(long long a, long long b) {
if (b == 0) return 1;
long long res = pw(a, b / 2);
res = res * res;
res %= MOD;
if (b % 2 == 0)
return res;
else {
res *= a;
res %= MOD;
return res;
}
}
long long C(long long a, long long b) {
long long c = fact[a] * fact[b - a];
c %= MOD;
long long res = fact[b] * pw(c, MOD - 2);
res %= MOD;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
pre();
for (long long i = 2; i < maxn; i++) {
if (!IsPrime[i]) {
Primes.push_back(i);
for (long long j = i * i; j < maxn; j += i) IsPrime[j] = true;
}
}
long long n;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 0; j < Primes.size() && Primes[j] * Primes[j] <= x; j++) {
while (x % Primes[j] == 0) {
cnt[Primes[j]]++;
x /= Primes[j];
}
}
if (x != 1) cnt[x]++;
}
long long ans = 1;
for (map<int, long long>::iterator i = cnt.begin(); i != cnt.end(); i++) {
ans *= C((*i).second, n + (*i).second - 1);
ans %= MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
int f[506][15551], s[506][15551];
bool notprime[100100];
vector<int> prime;
map<int, int> mp;
int a[506];
int n;
void eratosthene(void) {
for (int i = 0; i < (2); i = i + 1) notprime[i] = true;
for (int i = (2); i <= (100100 - 1); i = i + 1)
if (!notprime[i]) {
prime.push_back(i);
for (int j = 2 * i; j < 100100; j = j + i) notprime[j] = true;
}
}
void init(void) {
scanf("%d", &n);
for (int i = (1); i <= (n); i = i + 1) scanf("%d", &a[i]);
}
void anal(int x) {
for (__typeof((prime).begin()) it = (prime).begin(); it != (prime).end();
it++) {
if (1LL * (*it) * (*it) > x) break;
int tmp = 0;
while (x % *it == 0) {
tmp++;
x = x / (*it);
}
mp[*it] += tmp;
}
if (x > 1) mp[x]++;
}
void optimize(void) {
f[0][0] = 1;
for (int j = (0); j <= (15551 - 1); j = j + 1) s[0][j] = 1;
for (int i = (1); i <= (n); i = i + 1)
for (int j = (0); j <= (15551 - 1); j = j + 1) {
f[i][j] = s[i - 1][j];
if (j > 0)
s[i][j] = (s[i][j - 1] + f[i][j]) % mod;
else
s[i][j] = f[i][j];
}
}
void process(void) {
for (int i = (1); i <= (n); i = i + 1) anal(a[i]);
int res = 1;
for (__typeof((mp).begin()) it = (mp).begin(); it != (mp).end(); it++) {
int x = it->second;
res = 1LL * res * f[n][x] % mod;
}
printf("%d", res);
}
int main(void) {
eratosthene();
init();
optimize();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int arr[501];
long long int c[31 * 501][505];
map<long long int, long long int> mp;
void primefactcalc(long long int n) {
long long int no = 0;
while (n % 2 == 0) {
n = n / 2;
no++;
}
if (no > 0) mp[2] += no;
for (int i = 3; i * i <= n; i += 2) {
no = 0;
while (n % i == 0) {
n /= i;
no++;
}
if (no > 0) {
mp[i] += no;
}
}
if (n > 2) mp[n] += 1;
}
void init() {
for (int i = 0; i < 31 * 501; i++) {
for (int j = 0; j <= min(i, 500); j++) {
if (i == 0 || j == i)
c[i][j] = 1;
else {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
init();
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i];
primefactcalc(arr[i]);
}
long long int res = 1;
for (auto it : mp) {
long long int temp = it.second;
res = (res * (c[N + temp - 1][N - 1])) % 1000000007;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int N;
map<int, int> coun;
set<int> primes;
void first(int n) {
while (n % 2 == 0) {
primes.insert(2);
coun[2]++;
n /= 2;
}
for (int i = 3; i * i <= n; i += 2) {
while (n % i == 0) {
primes.insert(i);
coun[i]++;
n /= i;
}
}
if (n != 1) {
primes.insert(n);
coun[n]++;
}
}
long long dp[2][200007];
long long solu = 1ll;
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
int val;
scanf("%d", &val);
first(val);
}
dp[0][0] = 1ll;
for (int t = 1; t <= N; t++) {
for (int rem = 0; rem < 20000; rem++) {
int m = t % 2;
long long sol = dp[1 - m][rem];
if (rem > 0) {
sol += dp[m][rem - 1];
}
sol %= mod;
dp[m][rem] = sol;
}
}
for (int p : primes) {
solu *= dp[N % 2][coun[p]];
solu %= mod;
}
printf("%lld\n", solu);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fac[1000005], inv[1000005];
int p[32000];
int r[100000];
int v[5000];
int ptr;
int n, a[1000];
void prime() {
memset(r, 0, sizeof(r));
ptr = 0;
for (int i = 2; i < 32000; i++) {
if (r[i] == 0) p[ptr++] = i;
for (int j = 0; j < ptr; j++) {
if (i * p[j] < 32000) r[i * p[j]] = 1;
}
}
}
int mut(int a, int b) { return 1LL * a * b % 1000000007; }
int powmod(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = mut(a, ret);
a = mut(a, a);
b >>= 1;
}
return ret;
}
int zuhe(int df, int uf) { return mut(fac[df], mut(inv[uf], inv[df - uf])); }
int main() {
fac[0] = inv[0] = 1;
for (int i = 1; i < 1000005; i++) {
fac[i] = mut(i, fac[i - 1]);
inv[i] = powmod(fac[i], 1000000007 - 2);
}
prime();
scanf("%d", &n);
memset(v, 0, sizeof(v));
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
int ul = sqrt(a[i]);
int j;
for (j = 0; p[j] <= ul && j < ptr && a[i] != 1; j++) {
if (a[i] % p[j] == 0) {
a[i] /= p[j];
v[j]++;
j--;
}
}
if (a[i] > 1) {
for (; j < ptr; j++) {
if (a[i] == p[j]) {
v[j]++;
a[i] = 1;
break;
}
}
if (a[i] > 1) {
p[ptr] = a[i];
v[ptr] = 1;
ptr++;
}
}
}
int ans = 1;
for (int i = 0; i < ptr; i++) {
int df = v[i] + n - 1;
int uf = n - 1;
ans = mut(ans, zuhe(df, uf));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int const N = 1e6 + 5;
using namespace std;
long long n, x, fact[N], inv[N], ans = 1;
long long gcd(long long a, long long b) {
if (!a) return b;
return gcd(b % a, a);
}
long long fp(long long x, long long y) {
if (!y) return 1;
long long res = fp(x, y / 2) % 1000000007;
res = (res * res) % 1000000007;
if (y & 1) return (res * x) % 1000000007;
return res;
}
void solve() {
fact[0] = inv[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = (i * fact[i - 1]) % 1000000007;
inv[i] = fp(fact[i], 1000000007 - 2) % 1000000007;
}
}
long long ncr(long long n, long long r) {
return (((fact[n] * inv[r]) % 1000000007) * inv[n - r]) % 1000000007;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
cin >> n;
map<long long, long long> mp;
for (int i = 0; i < n; i++) {
cin >> x;
while (x % 2 == 0) x /= 2, mp[2]++;
for (int i = 3; i <= sqrt(x); i += 2)
while (x % i == 0) x /= i, mp[i]++;
if (x > 1) mp[x]++;
}
for (auto i : mp) ans = (ans * ncr(i.second + n - 1, n - 1)) % 1000000007;
cout << ans % 1000000007;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int arr[501];
long long int c[31 * 501][502];
map<long long int, long long int> mp;
void primefactcalc(long long int n) {
long long int no = 0;
while (n % 2 == 0) {
n = n / 2;
no++;
}
if (no > 0) mp[2] += no;
for (int i = 3; i * i <= n; i += 2) {
no = 0;
while (n % i == 0) {
n /= i;
no++;
}
if (no > 0) {
mp[i] += no;
}
}
if (n > 2) mp[n] += 1;
}
void init() {
for (int i = 0; i < 31 * 501; i++) {
for (int j = 0; j <= min(i, 500); j++) {
if (i == 0 || j == i)
c[i][j] = 1;
else {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
init();
int N;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i];
primefactcalc(arr[i]);
}
long long int res = 1;
for (auto it : mp) {
long long int temp = it.second;
res = (res * (c[N + temp - 1][N - 1])) % 1000000007;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int n, snt, C[505][15005];
map<int, int> F;
void tinh(int n) {
for (int i = 2; i <= n / i; ++i)
if (n % i == 0) {
while (n % i == 0) {
n /= i;
F[i]++;
}
}
if (n > 1) F[n]++;
}
void init() {
C[0][0] = 1;
for (int i = 1; i <= 30 * n; ++i) {
if (i == 1012) {
bool x = true;
}
C[0][i] = 1;
for (int j = 1; j <= min(i / 2, 500); ++j)
C[j][i] = (C[j - 1][i - 1] + C[j][i - 1]) % MOD;
for (int j = i / 2 + 1; j <= min(i, 500); ++j) C[j][i] = C[i - j][i];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
tinh(x);
}
init();
long long res = 1;
for (map<int, int>::iterator it = F.begin(); it != F.end(); ++it) {
int x = it->second;
res = res * C[n - 1][n + it->second - 1] % MOD;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool pri[400001];
map<int, int> num;
inline void getprime() {
for (register int i = 2; i <= 400000; i++) {
if (!pri[i]) {
for (register int j = i + i; j <= 400000; j += i) {
pri[j] = 1;
}
}
}
}
inline void getnum(int x) {
int i = 1, ans = 0;
for (register int i = 2; i <= sqrt(x); i++) {
if (!pri[i]) {
while (x % i == 0) {
x /= i;
num[i]++;
}
}
if (x == 1) break;
}
if (x != 1) num[x]++;
}
long long fac[40001], invfac[40001];
const long long Mod = 1e9 + 7;
inline long long Pow(long long a, long long b) {
if (b == 1) return a;
if (b == 2) return a * a % Mod;
if (b & 1)
return a * (Pow(a, b - 1) % Mod) % Mod;
else
return Pow(Pow(a, b / 2) % Mod, 2) % Mod;
}
inline void getfac() {
fac[0] = 1;
for (register int i = 1; i <= 40000; i++) {
fac[i] = fac[i - 1] * (long long)i % Mod;
}
invfac[40000] = Pow(fac[40000], Mod - 2);
for (register int i = 39999; i >= 0; i--) {
invfac[i] = invfac[i + 1] * (i + 1) % Mod;
}
}
inline long long C(int a, int b) {
if (b == 0) return 1;
return fac[a] * invfac[b] % Mod * invfac[a - b] % Mod;
}
int n, tmp;
long long ans = 1;
int main() {
getprime();
getfac();
scanf("%d", &n);
for (register int i = 1; i <= n; i++) {
scanf("%d", &tmp);
getnum(tmp);
}
map<int, int>::iterator it;
for (it = num.begin(); it != num.end(); it++) {
ans *= C(n + (it->second) - 1, n - 1);
ans %= Mod;
}
printf("%I64d", ans % Mod);
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long a, long long b, long long m) {
long long r = 1;
for (; b > 0; b >>= 1, a = a * a % m)
if (b & 1) r = r * a % m;
return r;
}
int main() {
int n;
cin >> n;
map<int, int> P;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
for (int f = 2; f * f <= a; f++) {
while (a % f == 0) {
a /= f;
P[f]++;
}
}
if (a > 1) P[a]++;
}
long long ans = 1;
long long M = 1000000007;
for (auto p : P) {
for (int i = 0; i < n - 1; i++) ans *= p.second + n - 1 - i, ans %= M;
for (int i = 1; i <= n - 1; i++) ans *= powmod(i, M - 2, M), ans %= M;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long P = 1000000007LL;
vector<int> divs;
vector<int> factorize(int x) {
vector<int> z;
for (int i = 2; i * i <= x; i++)
while (x % i == 0) {
z.push_back(i);
x /= i;
}
if (x != 1) z.push_back(x);
return z;
}
long long f[15555][555];
bool calced[15555][555];
long long getF(int n, int k) {
if (n == 0 && k >= 0) return 1LL;
if (n > 0 && k == 0) return 0LL;
if (n < 0 || k < 0) return 0LL;
if (calced[n][k]) return f[n][k];
calced[n][k] = 1;
f[n][k] = getF(n - 1, k) + getF(n, k - 1);
f[n][k] %= P;
return f[n][k];
}
long long answer = 1LL;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
vector<int> z = factorize(x);
for (size_t j = 0; j < z.size(); j++) divs.push_back(z[j]);
}
sort(divs.begin(), divs.end());
int k = 0;
for (size_t i = 0; i < divs.size(); i++) {
k++;
if ((int)i == (int)divs.size() - 1 || divs[i] != divs[i + 1]) {
answer = (answer * getF(k, n)) % P;
k = 0;
}
}
printf("%d\n", (int)answer);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int magic = 500 * 40;
vector<vector<long long>> c(magic, vector<long long>(500, 0));
void PreCalc() {
for (int i = 0; i < magic; ++i) {
c[i][0] = 1;
}
for (int i = 1; i < magic; ++i) {
for (int j = 1; j < 500; ++j) {
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
}
int main() {
PreCalc();
int n;
scanf("%d", &n);
map<int, int> deg_of;
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
for (int i = 2; i * i <= a; ++i) {
while (a % i == 0) {
++deg_of[i];
a /= i;
}
}
if (a != 1) {
++deg_of[a];
}
}
long long ans = 1;
for (auto& p : deg_of) {
long long cur_m = c.at(n + p.second - 1).at(n - 1);
ans *= cur_m;
ans %= mod;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> primes;
map<long long, long long> factor;
long long arr[510];
void extend_primes(void);
long long mod(long long a) { return (a % 1000000007); }
long long mod_mult(long long a, long long b) { return mod(mod(a) * mod(b)); }
long long mod_pow(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) {
ret = mod_mult(ret, a);
}
a = mod_mult(a, a);
b /= 2;
}
return ret;
}
long long combo(long long a, long long b) {
if (b == 0) return 1;
if (a == b) return 1;
long long top = 1, bot = 1;
for (long long i = 0; i < b; i++) {
top = mod_mult(top, a - i);
bot = mod_mult(bot, i + 1);
}
bot = mod_pow(bot, 1000000007 - 2);
return mod_mult(top, bot);
}
bool is_prime(long long a) {
while (primes.size() == 0 || primes.back() < sqrt(a)) extend_primes();
for (int i = 0; i < primes.size(); i++) {
if (a % primes[i] == 0) return false;
if (primes[i] > sqrt(a)) return true;
}
return true;
}
void extend_primes() {
if (primes.size() == 0) {
primes.push_back(2);
return;
}
if (primes.size() == 1) {
primes.push_back(3);
return;
}
long long last = primes.back() + 2;
while (!is_prime(last)) {
last += 2;
}
primes.push_back(last);
}
void fact(void) {
for (int i = 0; i < primes.size(); i++) {
long long tot = 0;
for (int j = 0; j < n; j++) {
while (arr[j] % primes[i] == 0) {
arr[j] /= primes[i];
tot++;
}
}
factor.insert(make_pair(primes[i], tot));
}
for (int i = 0; i < n; i++) {
if (arr[i] != 1) {
map<long long, long long>::iterator it = factor.find(arr[i]);
if (it != factor.end()) {
it->second++;
} else {
factor.insert(make_pair(arr[i], 1));
}
}
}
}
int main(void) {
while (primes.size() == 0 || primes.back() < 32000) {
extend_primes();
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
fact();
map<long long, long long>::iterator it = factor.begin();
long long ret = 1;
for (; it != factor.end(); it++) {
ret = mod_mult(ret, combo(it->second + n - 1, n - 1));
}
cout << ret << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline int size(const T& c) {
return c.size();
}
using namespace std;
int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; }
int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; }
const int maxn = 500 + 10;
const int cmod = 1000000007;
map<int, int> cnt;
int a[maxn];
int c[maxn * 40][maxn];
long long res;
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i <= maxn * 40 - 10; i++) {
c[i][0] = 1;
for (int j = 1; j <= min(i, maxn - 10); j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % cmod;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
for (int j = 2; j <= sqrt(a[i]); j++) {
while (a[i] % j == 0) {
a[i] /= j;
cnt[j]++;
}
}
if (a[i] > 1) cnt[a[i]]++;
}
res = 1;
for (__typeof((cnt).begin()) it = (cnt).begin(); it != (cnt).end(); it++) {
int u = (*it).first;
int v = (*it).second;
res = (res * c[v + n - 1][n - 1]) % cmod;
}
cout << res << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const MM = 15111, MA = 1e5, mod = 1e9 + 7, MN = 555;
int n, ans = 1, cnr[MM][MN];
map<int, int> cnt;
vector<int> pri;
bool aval[MA];
void add(int &a, long long b) {
b += a;
while (b > mod) b -= mod;
a = b;
}
void mult(int &a, long long b) {
b *= a;
b %= mod;
a = b;
}
void taj(int n) {
for (auto p : pri) {
while (n % p == 0) {
n /= p;
cnt[p]++;
}
}
if (n > 1) pri.push_back(n), cnt[n]++;
}
int32_t main() {
for (int i = 0; i < MM; i++) {
cnr[i][0] = 1;
for (int j = 1; j <= min(i, MN - 1); j++)
add(cnr[i][j], cnr[i - 1][j - 1] + cnr[i - 1][j]);
}
for (int i = 2; i < MA; i++) {
if (!aval[i]) {
pri.push_back(i);
for (int j = i; j < MA; j += i) aval[j] = 1;
}
}
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0, x; i < n; i++) {
cin >> x;
taj(x);
}
for (auto p : pri)
if (cnt[p]) mult(ans, cnr[n + cnt[p] - 1][n - 1]);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int nCr(int n, int r, int p) {
if (r > n - r) r = n - r;
int C[r + 1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = min(i, r); j > 0; j--) C[j] = (C[j] + C[j - 1]) % p;
}
return C[r];
}
void primeFactors(int n, unordered_map<int, int> &hash) {
while (n % 2 == 0) {
hash[2]++;
n = n / 2;
}
for (int i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
hash[i]++;
n = n / i;
}
}
if (n > 2) hash[n]++;
}
int main() {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
unordered_map<int, int> hash;
for (int i = 0; i < n; i++) {
if (A[i] != 1) primeFactors(A[i], hash);
}
long long int cnt = 1;
auto it = hash.begin();
while (it != hash.end()) {
int p = it->first;
int freq = it->second;
cnt = (cnt * (nCr(n + freq - 1, n - 1, 1000000007) % 1000000007)) %
1000000007;
it++;
}
cout << cnt % 1000000007;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 987654321;
const long long int INF = 123456789987654321;
const long long int mod = 1000000007;
const int MN = 500002;
vector<int> P, chk;
void get_P() {
chk = vector<int>(MN, 0);
for (int i = 2; i < MN; i++) {
if (chk[i]) continue;
P.push_back(i);
int mul = 1;
while (i * mul < MN) {
if (!chk[i * mul]) chk[i * mul] = i;
mul++;
}
}
}
int N;
vector<int> arr;
vector<int> X, prime;
map<int, int> dx;
void decompose() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < P.size(); j++) {
if (arr[i] % P[j] == 0) {
while (arr[i] % P[j] == 0) {
X.push_back(P[j]);
prime.push_back(P[j]);
arr[i] /= P[j];
}
}
}
if (arr[i] != 1) {
X.push_back(arr[i]);
prime.push_back(arr[i]);
}
}
}
void compress() {
sort(X.begin(), X.end());
X.resize(unique(X.begin(), X.end()) - X.begin());
for (int i = 0; i < X.size(); i++) dx[X[i]] = i;
}
vector<int> cnt;
void counting() {
cnt = vector<int>(X.size(), 0);
for (int i = 0; i < prime.size(); i++) {
cnt[dx[prime[i]]]++;
}
}
long long int pw(long long int x, long long int n) {
if (n == 0) return 1;
long long int t = pw(x, n / 2);
if (n % 2)
return (t * t % mod) * x % mod;
else
return t * t % mod;
}
long long int mod_inv(long long int x) { return pw(x, mod - 2); }
vector<long long int> fact, inv_fact;
void get_fact() {
fact.resize(MN);
inv_fact.resize(MN);
fact[0] = 1;
inv_fact[0] = 1;
for (int i = 1; i < MN; i++) {
fact[i] = fact[i - 1] * (long long int)i % mod;
inv_fact[i] = mod_inv(fact[i]);
}
}
long long int comb(int n, int r) {
return (fact[n] * inv_fact[r] % mod) * inv_fact[n - r] % mod;
}
long long int ans = 1;
void solve() {
for (int i = 0; i < X.size(); i++) {
ans *= comb(N + cnt[i] - 1, N - 1);
ans %= mod;
}
printf("%I64d", ans);
}
int main() {
get_P();
get_fact();
scanf("%d", &N);
arr.resize(N);
for (int i = 0; i < N; i++) {
scanf("%d", &arr[i]);
}
decompose();
compress();
counting();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 1000000007;
int binomial(int n, int k, const int& factorial) {
auto result = factorial;
for (auto i = 1; i <= k; i++) result = 1LL * result * (n - i + 1) % p;
return result;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int result = 1;
vector<int> a(n, 0);
for (auto i = 0; i < n; i++) {
cin >> a[i];
}
map<int, int> count;
for (auto current : a) {
for (auto i = 2; i <= current / i; i++)
while (current % i == 0) {
count[i] = count[i] + 1;
current /= i;
}
if (current != 1) {
count[current] = count[current] + 1;
}
}
int inverse[600];
int factorial = 1;
inverse[1] = 1;
for (auto i = 2; i < n; i++) {
inverse[i] = p - 1LL * p / i * inverse[p % i] % p;
factorial = 1LL * factorial * inverse[i] % p;
}
for (auto i : count)
result = (1LL * result * binomial(n + i.second - 1, n - 1, factorial)) % p;
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
void SieveOfEratosthenes(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p]) primes.push_back(p);
}
long long modInverse(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long NcR(long long n, long long r) {
long long p = 1, k = 1;
if (n - r < r) r = n - r;
if (r != 0) {
while (r) {
p *= n;
p %= 1000000007;
p *= modInverse(r, 1000000007);
p %= 1000000007;
n--;
r--;
}
} else
p = 1;
return p;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
SieveOfEratosthenes(40000);
map<int, int> fr;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
for (int j = 0; j < primes.size(); j++) {
while (a % primes[j] == 0) {
a /= primes[j];
fr[primes[j]]++;
}
}
if (a > 1) fr[a]++;
}
long long ans = 1;
for (map<int, int>::iterator i = fr.begin(); i != fr.end(); i++) {
ans *= NcR(n - 1 + i->second, i->second);
ans %= 1000000007;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans = 1, n, MOD = 1e9 + 7, c[509][509 * 32];
map<int, int> m;
int main() {
cin >> n;
for (int i = 0, x; i < n; i++) {
cin >> x;
for (int j = 2; j * j <= x; j++)
while (x % j == 0) m[j]++, x /= j;
if (x > 1) m[x]++;
}
for (int i = 0; i < 509 * 32; i++)
for (int j = 0; j <= min(i, 508); j++)
c[j][i] = (j == 0 || i == 0 ? 1 : c[j][i - 1] + c[j - 1][i - 1]) % MOD;
for (auto i : m) ans = ans * c[n - 1][i.second + n - 1] % MOD;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 1000000007;
int fast_exp(int n, int exp) {
auto result = 1;
while (exp != 0) {
if (exp % 2 == 1) result = 1LL * result * n % p;
exp /= 2;
n = 1LL * n * n % p;
}
return result;
}
int inverse(int n) { return fast_exp(n, p - 2); }
int binomial(int n, int k, int factorial) {
auto result = factorial;
for (auto i = 1; i <= k; i++) result = 1LL * result * (n - i + 1) % p;
return result;
}
int main() {
ios_base::sync_with_stdio(false);
short n;
cin >> n;
int max = 1, result = 1;
vector<int> a(n, 0);
for (auto i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > max) max = a[i];
}
bool prime[31623];
fill(prime + 2, prime + sizeof(prime) / sizeof(prime[0]), true);
for (auto i = 2; 1LL * i * i < sizeof(prime) / sizeof(prime[0]); i++)
if (prime[i])
for (auto j = 1LL * i * i; j < sizeof(prime) / sizeof(prime[0]); j += i)
prime[j] = false;
map<int, int> count;
for (auto current : a) {
for (auto i = 2; current != 1 && i < sizeof(prime) / sizeof(prime[0]); i++)
if (prime[i])
while (current % i == 0) {
count[i] = (count[i] + 1) % p;
current /= i;
}
if (current != 1) {
count[current] = (count[current] + 1) % p;
}
}
auto factorial = 1;
for (auto i = 2; i < n; i++) factorial = 1LL * factorial * i % p;
factorial = inverse(factorial);
for (auto i : count)
result = (1LL * result * binomial(n + i.second - 1, n - 1, factorial)) % p;
cout << result;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
const long long INF = 2000 * 1000 * 1000 * 1ll * 2000 * 1000 * 1000;
const double EPS = 1e-9;
const double pi = acos(-1.0);
const int maxn = 110;
template <typename T>
inline T sqr(T n) {
return (n * n);
}
struct item {
int x, k, mask;
void read() {
int size, xx;
scanf("%d%d%d", &x, &k, &size);
mask = 0;
for (int i = 0; i < size; i++) {
scanf("%d", &xx);
mask |= (1 << (xx - 1));
}
}
bool operator<(const item& it) const { return k < it.k; }
};
int n, m;
item a[maxn];
long long dp[1 << 20], res = INF, b;
int main() {
scanf("%d%d%I64d", &n, &m, &b);
for (int i = 0; i < n; i++) {
a[i].read();
}
sort(a, a + n);
for (int i = 1; i < (1 << m); i++) {
dp[i] = INF;
}
for (int i = 0; i < n; i++) {
for (int mask = 0; mask < (1 << m); mask++) {
dp[mask | a[i].mask] = min(dp[mask | a[i].mask], dp[mask] + a[i].x);
}
if (dp[(1 << m) - 1] != INF) res = min(res, dp[(1 << m) - 1] + a[i].k * b);
}
if (res == INF)
puts("-1");
else
printf("%I64d", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long ssum = 0, ff = 1;
char ch;
for (ch = getchar(); !isdigit(ch) && ch != '-'; ch = getchar())
;
if (ch == '-') ff = -1, ch = getchar();
for (; isdigit(ch); ch = getchar()) ssum = ssum * 10 + ch - '0';
return ssum * ff;
}
const long long M = 105, N = 22;
long long n, m, b, ans = 2e18, f[1 << N];
struct node {
long long s, k, w;
friend bool operator<(node x, node y) { return x.k < y.k; }
} a[M];
signed main() {
cin >> n >> m >> b;
for (long long i = 1; i <= n; i++) {
a[i].w = getint();
a[i].k = getint();
long long T = getint();
for (long long j = 1; j <= T; j++) a[i].s |= (1 << (getint() - 1));
}
sort(a + 1, a + n + 1);
memset(f, 0x7f, sizeof(f));
long long inf = f[0];
f[0] = 0;
for (long long i = 1; i <= n; i++) {
for (long long s = (1 << m) - 1; s >= 0; s--) {
if (f[s] == inf) continue;
f[s | a[i].s] = min(f[s | a[i].s], f[s] + a[i].w);
}
if (f[(1 << m) - 1] != inf) ans = min(ans, f[(1 << m) - 1] + b * a[i].k);
}
cout << (ans == 2e18 ? -1 : ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 2e18;
struct Friend {
ll mask, k, sum;
bool operator<(Friend z) const { return k < z.k; }
} a[105];
void solve() {
ll n, m, b;
cin >> n >> m >> b;
for (int i = 0; i < n; ++i) {
ll r, res = 0;
cin >> a[i].sum >> a[i].k >> r;
while (r--) {
ll q;
cin >> q;
q--;
res |= 1 << q;
}
a[i].mask = res;
}
sort(a, a + n);
vector<ll> dp(1 << m, INF);
dp[0] = 0ll;
ll ans = INF;
for (int i = 0; i < n; ++i) {
for (int mask = 0; mask < (1 << m); ++mask) {
if (dp[mask] < INF) {
ll j = mask | a[i].mask;
dp[j] = min(dp[j], dp[mask] + a[i].sum);
}
}
if (dp[(1 << m) - 1] < INF) {
ans = min(ans, dp[(1 << m) - 1] + b * a[i].k);
}
}
cout << (ans == INF ? -1 : ans);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, b;
struct friendo {
long long cost;
long long monitors;
long long solvable_mask;
friendo() {}
friendo(long long x, long long k, long long mask)
: cost(x), monitors(k), solvable_mask(mask) {}
bool operator<(const friendo& other) const {
return this->monitors < other.monitors;
}
};
friendo friend_list[100 + 1];
long long memo[2][(1 << 21) + 1];
int main() {
memset(memo, -1, sizeof memo);
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
long long x, k, solve_count;
cin >> x >> k >> solve_count;
long long mask = 0;
while (solve_count--) {
long long b;
cin >> b;
mask |= (1 << (b - 1));
}
friend_list[i] = friendo(x, k, mask);
}
sort(friend_list, friend_list + n);
long long best = -1;
memo[1][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++) memo[i % 2][j] = memo[(i + 1) % 2][j];
for (int j = 0; j < (1 << m); j++) {
if (memo[(i + 1) % 2][j] == -1) continue;
long long new_mask = j | friend_list[i].solvable_mask;
if (memo[i % 2][new_mask] == -1 ||
memo[(i + 1) % 2][j] + friend_list[i].cost < memo[i % 2][new_mask])
memo[i % 2][new_mask] = memo[(i + 1) % 2][j] + friend_list[i].cost;
}
if (memo[i % 2][(1 << m) - 1] == -1)
continue;
else if (best == -1 ||
memo[i % 2][(1 << m) - 1] + friend_list[i].monitors * b < best)
best = memo[i % 2][(1 << m) - 1] + friend_list[i].monitors * b;
}
cout << best << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 60;
int N, M;
long long B, dp[2][1 << 20];
struct Tperson {
long long b, k;
int m;
} p[101];
bool cmpk(Tperson a, Tperson b) { return a.k > b.k; }
inline void renew(long long &x, long long y) {
if (x > y) x = y;
}
int main() {
scanf("%d%d%I64d", &N, &M, &B);
for (int i = 1, m, a; i <= N; ++i) {
scanf("%I64d%I64d%d", &p[i].b, &p[i].k, &m);
while (m--) scanf("%d", &a), p[i].m += (1 << (a - 1));
}
sort(p + 1, p + N + 1, cmpk);
for (int j = 1; j < (1 << M); ++j) dp[0][j] = inf;
for (int i = 1; i <= N; ++i) {
for (int j = 1; j < (1 << M); ++j) dp[i & 1][j] = inf;
for (int j = 0; j < (1 << M); ++j) {
renew(dp[i & 1][j], dp[i & 1 ^ 1][j]);
renew(dp[i & 1][j | p[i].m],
dp[i & 1 ^ 1][j] + p[i].b + ((j == 0) ? p[i].k * B : 0));
}
}
long long ans = dp[N & 1][(1 << M) - 1];
printf("%I64d\n", ans == inf ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[(1 << 20)], maxi[(1 << 20)], b, k[200], c[200], dp2[(1 << 20)],
maxi2[(1 << 20)];
int a[200];
vector<pair<long long int, pair<long long int, long long int> > > v;
int main() {
int i, j, n, m, q;
cin >> n >> m >> b;
for (i = 0; i < n; i++) {
cin >> c[i] >> k[i] >> j;
int p = 0;
while (j--) {
cin >> q;
q--;
p = p | (1 << q);
}
a[i] = p;
v.push_back(make_pair(k[i], make_pair(c[i], a[i])));
}
sort(v.begin(), v.end());
memset(dp, -1, sizeof(dp));
memset(maxi, 0, sizeof(maxi));
dp[0] = 0;
maxi[0] = 0;
long long int ans = 1e18 + 1e15;
for (i = 0; i < n; i++) {
k[i] = v[i].first;
c[i] = v[i].second.first;
a[i] = v[i].second.second;
for (j = 0; j < (1 << m); j++)
if (dp[j] != -1) {
if (dp[j | a[i]] == -1 || dp[j | a[i]] > dp[j] + c[i]) {
dp[j | a[i]] = dp[j] + c[i];
}
}
if (dp[(1 << m) - 1] != -1) ans = min(ans, dp[(1 << m) - 1] + b * k[i]);
}
if (ans == 1e18 + 1e15)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, b, tmask;
const long long inf = 2LL * 1e18;
struct student {
long long x, k, mask;
};
student v[105];
long long dp[2][1 << 22];
bool cmp(student a, student b) { return a.k > b.k; }
int main() {
scanf("%I64d %I64d %I64d", &n, &m, &b);
for (int i = 0; i < int(n); i++) {
long long M, y;
scanf("%I64d %I64d %I64d", &v[i].x, &v[i].k, &M);
for (int j = 0; j < int(M); j++) {
scanf("%I64d", &y);
y--;
v[i].mask |= 1 << y;
}
tmask |= v[i].mask;
}
if (tmask != (1 << m) - 1)
printf("-1\n");
else {
sort(v, v + n, cmp);
for (int i = n; i >= 0; i--) {
for (int mask = int(0); mask <= int((1 << m) - 1); mask++) {
if (i == n) {
if (mask == (1 << m) - 1)
dp[i & 1][mask] = 0;
else
dp[i & 1][mask] = inf;
} else {
if (mask)
dp[i & 1][mask] = min(dp[(i + 1) & 1][mask],
dp[(i + 1) & 1][mask | v[i].mask] + v[i].x);
else
dp[i & 1][mask] =
min(dp[(i + 1) & 1][mask],
dp[(i + 1) & 1][mask | v[i].mask] + v[i].x + b * v[i].k);
}
}
}
printf("%I64d\n", dp[0][0]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int s;
long long x, k;
} a[400];
int n, m, ed, x;
long long ans, f[1850000], b;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
bool cmp(data a, data b) { return a.k < b.k; }
void go(int x) {
for (int i = 0; i <= ed; i++)
f[i | a[x].s] = min(f[i | a[x].s], f[i] + a[x].x);
ans = min(ans, f[ed] + b * a[x].k);
}
int main() {
n = read();
m = read();
b = read();
ed = (1 << m) - 1;
for (int i = 1; i <= n; i++) {
a[i].x = read();
a[i].k = read();
int t = read();
while (t--) x = read(), a[i].s += 1 << (x - 1);
}
sort(a + 1, a + 1 + n, cmp);
ans = 5000000000000000000ll;
for (int i = 1; i <= ed; i++) f[i] = 5000000000000000000ll;
f[0] = 0;
for (int i = 1; i <= n; i++) go(i);
if (ans >= 5000000000000000000ll)
puts("-1");
else
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)3e18;
const int MAX_N = 100 + 5;
int x[MAX_N], u[MAX_N];
pair<int, int> k[MAX_N];
long long dp[2][(1 << 20) + 5];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n, m, b;
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
int t;
cin >> x[i] >> k[i].first >> t;
k[i].second = i;
for (int j = 0; j < t; j++) {
int in;
cin >> in;
in--;
u[i] = u[i] | (1 << in);
}
u[i] = ~u[i];
}
sort(k, k + n);
long long ans = INF;
dp[0][0] = 0;
for (int j = 1; j < (1 << m); j++) dp[0][j] = INF;
for (int j = 0; j < n; j++) {
bool c = j % 2;
int p = k[j].second;
for (int mask = 1; mask < (1 << m); mask++)
dp[!c][mask] = min(dp[c][mask], dp[c][mask & u[p]] + x[p]);
ans = min(ans, dp[!c][(1 << m) - 1] + b * (long long)k[j].first);
}
if (ans == INF)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const long long INF = 2e18 + 7;
int n, m, b;
long long dp[1 << 20], ans = INF;
struct f {
int price, monitor, problems;
} a[N];
bool cmp(f A, f B) { return A.monitor < B.monitor; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m >> b;
for (int i = 1; i <= n; i++) {
int x;
cin >> a[i].price >> a[i].monitor >> x;
for (int j = 1; j <= x; j++) {
int y;
cin >> y;
a[i].problems |= (1 << (y - 1));
}
}
sort(a + 1, a + n + 1, cmp);
for (int j = 0; j < (1 << m); j++) {
dp[j] = INF;
}
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) {
int jp = j | a[i].problems;
dp[jp] = min(dp[jp], dp[j] + a[i].price);
if (jp == (1 << m) - 1) {
ans = min(ans, dp[jp] + 1ll * a[i].monitor * b);
}
}
}
if (ans == INF) {
cout << -1 << "\n";
} else {
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T x) {
return x * x;
}
struct sa {
int x, k, st;
friend bool operator<(sa a, sa b) { return a.k < b.k; }
};
sa a[300];
long long f[1 << 20];
int n, m, b, p;
long long ans;
int main() {
int i, j, t, st, x;
scanf("%d%d%d", &n, &m, &b);
for (i = 0; i < n; i++) {
scanf("%d%d%d", &a[i].x, &a[i].k, &t);
for (j = 0, st = 0; j < t; j++) {
scanf("%d", &x);
st |= 1 << (x - 1);
}
a[i].st = st;
}
sort(a, a + n);
p = 1 << m;
ans = 2000000000000000000LL;
for (j = 0; j < p; j++) f[j] = 2000000000000000000LL;
f[0] = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < p; j++) f[j | a[i].st] = min(f[j | a[i].st], f[j] + a[i].x);
ans = min(ans, f[p - 1] + (long long)a[i].k * b);
}
if (ans == 2000000000000000000LL) {
puts("-1");
return 0;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, b, x, tmp;
long long inf = 1222927042;
struct F {
int x, k, s;
} f[111];
int vis[111];
bool cmp(F a, F s) { return a.k < s.k; }
long long dp[1 << 20];
long long work() {
long long ans = inf;
for (int i = 0; i < (1 << m); i++) dp[i] = inf;
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++)
dp[j | f[i].s] = min(dp[j | f[i].s], dp[j] + f[i].x);
ans = min(ans, dp[(1 << m) - 1] + (long long)(f[i].k) * b);
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &b);
inf *= inf;
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &f[i].x, &f[i].k, &x);
while (x--) {
scanf("%d", &tmp);
vis[tmp] = 1;
f[i].s |= (1 << (tmp - 1));
}
}
sort(f, f + n, cmp);
for (int i = 1; i <= m; i++)
if (!vis[i]) {
cout << -1 << endl;
return 0;
}
long long ans = work();
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1 << 20;
long long n, m, b;
vector<pair<int, pair<int, int>>> v;
int prob[101];
unsigned long long dp[MAX], dp2[MAX];
int main() {
scanf("%lld%lld%lld", &n, &m, &b);
for (int i = 0; i < n; i++) {
int aa, bb, cc;
scanf("%d%d%d", &aa, &bb, &cc);
v.push_back({bb, {aa, i}});
for (int j = 0; j < cc; j++) {
int gg;
scanf("%d", &gg);
gg--;
prob[i] = prob[i] | (1 << gg);
}
}
sort(v.begin(), v.end());
for (int i = 0; i < (1 << m); i++) dp[i] = dp2[i] = 1e19;
dp[0] = dp2[0] = 0ll;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) {
dp2[j] = min(dp2[j], dp[j]);
int mask = j | prob[v[i - 1].second.second];
long long cst = 0;
if (__builtin_popcount(mask) == m) cst = v[i - 1].first * b;
dp2[mask] = min(dp2[mask], dp[j] + v[i - 1].second.first + cst);
}
for (int j = 0; j < (1 << m); j++) {
dp[j] = dp2[j];
}
}
if (dp[(1 << m) - 1] >= 1e19)
puts("-1");
else
printf("%lld\n", dp[(1 << m) - 1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const int MAXN = 1e6 + 10;
const long long MOD = 1e9 + 7;
const long long MOD2 = 998244353;
const long long INF = 8e18;
const int LOG = 22;
long long pw(long long a, long long b, long long mod) {
return (!b ? 1
: (b & 1 ? (a * pw(a * a % mod, b / 2, mod)) % mod
: pw(a * a % mod, b / 2, mod)));
}
long long dp[2][(1 << 20)], Dp[(1 << 20)];
int X[MAXN], K[MAXN], B[MAXN];
bool comp(int a, int b) { return K[a] < K[b]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m, b;
cin >> n >> m >> b;
vector<int> N;
for (int i = 0; i < n; i++) N.push_back(i);
for (int i = 0; i < n; i++) {
int T, cu = 0;
cin >> X[i] >> K[i] >> T;
for (int i = 0; i < T; i++) {
int a;
cin >> a;
a--;
cu |= (1 << a);
}
B[i] = cu;
}
sort((N).begin(), (N).end(), comp);
for (int mask = 0; mask < (1 << 20); mask++) {
Dp[mask] = dp[1][mask] = dp[0][mask] = 5e18;
}
int z = dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int mask = 0; mask < (1 << m); mask++) {
dp[1 - z][mask] = dp[z][mask];
}
int cu = N[i];
for (int mask = 0; mask < (1 << m); mask++) {
int new_mask = (mask | B[cu]);
dp[1 - z][new_mask] = min(dp[1 - z][new_mask], dp[z][mask] + X[cu]);
}
for (int mask = 0; mask < (1 << m); mask++) {
Dp[mask] = min(Dp[mask], dp[1 - z][mask] + (1ll) * K[cu] * b);
}
z = 1 - z;
}
if (Dp[(1 << m) - 1] >= 5e18) {
return cout << -1, 0;
}
cout << Dp[(1 << m) - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[110], k[110];
pair<int, int> p[110];
int s[110];
long long dp[1 << 20];
inline void update(long long &a, long long b) {
if (a == -1) a = b;
if (a > b) a = b;
}
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
for (int i = 0; i < n; i++) {
int t, ss;
scanf("%d%d%d", &x[i], &k[i], &t);
for (int j = 0; j < t; j++) {
scanf("%d", &ss);
--ss;
s[i] |= 1 << ss;
}
p[i] = make_pair(k[i], i);
}
sort(p, p + n);
for (int i = 0; i < 1 << m; i++) {
dp[i] = -1;
}
dp[0] = 0;
long long ans = -1;
for (int j = 0; j < n; j++) {
int t = p[j].second;
for (int i = 0; i < 1 << m; i++) {
if (dp[i] != -1) {
update(dp[i | s[t]], dp[i] + x[t]);
}
}
if (dp[(1 << m) - 1] != -1) {
update(ans, dp[(1 << m) - 1] + (long long)k[t] * b);
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct fr {
long long x, k;
int m;
};
bool cmp(fr a, fr b) {
if (a.k < b.k)
return true;
else
return false;
}
fr arr[1000];
int n, m;
long long b;
long long dp[5000000];
long long dp2[5000000];
int main() {
cin >> n >> m >> b;
for (int i = 0; i < n; ++i) {
int mm;
cin >> arr[i].x >> arr[i].k >> mm;
arr[i].m = 0;
for (int j = 0; j < mm; ++j) {
int a;
cin >> a;
arr[i].m |= 1 << (a - 1);
}
}
sort(arr, arr + n, cmp);
for (int i = 0; i < 1 << m; ++i) dp[i] = -1;
for (int i = 0; i < 1 << m; ++i) dp2[i] = -1;
dp[0] = 0;
dp2[0] = 0;
for (int i = 0; i < n; ++i) {
long long dop = b * arr[i].k;
for (int j = 1; j < 1 << m; ++j) {
long long xx = arr[i].x + dp2[j ^ (j & arr[i].m)];
if (xx == arr[i].x - 1) continue;
if (dp[j] > dop + xx || dp[j] == -1) dp[j] = dop + xx;
if (dp2[j] > xx || dp2[j] == -1) dp2[j] = xx;
}
}
cout << dp[(1 << m) - 1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v, f;
Edge *next, *rest;
};
int n, m, b, x[100], k[100], p[100];
long long dp[1048576];
long long ans = 0x3FFFFFFFFFFFFFFFLL;
int main() {
scanf("%d%d%d", &n, &m, &b);
for (int i = 0, len; i < n; i++) {
scanf("%d%d%d", &x[i], &k[i], &len);
for (int j = 0, t; j < len; j++) scanf("%d", &t), p[i] |= 1 << (t - 1);
p[i] ^= (1 << m) - 1;
}
for (int i = 0; i < n; i++) {
for (int j = n - 1; j > i; j--) {
if (k[j - 1] > k[j])
swap(k[j - 1], k[j]), swap(x[j - 1], x[j]), swap(p[j - 1], p[j]);
}
}
for (int i = 1; i < 1 << m; i++) dp[i] = 0x3FFFFFFFFFFFFFFFLL;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 1 << m; j++) dp[j] = min(dp[j], dp[j & p[i]] + x[i]);
if (dp[(1 << m) - 1] < 0x3FFFFFFFFFFFFFFFLL)
ans = min(ans, dp[(1 << m) - 1] + (long long)k[i] * b);
}
printf("%I64d", ans == 0x3FFFFFFFFFFFFFFFLL ? -1 : ans);
getchar();
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long poww(long long a, long long b, long long md) {
if (b == -1) return poww(a, md - 2, md);
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
const long long N = 105;
const long long LOG = 22;
const long long INF = 8e18;
const long long MOD = 1e9 + 7;
tuple<long long, long long, long long> frs[N];
long long dp[2][1 << 20];
int sol[N];
int n, m, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> b;
for (int i = 1; i <= n; i++) {
long long &ki = get<0>(frs[i]), &xi = get<1>(frs[i]), &id = get<2>(frs[i]);
id = i;
cin >> xi >> ki;
int mi;
cin >> mi;
for (int j = 0; j < mi; j++) {
int prob;
cin >> prob;
sol[i] |= (1 << (--prob));
}
}
sort(frs + 1, frs + n + 1);
for (int i = 0; i <= n; i++) {
for (int mask = 0; mask < (1 << m); mask++) {
if (i == 0) {
if (mask + 1 == (1 << m))
dp[i][mask] = 0;
else
dp[i][mask] = INF;
continue;
}
int idx = i % 2, lst = (i + 1) % 2;
long long monitor = (mask == 0 ? get<0>(frs[i]) : 0) * b;
dp[idx][mask] =
min(dp[lst][mask],
monitor + get<1>(frs[i]) + dp[lst][mask | sol[get<2>(frs[i])]]);
}
}
long long ans = dp[n % 2][0];
cout << (ans >= INF ? -1 : ans) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
int cost, monitor, num;
int state;
} p[100010];
int n, m, B;
long long dp[2][1 << 20];
bool cmp(const Point &A, const Point &B) { return A.monitor < B.monitor; }
int main() {
while (scanf("%d%d%d", &n, &m, &B) != EOF) {
memset(dp, -1, sizeof(dp));
int all = 0, top = 1 << m;
for (int i = 1; i <= n; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
p[i].cost = a;
p[i].monitor = b;
p[i].num = c;
int temp = 0;
for (int j = 1; j <= c; j++) {
int t = 0;
scanf("%d", &t);
t--;
temp |= (1 << t);
}
p[i].state = temp;
all |= temp;
}
if (all != top - 1) {
puts("-1");
} else {
sort(p + 1, p + 1 + n, cmp);
long long ans = -1;
int S, T;
dp[0][0] = 0;
S = 0;
long long NewMoni = 0;
p[0].monitor = 0;
int nx;
for (int i = 1; i <= n; i++) {
NewMoni = 0;
if (p[i].monitor > p[i - 1].monitor) {
NewMoni = (long long)B * (p[i].monitor - p[i - 1].monitor);
}
T = 1 - S;
memset(dp[T], -1, sizeof(dp[T]));
for (int ss = 0; ss <= 1; ss++)
for (int j = 0; j < top; j++) {
if (dp[S][j] == -1) {
continue;
}
nx = (j | (p[i].state * ss));
if (dp[T][nx] == -1 ||
dp[T][nx] > dp[S][j] + NewMoni + p[i].cost * ss) {
dp[T][nx] = dp[S][j] + NewMoni + p[i].cost * ss;
if (nx == top - 1) {
if (ans == -1 || ans > dp[T][nx]) {
ans = dp[T][nx];
}
}
}
}
S = T;
}
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int INFINITO = 9223372036854775807;
long long int X[200], K[200], M[200];
int MASK[200];
long long int n, m, b;
const int MAXN = (1 << 20) + 1000;
long long int DP[2][MAXN];
vector<pair<int, int> > F;
void print(int mask) {
while (mask != 0) {
cout << mask % 2;
mask /= 2;
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> b;
for (int i = 0; i < (int)(n); i++) {
cin >> X[i] >> K[i] >> M[i];
for (int j = 0; j < (int)(M[i]); j++) {
int bit;
cin >> bit;
bit--;
MASK[i] |= (1 << bit);
}
}
for (int i = 0; i < (int)(n); i++) F.push_back(pair<int, int>(K[i], i));
sort((F).rbegin(), (F).rend());
int ini_mask = (1 << m) - 1;
long long int *prev = DP[0], *now = DP[1];
for (int mask = 0; mask < (int)(1 << m); mask++) prev[mask] = INFINITO;
prev[0] = 0;
for (int i = (int)(n)-1; i >= ((int)0); i--) {
int f = F[i].second;
for (int mask = 0; mask < (int)(1 << m); mask++) {
long long int A = prev[mask];
long long int B = prev[(mask & ~MASK[f])];
if (B < INFINITO) {
B = B + X[f];
if (mask == ini_mask) B = B + K[f] * b;
}
now[mask] = min(A, B);
}
swap(now, prev);
}
long long int res = prev[ini_mask];
cout << (res == INFINITO ? -1 : res) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, dp[1 << 21], b, ans = 3e18;
pair<long long, pair<long long, long long> > a[1 << 21];
int main() {
cin >> n >> m >> b;
for (long long i = 0, m, x; i < n; i++) {
cin >> a[i].second.first >> a[i].first >> m;
while (m--) cin >> x, x--, a[i].second.second += 1 << x;
}
for (long long i = 0; i < (1 << m); i++) dp[i] = ans;
dp[0] = 0, sort(a, a + n);
for (long long i = 0; i < n; i++) {
for (int j = 0; j < (1 << m); j++)
dp[j] = min(dp[j], dp[j & (j ^ a[i].second.second)] + a[i].second.first);
ans = min(ans, dp[(1 << m) - 1] + a[i].first * b);
}
cout << (ans < (long long)3e18 ? ans : -1);
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
long long x, k;
int sta, m;
bool operator<(const node &b) const { return k < b.k; }
} a[110];
long long dp[(1 << 20) + 10];
int main() {
long long fuck, b, ans = -1;
int n, m, temp, i, j, y;
scanf("%d%d%I64dd", &n, &m, &b);
for (i = 1; i <= n; i++) {
scanf("%I64d%I64d%d", &a[i].x, &a[i].k, &a[i].m);
temp = 0;
for (j = 1; j <= a[i].m; j++) {
scanf("%d", &y);
temp = temp | (1 << (y - 1));
}
a[i].sta = temp;
}
sort(a + 1, a + 1 + n);
memset(dp, -1, sizeof(dp));
dp[0] = 0;
int tot = (1 << m);
for (i = 1; i <= n; i++) {
for (j = tot - 1; j >= 0; j--) {
if (dp[j] < 0) continue;
if (dp[j | a[i].sta] == -1)
dp[j | a[i].sta] = dp[j] + a[i].x;
else if (dp[j | a[i].sta] > dp[j] + a[i].x)
dp[j | a[i].sta] = dp[j] + a[i].x;
}
if (dp[tot - 1] < 0) continue;
fuck = dp[tot - 1] + a[i].k * b;
if (ans == -1 || fuck < ans) ans = fuck;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100100;
const unsigned long long oo = 1ll << 60;
struct nd {
unsigned long long a, b, e;
bool operator<(const nd &o) const {
if (b != o.b) return b < o.b;
return false;
}
} A[MAX];
unsigned long long N, M, B, c, x;
unsigned long long dp[1 << 22], sol;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> M >> B;
for (int I = 0; I < N; I++) {
cin >> A[I].a >> A[I].b >> c;
for (int K = 0; K < c; K++) {
cin >> x;
A[I].e |= 1 << (x - 1);
}
}
sort(A, A + N);
for (int I = 0; I < 1 << M; I++) dp[I] = oo;
dp[0] = 0;
sol = oo;
for (int I = 0; I < N; I++) {
for (int msk = 0; msk < 1 << M; msk++)
if (dp[msk] < oo)
dp[msk | A[I].e] = min(dp[msk | A[I].e], dp[msk] + A[I].a);
if (dp[(1 << M) - 1] < oo) sol = min(sol, dp[(1 << M) - 1] + A[I].b * B);
}
if (sol == oo)
cout << -1 << endl;
else
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005, INF = 1000010000;
const long long int LINF = 4000000000000000000ll;
const double eps = 1e-10;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
struct dat {
int x, k, m;
dat() {}
dat(int x, int k, int m) : x(x), k(k), m(m) {}
bool operator<(const dat& a) const { return k < a.k; }
};
long long int dp[1 << 20];
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
long long int ans = LINF;
vector<dat> d;
for (int i = 0; i < n; i++) {
int x, k, ms, msk = 0;
scanf("%d%d%d", &x, &k, &ms);
for (int j = 0; j < ms; j++) {
int a;
scanf("%d", &a);
msk |= 1 << a - 1;
}
d.push_back(dat(x, k, msk));
}
int m2 = 1 << m;
for (int i = 0; i < m2; i++) dp[i] = LINF;
dp[0] = 0;
sort(d.begin(), d.end());
for (int i = 0; i < n; i++) {
for (int j = 0; j < m2; j++) {
dp[j | d[i].m] = min(dp[j | d[i].m], dp[j] + d[i].x);
}
ans = min(ans, dp[m2 - 1] + (long long int)d[i].k * b);
}
if (ans == LINF) ans = -1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct xx {
int m, p, v;
} a[110];
bool cmp(xx a, xx b) { return a.v < b.v; }
long long f[1100000];
int main() {
int n, m, b;
cin >> n >> m >> b;
memset(f, -1, sizeof(f));
f[0] = 0;
int mx = 1 << m;
for (int i = 1; i <= n; i++) {
int p;
scanf("%d%d%d", &a[i].m, &a[i].v, &p);
while (p--) {
int x;
scanf("%d", &x);
a[i].p |= 1 << (x - 1);
}
}
sort(a + 1, a + n + 1, cmp);
long long ans = -1, ans2;
for (int i = 1; i <= n; i++) {
ans2 = 1ll * a[i].v * b;
for (int j = mx - 1; j >= 0; j--)
if (f[j] >= 0) {
int k = j | a[i].p;
if (f[k] == -1 || f[k] > f[j] + a[i].m) f[k] = f[j] + a[i].m;
}
if (f[mx - 1] != -1) {
if (ans == -1)
ans = f[mx - 1] + ans2;
else
ans = min(ans, f[mx - 1] + ans2);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void do_nothing() {}
void solve() {
int n, m;
long long b;
cin >> n >> m >> b;
int allprobs = (1 << m) - 1;
vector<tuple<long long, int, int>> friends(n);
for (int(i) = 0; (i) < (n); (i)++) {
int x;
long long k;
cin >> x >> k;
int nm;
cin >> nm;
int mm = 0;
for (int(j) = 0; (j) < (nm); (j)++) {
int pro;
cin >> pro;
mm |= 1 << (pro - 1);
}
friends[i] = make_tuple(k, x, mm);
}
sort((friends).begin(), (friends).end());
const long long DPMAX = numeric_limits<long long>::max();
vector<long long> dp(1 << m, DPMAX);
dp[0] = 0;
long long ans = DPMAX;
for (int ifr = 0; ifr < (int)(friends).size(); ifr++) {
long long k;
int x, mm;
tie(k, x, mm) = friends[ifr];
for (int(i) = 0; (i) < (1 << m); (i)++) {
int pre = i & ~mm;
if (dp[pre] != DPMAX) dp[i] = min(dp[i], dp[pre] + x);
}
if (dp[allprobs] != DPMAX) ans = min(ans, k * b + dp[allprobs]);
}
if (ans != DPMAX)
cout << ans;
else
cout << -1;
cout << "\n";
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int x, k, mi, w;
bool operator<(const Node &rhs) const { return k < rhs.k; }
} a[105];
int n, m, b;
long long dp[1 << 21];
void upd(long long &x, long long r) {
if (x < 0 || x > r) x = r;
}
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
cin >> n >> m >> b;
for (int i = 0; i < n; i++) {
cin >> a[i].x >> a[i].k >> a[i].mi;
a[i].w = 0;
for (int j = 0; j < a[i].mi; j++) {
int t;
cin >> t;
t--;
a[i].w |= 1 << t;
}
}
sort(a, a + n);
memset(dp, -1, sizeof(dp));
dp[0] = 0;
int all = (1 << m) - 1;
long long ans = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 1 << m; j++)
if (dp[j] >= 0) {
upd(dp[j | a[i].w], dp[j] + a[i].x);
if ((j | a[i].w) == all) upd(ans, dp[all] + 1LL * a[i].k * b);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using DO = double;
using LL = long long;
using VI = vector<int>;
const int N = 1 << 20;
const LL INF = 0x3f3f3f3f3f3f3f3fll;
inline void smin(LL& a, const LL& b) {
if (a > b) a = b;
}
LL dp[N];
int bt[111];
int val[111];
int k[111];
int id[111];
int main() {
int n, m, b;
scanf("%d %d %d", &n, &m, &b);
int N = 1 << m;
for (int i = 1, f; i <= n; i++) {
scanf("%d %d %d", val + i, k + i, &f);
for (int j = 0, r; j < f; j++) {
scanf("%d", &r);
r--;
bt[i] |= (1 << r);
}
id[i] = i;
}
sort(id + 1, id + n + 1, [&](int i, int j) { return k[i] < k[j]; });
for (int i = 1; i < N; i++) {
dp[i] = INF;
}
LL crr = 0, ans = INF;
for (int i = 1; i <= n; i++) {
crr += (LL)(k[id[i]] - k[id[i - 1]]) * b;
int bit = bt[id[i]];
int v = val[id[i]];
for (int k = N - 1; k >= 0; k--) {
smin(dp[k | bit], dp[k] + v);
}
if (dp[N - 1] != INF) {
smin(ans, dp[N - 1] + crr);
}
}
if (ans == INF) {
ans = -1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long int inf = 7e18;
const long long int maxN = 101;
long long int n, b, m;
struct node {
long long int x, k, m, pmask;
node() {}
node(long long int x, long long int k, long long int m,
vector<long long int>& a) {
this->x = x;
this->k = k;
this->m = m;
this->pmask = 0;
for (auto& i : a) pmask = pmask | (1ll << i);
}
};
node a[maxN];
bool cmp(const node& a, const node& b) { return a.k < b.k; }
signed main() {
cin >> n >> m >> b;
for (long long int i = 0; i < n; i++) {
long long int x, k, mi;
cin >> x >> k >> mi;
vector<long long int> b(mi);
for (long long int j = 0; j < mi; j++) {
cin >> b[j];
b[j]--;
}
a[i] = node(x, k, mi, b);
}
sort(a, a + n, cmp);
vector<long long int> dp1(1ll << m, inf), dp2(1ll << m, inf);
long long int ans = inf;
dp1[0] = 0;
dp1[a[0].pmask] = a[0].x;
ans = min(ans, a[0].k * b + dp1[(1ll << m) - 1]);
for (long long int i = 1; i < n; i++) {
dp2.assign((1ll << m), inf);
for (long long int mask = 0; mask < (1ll << m); mask++) {
dp2[mask] = min(dp2[mask], dp1[mask]);
dp2[mask | a[i].pmask] = min(dp2[mask | a[i].pmask], dp1[mask] + a[i].x);
}
swap(dp1, dp2);
ans = min(ans, a[i].k * b + dp1[(1ll << m) - 1]);
}
if (ans >= 6e18)
cout << -1 << "\n";
else
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int nFriend, nTask;
long long costMonitor;
struct fd {
long long cost;
int needMonitor;
int ableMask;
bool operator<(fd that) const { return needMonitor < that.needMonitor; }
} F[101];
long long INF = 2000000000000000000LL;
long long DP[2][1 << 20];
inline long long dp(int cur, int mask) {
if (cur > nFriend) return INF;
long long &ret = DP[cur % 2][mask];
if (ret != -1) return ret;
ret = INF;
if ((mask | (F[cur].ableMask)) == (1 << nTask) - 1)
ret = min(ret, F[cur].cost + F[cur].needMonitor * costMonitor);
else
ret = min(ret, DP[(cur + 1) % 2][mask | F[cur].ableMask]) + F[cur].cost;
ret = min(ret, DP[(cur + 1) % 2][mask]);
return ret;
}
int MAIN() {
cin >> nFriend >> nTask >> costMonitor;
for (int i = 1; i <= nFriend; i++) {
cin >> F[i].cost >> F[i].needMonitor;
int s;
cin >> s;
F[i].ableMask = 0;
for (int j = 1; j <= s; j++) {
int t;
cin >> t;
t--;
F[i].ableMask |= (1 << t);
}
}
sort(F + 1, F + 1 + nFriend);
memset(DP, 0xff, sizeof(DP));
for (int j = 0; j < (1 << nTask); j++) DP[(nFriend + 1) % 2][j] = INF;
for (int i = nFriend; i >= 1; i--) {
for (int j = 0; j < (1 << nTask); j++) DP[i % 2][j] = -1;
for (int j = 0; j < (1 << nTask); j++) dp(i, j);
}
long long ans = dp(1, 0);
if (ans >= INF) ans = -1;
cout << ans << endl;
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
return MAIN();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.