solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
from math import factorial
n,ans,s = int(input()),1,0
for i in range(n) :
a = int(input())
ans=(ans*factorial(s+a-1)//factorial(s)//factorial(a-1))%1000000007
s+=a
print(ans) | 9 | PYTHON3 |
import math
MOD = 1000000007
MAXN = 1005
comb = [([0] * MAXN) for i in range(0, MAXN)]
comb[0][0] = 1
for i in range(1, MAXN):
comb[i][0] = 1
for j in range(1, i + 1):
comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1]
comb[i][j] %= MOD
k = int(input())
sum = 0
ans = 1
for i in range(0, k):
num = int(input())
sum += num
ans = ans * comb[sum - 1][num - 1] % MOD
print (ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int c[1001];
unsigned long long comb[3000][3000];
void init() {
int i, j;
for (i = 0; i < 3000; i++) comb[i][0] = 1;
for (i = 1; i < 3000; i++) {
for (j = 1; j <= i; j++) {
comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1];
comb[i][j] %= 1000000007;
}
}
}
int main() {
memset(comb, 0, sizeof(comb));
init();
int n;
cin >> n;
unsigned long long dp[n + 1], s[n + 1];
memset(c, 0, sizeof(c));
s[0] = 0;
for (int i = 1; i <= n; ++i) {
cin >> c[i];
s[i] = s[i - 1] + c[i];
}
dp[1] = 1;
for (int i = 2; i <= n; ++i) {
dp[i] = dp[i - 1] * comb[s[i] - 1][c[i] - 1];
dp[i] %= 1000000007;
}
cout << dp[n] << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long cc[1010][1010];
void Init() {
for (int n = 0; n <= 1000; n++) {
for (int m = 0; m <= n; m++) {
if (m == 0 || n == m)
cc[n][m] = 1;
else
cc[n][m] = cc[n - 1][m] % 1000000007 + cc[n - 1][m - 1] % 1000000007;
}
}
}
int a[10000];
int main() {
Init();
int n;
scanf("%d", &n);
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
int last = n;
long long way = 1;
while (last >= 1) {
way = way * cc[sum - 1][a[last] - 1] % 1000000007;
sum -= a[last];
last--;
}
printf("%I64d\n", way % 1000000007);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int M = 1e3 + 10;
const int mod = 1e9 + 7;
long long a[M], sum[M], f[M];
int k;
long long mul(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res % mod;
}
void init() {
f[0] = 1;
int i;
for (i = 1; i < M; i++) f[i] = (f[i - 1] * i) % mod;
}
long long C(int m, int n) {
long long res =
((f[m] * mul(f[n], mod - 2)) % mod * mul(f[m - n], mod - 2)) % mod;
return res;
}
int main() {
init();
while (~scanf("%d", &k)) {
memset(sum, 0, sizeof(sum));
for (int i = 1; i <= k; i++) {
scanf("%lld", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
long long ans = 1;
for (int i = k; i > 0; i--) {
ans = ans * C(sum[i] - 1, a[i] - 1) % mod;
sum[i] -= a[i];
}
printf("%lld\n", ans);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9L + 7;
long long power(long long x, long long y) {
long long res = 1LL;
x = x % MOD;
while (y > 0) {
if (y & 1) res = (res * x) % MOD;
y = y >> 1;
x = (x * x) % MOD;
}
return res;
}
long long modInverse(long long n) { return power(n, MOD - 2); }
long long nCr(long long n, long long r) {
if (r == 0) return 1;
long long fac[n + 1];
fac[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % MOD;
return (fac[n] * modInverse(fac[r]) % MOD * modInverse(fac[n - r]) % MOD) %
MOD;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int k;
cin >> k;
vector<int> c(k), p_sum(k);
for (int i = 0; i < k; ++i) {
cin >> c[i];
p_sum[i] = c[i];
p_sum[i] += (i > 0 ? p_sum[i - 1] : 0);
}
vector<long long> dp(k + 1);
dp[0] = 1;
for (int i = 1; i < k; ++i) {
if (c[i] == 1) {
dp[i] = dp[i - 1];
} else {
dp[i] = (dp[i - 1] % MOD * nCr(c[i] + p_sum[i - 1] - 1, c[i] - 1) % MOD) %
MOD;
}
}
cout << dp[k - 1] % MOD;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s[1010][1010] = {0};
int t;
int a = 1;
int q;
long long ans = 1;
for (int i = 0; i < 1010; i++) s[i][0] = 1;
for (int i = 1; i < 1010; i++)
for (int j = 1; j < 1010; j++)
s[i][j] = (s[i][j - 1] + s[i - 1][j]) % 1000000007;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> q;
ans = (ans * s[a][q - 1]) % 1000000007;
a += q;
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long fac[1005], MOD = 1000000007, ara[1005], sum[1005];
long long BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return R;
}
void gen() {
long long i;
fac[0] = 1;
for (i = 1; i <= 1000; i++) fac[i] = (fac[i - 1] * i) % MOD;
}
long long dp[1005];
long long solve(long long n) {
long long up = sum[n] - 1;
long long down = ara[n] - 1;
long long an = up - down;
up = fac[up];
down = fac[down];
an = fac[an];
long long res = BigMod(down, MOD - 2, MOD);
up = (up * res) % MOD;
res = BigMod(an, MOD - 2, MOD);
up = (up * res) % MOD;
return up;
}
long long rec(long long n) {
dp[1] = 1;
long long i;
for (i = 2; i <= n; i++) {
dp[i] = (dp[i - 1] * solve(i)) % MOD;
}
return dp[n];
}
int main() {
gen();
long long n;
scanf("%I64d", &n);
long long i, c;
for (i = 1; i <= n; i++) {
scanf("%I64d", &ara[i]);
sum[i] = sum[i - 1] + ara[i];
}
printf("%I64d\n", rec(n));
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
long long dp[maxn][maxn];
long long a[maxn];
long long sum, ans, n;
int main() {
dp[0][0] = 1;
dp[1][1] = 1;
dp[1][0] = 1;
for (int i = 2; i < 1005; i++) {
dp[i][0] = 1;
dp[i][i] = 1;
for (int j = 1; j < i; j++) {
dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % 1000000007;
}
}
while (~scanf("%lld", &n)) {
sum = 0, ans = 1;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
sum += a[i];
ans *= dp[sum - 1][a[i] - 1];
ans %= 1000000007;
}
printf("%lld\n", ans);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
long long ans(int len, int c);
long long comb[1000][1000] = {0};
int main(void) {
int k, c[1000], i;
long long dp[1000] = {1};
for (i = 0; i <= 1000; i++) {
comb[i][0] = comb[i][i] = 1;
}
scanf("%i", &k);
for (i = 0; i < k; i++) scanf("%i", &c[i]);
int len = c[0] - 1;
for (i = 1; i < k; i++) {
len += c[i];
dp[i] = (dp[i - 1] * ans(len, c[i] - 1)) % 1000000007;
}
printf("%I64d\n", dp[k - 1]);
return 0;
}
long long ans(int len, int c) {
if (!comb[len][c])
comb[len][c] = (ans(len - 1, c) + ans(len - 1, c - 1)) % 1000000007;
return comb[len][c];
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long c[1003][1003];
const int MD = 1000000000 + 7;
int main() {
c[0][0] = 1;
for (int i = 1; i <= 1000; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
if (c[i][j] >= MD) {
c[i][j] -= MD;
}
}
}
long long ans = 1;
int n;
cin >> n;
int sum = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
sum += x - 1;
ans = (ans * c[sum][x - 1]) % MD;
sum++;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
MOD = 10 ** 9 + 7
def fact(n):
factor = 1
if n == 0:
return 1
for i in range(1, n + 1):
factor = (factor * i)
return factor
mass = []
n = int(input())
for i in range(n):
mass.append(int(input()))
res = 1
summ = 0
for i in range(n):
summ += mass[i]
res = (res * fact(summ - 1) // (fact(mass[i] - 1)
* fact(summ - mass[i]))) % MOD
print(res)
| 9 | PYTHON3 |
from math import factorial
n = int(input())
ans,s = 1,0
for i in range(n) :
a = int(input())
ans=(ans*factorial(s+a-1)//factorial(s)//factorial(a-1))%1000000007
s+=a
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
using namespace std;
long long C[1001][1001];
long long a[1001];
void c() {
int i, j;
for (i = 0; i <= 1000; i++) C[i][0] = 1;
for (i = 1; i <= 1000; i++) {
for (j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
}
}
}
int main() {
int n;
cin >> n;
int i, j;
long long tot = 0;
c();
for (i = 0; i < n; i++) {
cin >> a[i];
tot += a[i];
}
long long ans = C[tot - 1][a[n - 1] - 1];
tot--;
tot -= (a[n - 1] - 1);
for (j = n - 2; j >= 0; j--) {
ans = (ans * C[tot - 1][a[j] - 1]) % 1000000007;
tot -= (a[j]);
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 1000005;
int fact[maxn], inv[maxn];
void init(int n = 1e6) {
fact[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = (long long)i * fact[i - 1] % 1000000007;
inv[1] = 1;
for (int i = 2; i <= n; i++)
inv[i] = 1000000007 -
(long long)(1000000007 / i) * inv[1000000007 % i] % 1000000007;
inv[0] = 1;
for (int i = 1; i <= n; i++)
inv[i] = (long long)inv[i - 1] * inv[i] % 1000000007;
}
int C(int n, int m) {
return (long long)fact[n] * inv[m] % 1000000007 * inv[n - m] % 1000000007;
}
int n, k, a[maxn];
int main() {
init();
while (~scanf("%d", &k)) {
n = 0;
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
n += a[i];
}
int ans = 1;
for (int i = k; i >= 1; i--)
ans = (long long)ans * C(n - 1, a[i] - 1) % 1000000007, n -= a[i];
printf("%d\n", ans);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long C[1100][1100];
int n, k;
int sum[1100];
int main() {
for (int i = 0; i < 1100; i++) C[i][0] = C[i][i] = 1;
for (int i = 1; i < 1100; i++)
for (int j = 1; j < i; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> sum[i];
}
long long ans = 1;
long long tot = 0;
for (int i = 0; i < 1100; i++)
if (sum[i]) {
ans *= C[tot + sum[i] - 1][sum[i] - 1];
ans %= 1000000007;
tot += sum[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int triangle[5000 + 1][5000 + 1];
void makeTriangle() {
int i, j;
triangle[0][0] = 1;
for (i = 1; i < 5000; i++) {
triangle[i][0] = 1;
for (j = 1; j <= i; j++) {
triangle[i][j] =
(triangle[i - 1][j - 1] + triangle[i - 1][j]) % 1000000007;
}
}
}
long long int C(long long int n, long long int r) { return triangle[n][r]; }
int main() {
int k;
makeTriangle();
scanf("%d", &k);
int a[1005], f[1005], i;
f[0] = 0;
for (i = 1; i <= k; i++) {
scanf("%d", &a[i]);
f[i] = f[i - 1] + a[i];
}
int long long ans = 1;
for (i = 2; i <= k; i++) {
ans = (ans * C(f[i] - 1, a[i] - 1)) % 1000000007;
}
cout << ans;
return 0;
}
| 9 | CPP |
import sys
import math
from math import *
from operator import add
from itertools import permutations
import itertools
# try:
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')
# except noerror:
# print("no input_file")
inf = 1e10
mod = int(1e9 + 7)
def NcR(n, r):
"""
p holds the value of n*(n-1)*(n-2)...,
k holds the value of r*(r-1)...
C(n, r) == C(n, n-r),
choosing the smaller value """
p = 1
k = 1
if (n - r < r):r = n - r
if (r != 0):
while (r):
p *= n
k *= r
m = gcd(p, k)
"""
gcd of p, k
dividing by gcd, to simplify product
division by their gcd saves from the overflow"""
p //= m
k //= m
n -= 1
r -= 1
return p
t=1;# t=int(input())
for _ in range(t):
k=int(input())
total=int(input())
res=1
for i in range(1,k):
c=int(input())
res = (res*NcR(total + c-1, c-1))%mod
total+=c
print(res) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
const long long MAXN = 3000;
long long calc[MAXN][MAXN];
long long C(long long k, long long n) {
if (calc[k][n] != -1) {
return calc[k][n];
}
if (k == 0) {
calc[k][n] = 1;
return 1;
}
if (k == n) {
calc[k][n] = 1;
return 1;
}
calc[k][n] = (C(k - 1, n - 1) + C(k, n - 1)) % MOD;
return calc[k][n];
}
int main() {
for (long long i = 0; i < MAXN; ++i) {
for (long long j = 0; j < MAXN; ++j) {
calc[i][j] = -1;
}
}
long long k;
cin >> k;
long long ans = 1;
long long csum = 0;
for (long long i = 0; i < k; ++i) {
long long num;
cin >> num;
ans = ans * C(num - 1, num - 1 + csum);
ans %= MOD;
csum += num;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long sum, ans, n, i, j, k, l, a[1005], d[1005][1005], m = 1000000007;
int main() {
cin >> k;
for (i = 1; i <= k; i++) cin >> a[i], n = n + a[i];
for (i = 0; i <= n; i++) {
for (j = 0; j <= i; j++) {
if (i == j || j == 0)
d[i][j] = 1;
else
d[i][j] = (d[i - 1][j - 1] + d[i - 1][j]) % m;
}
}
for (i = 1, ans = 1; i <= k; i++) {
ans = (ans * d[sum + a[i] - 1][sum]) % m;
sum += a[i];
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
long long f[10000];
long long pri[10000];
long long power(long long n, long long p) {
if (p == 0) return 1;
long long ans = 1;
ans *= power(n, p / 2);
ans = ans % MOD;
ans *= ans;
ans = ans % MOD;
if (p & 1) ans *= n;
ans = ans % MOD;
return ans % MOD;
}
void fact() {
f[0] = 1;
for (int i = 1; i < 1998; i++) {
f[i] = i * f[i - 1];
f[i] = f[i] % MOD;
}
}
long long inv(long long a) {
a = a % MOD;
return power(a, MOD - 2) % MOD;
}
long long ncr(long long n, long long r) {
return (f[n] * inv(f[r] * f[n - r])) % MOD;
}
int main() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
if (i == 0)
pri[i] = a;
else
pri[i] = a + pri[i - 1];
}
fact();
long long ans = 1;
for (int i = 0; i < n; i++) {
ans *= ncr(pri[i] - 1, v[i] - 1);
ans = ans % MOD;
}
cout << ans << endl;
}
| 9 | CPP |
def C(n, k):
return (math.factorial(n) // (math.factorial(k) * math.factorial(n - k)))
import sys
import math
sys.setrecursionlimit(5000)
n = int(input())
arr = [0]
for i in range(n):
arr.append(int(input()))
sum = [0] * (n + 1)
ans = 1;
for i in range(1, n + 1):
sum[i] = sum[i - 1] + arr[i - 1]
for i in range (1, n + 1):
if(arr[i] > 1):
ans *= C(sum[i] + arr[i] - 1, sum[i])
print(ans % 1000000007) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
long long int dx[] = {0, 1, 0, -1, -1, 1, -1, 1};
long long int dy[] = {-1, 0, 1, 0, -1, 1, 1, -1};
const long long int MAXN = 1e4 + 5;
const long long int N = 1e5 + 5;
long long int n, m;
template <class A>
ostream& operator<<(ostream& out, const vector<A>& v) {
out << "[";
for (long long int i = 0; i < v.size(); i++) {
if (i) out << ", ";
out << v[i];
}
return out << "]";
}
long long int binpow(long long int n, long long int p) {
long long int res = 1;
while (p > 0) {
if (p & 1) res = res * n;
n = n * n;
p >>= 1;
}
return res;
}
long long int power(long long int n, long long int p) {
long long int res = 1;
n %= 1000000007;
while (p > 0) {
if (p & 1) res = (res * n) % 1000000007;
n = (n * n) % 1000000007;
p >>= 1;
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2);
}
long long int fact[MAXN], inv[MAXN], invfact[MAXN];
void initFactorials() {
fact[0] = 1;
for (long long int i = 1; i < MAXN; i++) {
fact[i] = (fact[i - 1] * i * 1LL) % 1000000007;
}
inv[1] = 1;
for (long long int i = 2; i < MAXN; i++)
inv[i] = inv[1000000007 % i] * (1000000007 - 1000000007 / i) % 1000000007;
invfact[0] = 1;
for (long long int i = 1; i < MAXN; i++)
invfact[i] = (invfact[i - 1] * inv[i]) % 1000000007;
}
long long int nCrMod(long long int n, long long int r) {
if (n < r) return 0;
if (r == 0) return 1;
long long int num = fact[n], den = (fact[r] * fact[n - r]) % 1000000007;
long long int inv = modInverse(den, 1000000007);
return (num * inv) % 1000000007;
}
void solve() {
long long int x, y, z, k;
initFactorials();
cin >> k;
long long int a[k];
n = 0;
for (long long int i = 0; i < k; i++) cin >> a[i], n += a[i];
long long int res = 1;
for (long long int i = k - 1; i >= 0; i--) {
x = a[i];
y = nCrMod(n - 1, x - 1);
n -= x;
res *= y;
res %= 1000000007;
}
cout << res << "\n";
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long degree(long long a, long long k, long long p) {
long long res = 1;
long long cur = a;
while (k) {
if (k % 2) {
res = (res * cur) % p;
}
k /= 2;
cur = (cur * cur) % p;
}
return res;
}
long long get_degree(long long n, long long p) {
long long int degree_num = 0;
long long u = p;
long long temp = n;
while (u <= temp) {
degree_num += temp / u;
u *= p;
}
return degree_num;
}
long long combinations(long long int n, long long int k, long long p) {
long long int num_degree = get_degree(n, p) - get_degree(n - k, p);
long long int den_degree = get_degree(k, p);
if (num_degree > den_degree) {
return 0;
}
long long res = 1;
for (long long i = n; i > n - k; --i) {
long long ti = i;
while (ti % p == 0) {
ti /= p;
}
res = (res * ti) % p;
}
for (long long i = 1; i <= k; ++i) {
long long ti = i;
while (ti % p == 0) {
ti /= p;
}
res = (res * degree(ti, p - 2, p)) % p;
}
return res;
}
long long int dp[1001] = {0};
long long int c[1001] = {0};
long long int c1[1001] = {0};
int main(void) {
ios_base::sync_with_stdio(false);
long long int k;
cin >> k;
for (long long int i = 0; i < k; i++) cin >> c[i];
dp[0] = 1;
c1[0] = c[0];
for (long long int i = 1; i < k; i++) c1[i] = c[i] + c1[i - 1];
for (long long int i = 1; i < k; i++) {
dp[i] = dp[i - 1];
long long int obj = c[i] - 1;
long long int pla = c1[i - 1] + 1;
long long int comb;
if (pla > 1)
comb = combinations(obj + pla - 1, pla - 1, 1000000007ll);
else
comb = 1;
dp[i] = (dp[i - 1] * comb) % 1000000007ll;
}
cout << dp[k - 1];
}
| 9 | CPP |
from sys import stdin
input=lambda : stdin.readline().strip()
from math import ceil,sqrt,factorial,gcd
from collections import deque
from bisect import bisect_right
k=int(input())
ans=1
total=0
MOD=1000000007
for i in range(k):
z=int(input())
ans=(ans*factorial(total+z-1)//factorial(total)//factorial(z-1))%MOD
total+=z
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long scan_d() {
char t = getchar();
long long you = 0;
while (t > '9' || t < '0') t = getchar();
while (t <= '9' && t >= '0') {
you *= 10;
you += t - '0';
t = getchar();
}
return you;
}
long long dp[1050][1050];
long long op[1001];
int main() {
for (int i = 0; i <= 1010; i++) dp[1][i] = 1;
for (int i = 2; i <= 1010; i++)
for (int o = i - 1; o <= 1010; o++) {
dp[i][o] = dp[i - 1][o - 1] + dp[i][o - 1];
dp[i][o] %= 1000000007;
}
long long y;
y = scan_d();
long long sum = 0;
for (int i = 1; i <= y; i++) {
op[i] = scan_d();
}
long long ans = 1;
for (int i = 1; i <= y; i++) {
sum += op[i];
ans *= dp[op[i]][sum - 1];
ans %= 1000000007;
}
cout << ans << endl;
}
| 9 | CPP |
t = int(input())
c = 1
s = int(input())
for _ in range(t-1):
n = int(input())
s += n
k = 1
for i in range(1, n):
k = k*(s-i)//i
c = (c*k) % (10**9+7)
print(c)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[1010][1010];
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k, x;
cin >> k;
memset(dp, 0, sizeof(dp));
long long int ans = 1;
n = 0;
for (int(i) = (1); (i) < (1000 + 1); ++(i)) {
dp[i][i] = dp[i][0] = 1;
for (int(j) = (1); (j) < (i); ++(j)) {
dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % 1000000007;
}
}
cin >> n;
for (int(i) = (1); (i) < (k); ++(i)) {
cin >> x;
ans = (ans * dp[n + x - 1][x - 1]) % 1000000007;
n += x;
}
cout << ans << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int k;
long long dp[1001][1001];
long long mod(long long a) { return a % 1000000007; }
long long sum(long long a, long long b) { return mod(mod(a) + mod(b)); }
long long mul(long long a, long long b) { return mod(mod(a) * mod(b)); }
void initdp() {
for (int i = 0; i < 1001; ++i) dp[i][0] = dp[i][i] = 1;
for (int i = 1; i < 1001; ++i) {
for (int j = 1; j < 1001; ++j) {
dp[i][j] = sum(dp[i - 1][j - 1], dp[i - 1][j]);
}
}
}
int main() {
ios::sync_with_stdio(false);
initdp();
while (cin >> k) {
vector<long long> v(k);
long long ans = 1, aux = 0;
for (int i = 0; i < k; ++i) cin >> v[i];
aux = v[0];
for (int i = 1; i < k; ++i) {
aux += v[i];
ans = mul(ans, dp[aux - 1][v[i] - 1]);
}
cout << ans << "\n";
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int dp[1005][1005];
long long int fact[100005], ifact[100005];
long long int power(long long int a, long long int b) {
long long int ans = 1, temp = a;
while (b > 0) {
if (b % 2 == 0) {
temp = (temp * temp) % 1000000007;
b /= 2;
} else {
ans = (ans * temp) % 1000000007;
b--;
}
}
return ans % 1000000007;
}
void precompute() {
long long int i = 1;
fact[0] = fact[1] = 1;
for (i = 2; i <= 100000; i++)
fact[i] = (long long int)(i * fact[i - 1]) % 1000000007;
ifact[100000] = power(fact[100000], 1000000007 - 2);
for (i = 99999; i >= 0; i--)
ifact[i] =
(long long int)(ifact[i + 1] * (i + (long long int)1)) % 1000000007;
}
long long int cal(long long int n, long long int r) {
long long int ans;
if (n < r) return 0;
ans = (fact[n] % 1000000007 * ifact[r] % 1000000007) % 1000000007;
ans = (ans * ifact[n - r]) % 1000000007;
return ans % 1000000007;
}
int main() {
long long int t, i, j, n, m, ans, sum, col[1005], pos, ball, k, cnt;
cin >> k;
precompute();
memset(dp, 0, sizeof(dp));
sum = 0;
for (i = 1; i <= k; i++) {
cin >> col[i];
sum += col[i];
}
cnt = 0;
for (i = 1; i <= k; i++) {
for (j = 1; j <= sum; j++) {
pos = j - 1 - cnt;
ball = col[i] - 1;
if (i > 1)
dp[i][j] = (cal(pos, ball) * dp[i - 1][j - 1]) % 1000000007;
else
dp[i][j] = (cal(pos, ball)) % 1000000007;
dp[i][j] = (dp[i][j] + dp[i][j - 1]) % 1000000007;
}
cnt += col[i];
}
cout << dp[k][sum];
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
int a[maxn];
long long dp[maxn][maxn];
void pre() {
dp[0][0] = 1;
for (int i = 1; i < maxn; i++) {
dp[i][i] = 1;
dp[i][0] = 1;
for (int j = 1; j < i; j++)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % 1000000007;
}
}
int main() {
int k;
pre();
while (cin >> k) {
int total = 0;
for (int i = 0; i < k; i++) {
cin >> a[i];
total += a[i];
}
long long res = 1;
for (int i = k - 1; i > 0; i--) {
res *= dp[total - 1][a[i] - 1];
res %= 1000000007;
total -= a[i];
}
cout << res << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s[1010][1010] = {0};
int t;
int a = 1;
int q;
long long ans = 1;
for (int i = 0; i < 1010; i++) s[i][0] = 1;
for (int i = 1; i < 1010; i++)
for (int j = 1; j < 1010; j++)
s[i][j] = (s[i][j - 1] + s[i - 1][j]) % 1000000007;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> q;
ans = (ans * s[a][q - 1]) % 1000000007;
a += q;
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long PowerMod(long long a, long long b, long long c) {
long long ans = 1;
a = a % c;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % c;
b = b / 2;
a = (a * a) % c;
}
return ans;
}
long long C(long long n, long long m) {
if (m < n - m) m = n - m;
long long ans = 1;
for (long long i = n; i > m; i--) {
ans *= i;
ans %= 1000000007;
}
for (long long i = 1; i <= n - m; i++)
ans = ans * (PowerMod(i, 1000000007 - 2, 1000000007)) % 1000000007;
return ans % 1000000007;
}
int main() {
int k;
cin >> k;
int a[1005] = {0};
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
}
int pre[1005] = {0};
for (int i = 1; i <= k; i++) {
pre[i] = pre[i - 1] + a[i];
}
long long answer = 1;
for (int i = k; i >= 1; i--) {
answer *= (C(pre[i] - 1, a[i] - 1));
answer %= 1000000007;
}
cout << answer % 1000000007 << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const double Pi = 3.1415926535;
long long bin_pow(long long a, long long b) {
if (b == 1) return a;
if (b % 2 == 0) {
long long c = bin_pow(a, b / 2);
return (c * c) % 1000000007;
} else {
long long c = bin_pow(a, b / 2);
return ((c * c % 1000000007) * a) % 1000000007;
}
}
long long colors[3000];
long long n[4005];
long long k[4005];
int main() {
int sizeI;
cin >> sizeI;
for (int i = 0; i < sizeI; i++) {
cin >> colors[i];
}
n[1] = 1;
k[1] = 1;
for (int i = 2; i <= 4000; i++) {
n[i] = n[i - 1] * i % 1000000007;
k[i] = bin_pow(n[i], 1000000007 - 2);
}
long long sum = colors[0];
long long ans = 1;
for (int i = 1; i < sizeI; i++) {
sum += colors[i] - 1;
if (colors[i] == 1) {
sum++;
continue;
}
ans = (ans * (n[sum] * k[colors[i] - 1] % 1000000007) % 1000000007) *
k[sum - (colors[i] - 1)] % 1000000007;
sum++;
}
cout << ans;
}
| 9 | CPP |
INF = 1000000007
k = int(input())
ks = []
for i in range(k):
ks.append(int(input()))
facts = [1, 1]
for i in range(2, 1000):
facts.append(facts[i - 1] * i)
count = 1
summ = ks[0]
for i in range(1, k):
count *= facts[ks[i] - 1 + summ] // facts[summ] // facts[ks[i] - 1]
count %= INF
summ += ks[i]
print(count % INF) | 9 | PYTHON3 |
import math
def read_data():
k = int(input())
ns = [int(input()) for i in range(k)]
return k, ns
def solve(k, ns):
n = sum(ns)
free_pos = n
result = 1
mod = 10**9 + 7
for ni in reversed(ns):
tmp = math.factorial(free_pos - 1)//math.factorial(free_pos - ni)
tmp //= math.factorial(ni - 1)
tmp %= mod
result *= tmp
result %= mod
free_pos -= ni
return result
k, ns = read_data()
print(solve(k, ns)) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool sieve[1000100];
vector<long long> primes;
long long v[1010];
long long dp[1000100];
long long sum;
void mountSieve() {
for (int i = 2; i * i < 1000100; i++) {
if (!sieve[i]) {
int x = i * i;
while (x < 1000100) {
sieve[x] = true;
x += i;
}
}
}
for (int i = 2; i < 1000100; i++) {
if (!sieve[i]) {
primes.push_back(i);
}
}
}
int main() {
mountSieve();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &v[i]);
sum += v[i];
}
sum--;
for (int i = 0; primes[i] <= sum; i++) {
long long x = primes[i];
while (x <= sum) {
dp[primes[i]] += sum / x;
x *= primes[i];
}
}
for (int j = 1; j <= n; j++) {
sum = v[j] - 1;
for (int i = 0; primes[i] <= sum; i++) {
long long x = primes[i];
while (x <= sum) {
dp[primes[i]] -= sum / x;
x *= primes[i];
}
}
}
sum = 0;
for (int i = 1; i < n; i++) {
sum += v[i];
long long x = sum;
for (int j = 0; primes[j] <= x; j++) {
while (x % primes[j] == 0) {
dp[primes[j]]--;
x /= primes[j];
}
}
}
long long ans = 1;
for (int i = 1; i < 1000100; i++) {
while (dp[i]--) {
ans *= i;
if (ans >= 1000000007) ans %= 1000000007;
}
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
# coding: utf-8
# In[6]:
matrix = [[0 for x in range(1001)] for y in range(1001)]
mod = 1000000007
def pascal():
matrix[0][0]=1;
for i in range(1001):
for j in range(1001):
if j==0 or j==i:
matrix[i][j]=1
else:
matrix[i][j] = (matrix[i-1][j-1]+matrix[i-1][j])%mod
a = int(input())
b = []
for i in range(a):
b.append(int(input()))
pascal()
r = 1
s = b[0]
for i in range(1,a):
r = (r*matrix[s + b[i]-1][b[i]-1])%mod
s += b[i]
print(r)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const long long int Mod = 1000000007;
long long int C[N][N];
int main() {
C[0][0] = 1;
C[1][0] = C[1][1] = 1;
for (int i = 2; i < N - 1; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % Mod;
}
int n;
int a[N];
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long int ans = 1;
long long int count = 0;
for (int i = 0; i < n; i++) {
count += a[i];
ans = (ans * C[count - 1][a[i] - 1]) % Mod;
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int a[1005];
long long C[1005][1005];
void init() {
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j <= i; j++) {
if (i == 0 || j == 0)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
}
int main() {
init();
int n;
cin >> n;
int sum = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
long long cnt = 1;
for (int i = n; i >= 1; i--) {
cnt = cnt * C[sum - 1][a[i] - 1] % mod;
sum -= a[i];
}
cout << cnt << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int MOD = 1E9 + 7;
int n, x, c[N][N], ans = 1, sum;
int main() {
c[0][0] = 1;
for (int i = 1; i < N; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % MOD;
}
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
sum += x;
ans = ((long long)ans * c[sum - 1][x - 1]) % MOD;
}
cout << ans << endl;
}
| 9 | CPP |
n = int(input())
cnt = []
for i in range(n):
cnt.append(int(input()))
dp = [1]
length = [cnt[0]]
MOD = int(1000000007)
def C(n, k):
assert(n >= k)
res = 1
for i in range(n - k + 1, n + 1):
res *= i
for i in range(2, k + 1):
res //= i
"""DEBUG"""
#import math as m
#assert(res == m.factorial(n) // m.factorial(k) // m.factorial(n - k))
""""/DEBUG"""
return res % MOD
for i in range(1, n):
length.append(length[i - 1] + cnt[i])
dp.append((dp[i - 1] * C(length[i] - 1, cnt[i] - 1)) % MOD)
print(dp[n - 1])
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int a[1055];
long long C[1055][1055];
int main() {
C[0][0] = 1;
for (int i = 1; i < 1055; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
}
}
int k;
cin >> k;
vector<int> color(k + 2);
for (int i = 0; i < k; i++) {
cin >> color[i];
}
long long res = 1;
int tot = 0;
for (int i = 0; i < k; i++) {
res = (res * C[tot + color[i] - 1][color[i] - 1]) % 1000000007;
tot += color[i];
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
const int mod = 1000000000 + 7;
int K;
int C[1010];
int dp[1010][1010];
int tot;
const int MAX_ARG = 2200;
long long dp2[MAX_ARG][MAX_ARG];
long long comb(int a, int b) {
if (a < 0 || b < 0) return 0;
if (a < b)
return 0;
else if (b == 0)
return 1;
else if (dp2[a][b] >= 0)
return dp2[a][b];
return dp2[a][b] = (comb(a - 1, b) + comb(a - 1, b - 1)) % mod;
}
int dfs(int kind, int pos, int sum) {
if (dp[kind][pos] >= 0) return dp[kind][pos];
long long res = 0;
if (kind == K) {
res = 1;
} else if (pos == tot) {
res = 0;
} else {
if (pos + 1 >= C[kind] + sum) {
const int A = pos + 1 - (C[kind] + sum) + C[kind] - 1;
const int B = C[kind] - 1;
res = (res + (comb(A, B) * dfs(kind + 1, pos + 1, sum + C[kind]))) % mod;
}
res = (res + dfs(kind, pos + 1, sum)) % mod;
}
return dp[kind][pos] = res;
}
int main() {
memset(dp, -1, sizeof(dp));
fastStream();
cin >> K;
for (int i = 0; i < K; i++) {
cin >> C[i];
tot += C[i];
}
memset(dp2, -1, sizeof(dp2));
cout << dfs(0, 0, 0) << endl;
return 0;
}
| 9 | CPP |
def fact(x):
r = 1
for i in range(1, x + 1): r *= i
return r
mod = int(1e9 + 7)
n = int(input())
arr = [0] * n
for i in range(n): arr[i] = int(input())
r = 1; s = 0
for i in range(1, n):
s += arr[i - 1]
r *= fact(s + arr[i] - 1) // fact(s) // fact(arr[i] - 1)
r %= mod
print(r)
| 9 | PYTHON3 |
def fact(n) :
p = n;
# print("n=" + str(n))
for i in range(1, n) :
# print("i=" + str(i))
p *= i
if(n == 0) :
return 1
return p
def ncr(n, r) :
return fact(n) // fact(n-r) // fact(r)
n = int(input())
c = []
for i in range(n) :
k = int(input())
c.insert(len(c), k)
# print("hi - " + str(c[i]))
p = 1
sum = 0
for i in range(n) :
# print("i=" + str(i))
sum += c[i]
# print("sum=" + str(sum))
# print(sum);
for i in range(n, 0, -1) :
# print("alala : " + str(ncr(sum-1, c[i-1]-1)))
# print("sum=" + str(sum-1) + " c : " + str(c[i-1]-1))
p = p * ncr(sum-1, c[i-1]-1)
p %= 1000000007
sum -= c[i-1]
print(int(p)) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1e9 + 7;
int n, a[1005];
long long c[1005][1005], ans = 1;
void pai() {
c[0][0] = 1;
for (int i = 1; i < 1005; i++) {
c[i][i] = c[i][0] = 1;
for (int j = 1; j < i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mo;
}
}
int main() {
pai();
cin >> n;
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = n - 1; i > 0; i--) {
ans *= c[sum - 1][a[i] - 1];
ans %= mo;
sum -= a[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long C[1005][1005];
void nCr() {
int i, j;
C[0][0] = 1;
for (i = 0; i < 1004; i++) C[i][0] = 1;
for (i = 1; i < 1004; i++) {
for (j = 1; j < i + 1; j++) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
if (C[i][j] >= 1000000007) C[i][j] = C[i][j] - 1000000007;
}
}
}
long long dp[1005];
int main() {
long long i, j;
ios_base ::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
nCr();
int k;
cin >> k;
int a[1005];
int n = 0;
for (i = 0; i < k; i++) {
cin >> a[i];
n += a[i];
}
dp[0] = 1;
for (i = 1; i < k; i++) {
dp[i] = (dp[i - 1] * C[n - 1][a[k - i] - 1]) % 1000000007;
n = n - a[k - i];
}
cout << dp[k - 1] << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e3 + 50;
const long long mod = 1000000007;
long long f[maxn][maxn];
int k, sum[maxn], c[maxn];
long long ans = 1;
long long dp(int x, int y) {
if (f[x][y] != -1) return f[x][y];
long long &tans = f[x][y] = 1;
if (y == 0 || y == x) return tans = 1;
tans = dp(x - 1, y - 1) + dp(x - 1, y);
if (tans >= mod) tans %= mod;
return tans;
}
int main(int argc, char *argv[]) {
memset(f, -1, sizeof(f));
cin >> k;
for (int i = 1; i < k + 1; ++i) {
cin >> c[i];
sum[i] = sum[i - 1] + c[i];
}
for (int i = 2; i <= k; ++i) {
int vk = sum[i - 1] + 1;
int n = c[i] - 1;
ans *= dp(vk + n - 1, vk - 1);
if (ans >= mod) ans %= mod;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 10000;
long long n, sum = 0;
long long ans = 1;
long long mod = 1000000000 + 7;
long long a[1000][1000];
long long num;
int32_t main() {
cin >> n;
a[0][0] = 1;
for (long long i = 1; i < 1000; i++) {
a[i][0] = 1;
for (long long j = 1; j <= i; j++) {
a[i][j] = (a[i - 1][j] + a[i - 1][j - 1]) % mod;
}
}
while (n > 0) {
cin >> num;
sum += num;
ans = (ans * a[sum - 1][num - 1]) % mod;
n--;
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
vector<int> x;
int sum = 0;
for (int i = 0; i < k; i++) {
int t;
cin >> t;
sum += t;
x.push_back(t);
}
unsigned long v[1005][1005];
v[0][0] = 1;
v[0][1] = 1;
v[0][2] = 0;
for (int i = 1; i < sum; i++) {
v[i][0] = 1;
for (int j = 0; j < i + 1; j++) {
v[i][j + 1] = (v[i - 1][j + 1] + v[i - 1][j]) % 1000000007;
}
v[i][i + 2] = 0;
}
unsigned long long int p = 1;
for (int i = 0; i < k - 1; i++) {
p = (p * v[sum - 2][x[k - i - 1] - 1]) % 1000000007;
sum = sum - x[k - i - 1];
}
cout << p << endl;
}
| 9 | CPP |
mx=1001
mod=1000000007
nCr=[[0 for i in range(mx)] for j in range(mx)]
nCr[0][0]=1
for i in range(1,mx):
nCr[i][0]=1
for j in range(1,mx):
nCr[i][j]=nCr[i-1][j-1]+nCr[i-1][j]
n=int(input())
l=[]
for i in range(n):
l.append(int(input()))
res=1
total=0
for i in range(n):
res=(res*nCr[total+l[i]-1][l[i]-1])%mod
total+=l[i]
print(res) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int pow(long long t, long long n) {
if (n == 1) return t % 1000000007;
if (n % 2 == 0)
return pow((t * t) % 1000000007, n / 2);
else
return (t * pow(t, n - 1)) % 1000000007;
}
int mod_inv(int r) { return pow(r, 1000000007 - 2); }
int C(int n, int r) {
if (r == 0) return 1;
return (long long)C(n - 1, r - 1) * n % 1000000007 * mod_inv(r) % 1000000007;
}
int H(int n, int r) { return C(n + r - 1, r); }
int main() {
int n;
cin >> n;
long long ans = 1;
int total = 0;
while (n--) {
int tmp;
cin >> tmp;
ans = ans * H(total + 1, tmp - 1) % 1000000007;
total += tmp;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
long long fp[1010], fc[1010], inv[1010];
int n, a[1010], m;
long long f[1010][1010];
long long fpm(long long x, int y) {
long long res = 1;
for (; y; y >>= 1, x = x * x % mod)
if (y & 1) res = res * x % mod;
return res;
}
void update(long long& x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
long long C[2010][2010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i <= 2000; i++) C[i][0] = 1;
for (int i = 1; i <= 2000; i++)
for (int j = 1; j <= 2000; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
long long ans = 1;
int s = 0;
for (int i = 1; i <= n; i++) {
ans *= C[s + a[i] - 1][s], ans %= mod;
s += a[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 100;
long long inv[maxn], pro[maxn], invpro[maxn];
long long a[maxn], sum[maxn], dp[maxn];
void Prepare_C() {
inv[1] = 1;
for (int i = 2; i < maxn; i++)
inv[i] = (long long)(mod - mod / i) * inv[mod % i] % mod;
pro[0] = invpro[0] = 1;
for (int i = 1; i < maxn; i++) {
pro[i] = pro[i - 1] * i % mod;
invpro[i] = invpro[i - 1] * inv[i] % mod;
}
}
long long get_C(int n, int m) {
if (n < m) return 0;
return pro[n] * invpro[m] % mod * invpro[n - m] % mod;
}
int main() {
int k;
Prepare_C();
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
sum[i] = sum[i - 1] + a[i];
}
dp[1] = 1LL;
for (int i = 2; i <= k; i++) {
dp[i] = dp[i - 1];
for (int j = 1; j < a[i]; j++) {
dp[i] +=
get_C(sum[i - 1] + a[i] - j - 1, a[i] - j) % mod * dp[i - 1] % mod;
dp[i] %= mod;
}
}
printf("%I64d\n", dp[k] % mod);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int md = 1e9 + 7;
int k, n, c[1005][1005];
int main() {
c[0][0] = 1;
for (int i = 1; i < 1005; i++) {
c[i][0] = 1;
for (int j = 1; j < 1005; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % md;
}
scanf("%d", &k);
long long ans = 1;
while (k--) {
int x;
scanf("%d", &x);
ans = (ans * c[n + x - 1][x - 1]) % md;
n += x;
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
vector<long long> sil;
long long fme(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 1) return (fme(a, b - 1) * a) % MOD;
long long tmp = fme(a, b / 2);
return (tmp * tmp) % MOD;
}
long long nck(long long n, long long k) {
if (k < 0 || k > n) return 0;
return ((sil[n] * fme(sil[k], MOD - 2) % MOD) * fme(sil[n - k], MOD - 2)) %
MOD;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
sil.resize(2002);
sil[0] = 1;
for (long long i = 1; i < sil.size(); i++) sil[i] = (i * sil[i - 1]) % MOD;
int n;
cin >> n;
long long res = 1;
long long curSiz = 0;
vector<int> tab(n);
for (int i = 0; i < n; i++) {
cin >> tab[i];
res = res * nck(curSiz + tab[i] - 1, tab[i] - 1) % MOD;
curSiz += tab[i];
}
cout << res << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int jie[1000001], n, a[1001], sum, ans;
long long int fast(long long int x, long long int y) {
long long int z = 1;
while (y) {
if (y & 1) z = (z * x) % 1000000007;
x = x * x % 1000000007;
y >>= 1;
}
return z;
}
long long int zuhe(long long int nn, long long int mm) {
return ((jie[nn] % 1000000007) *
(fast((jie[mm] * jie[nn - mm]) % 1000000007, 1000000007 - 2) %
1000000007)) %
1000000007;
}
int main() {
int i;
jie[0] = 1;
for (i = 1; i < 1000001; i++) jie[i] = (jie[i - 1] * i) % 1000000007;
while (scanf("%I64d", &n) != EOF) {
sum = 0;
ans = 1;
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
sum = sum + a[i];
}
for (i = n; i >= 1; i--) {
ans = ((ans % 1000000007) * (zuhe(sum - 1, a[i] - 1) % 1000000007)) %
1000000007;
sum = sum - a[i];
}
printf("%I64d\n", ans);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int *arr = new int[n];
int *csum = new int[n];
int **pascal = new int *[1001];
for (int i = 0; i < 1001; i++) {
pascal[i] = new int[1001];
for (int j = 0; j < 1001; j++) {
if (j > i)
pascal[i][j] = 0;
else if (i == j)
pascal[i][j] = 1;
else if (j == 0)
pascal[i][j] = 1;
else {
pascal[i][j] = (pascal[i - 1][j - 1] + pascal[i - 1][j]) % 1000000007;
}
}
}
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (i == 0)
csum[i] = arr[i];
else
csum[i] = csum[i - 1] + arr[i];
}
long long int sum = 1;
for (int i = 1; i < n; i++) {
sum = (sum * pascal[csum[i - 1] + arr[i] - 1][csum[i - 1]]) % 1000000007;
}
cout << sum << endl;
return 0;
}
| 9 | CPP |
k,md,s,res=int(input()),1000000007,int(input()),1
c=[[1]+[0]*1000 for i in range(1001)]
for i in range(1,1001):
for j in range(1,i+1):
c[i][j]=(c[i-1][j]+c[i-1][j-1])%md
for i in range(1,k):
x=int(input())
s+=x
res=(res*c[s-1][x-1])%md
print(res) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long c[1010][1010];
void init() {
for (long long i = 0; i <= 1005; i++) {
c[i][0] = c[i][i] = 1;
for (long long j = 1; j < i; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007;
}
}
signed main() {
init();
long long n;
cin >> n;
long long tot = 0, ans = 1;
for (long long i = 0; i < n; i++) {
long long tmp;
cin >> tmp;
if (tot) {
ans *= c[tot + tmp - 1][tmp - 1];
ans %= 1000000007;
tot += tmp;
} else
tot += tmp;
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int C[1001][1001];
int main() {
for (int i = 0; i < 1001; ++i) {
C[i][0] = 1;
for (int j = 1; j < i; ++j) {
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
if (C[i][j] >= mod) C[i][j] -= mod;
}
for (int j = i; j < 1001; ++j) C[i][j] = C[i][j - i];
}
int n;
scanf("%d", &n);
long long ans = 1;
int cnt = 0;
while (n--) {
int x;
scanf("%d", &x);
ans = ans * C[cnt + x - 1][x - 1] % mod;
cnt += x;
}
printf("%lld\n", ans);
}
| 9 | CPP |
"""
#If FastIO not needed, used this and don't forget to strip
#import sys, math
#input = sys.stdin.readline
"""
import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from collections import defaultdict as dd, deque as dq
import math, string
def getInts():
return [int(s) for s in input().split()]
def getInt():
return int(input())
def getStrs():
return [s for s in input().split()]
def getStr():
return input()
def listStr():
return list(input())
MOD = 10**9+7
"""
Number of ways to position ith ball is (C1+C2+...+Ci - 1) choose (Ci - 1)
"""
facs = [1]
curr = 1
for j in range(1,10**6+1):
curr *= j
curr %= MOD
facs.append(curr)
def solve():
N = getInt()
cols = []
pref = []
curr = 0
for i in range(N):
x = getInt()
curr += x
cols.append(x)
pref.append(curr)
dp = 1
for j in range(1,N):
tot = pref[j]
mult = facs[tot-1]*pow(facs[cols[j]-1], MOD-2, MOD)*pow(facs[pref[j-1]],MOD-2,MOD)
dp *= mult
dp %= MOD
return dp
#for _ in range(getInt()):
print(solve()) | 9 | PYTHON3 |
def binomialCoefficient(n, k):
if(k > n - k):
k = n - k
res = 1
for i in range(k):
res = res * (n - i)
res = res // (i + 1)
return res
k=int(input())
sum=0
ans=1
m=1000000007
for i in range(k):
a=int(input())
ans=(ans%m)*(binomialCoefficient(sum+a-1,a-1))%m
sum+=a
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1234567;
long long dp[1005], A[1005], fact[1005], inv[1005];
long long fast_pow(long long x, long long n) {
long long prod = 1;
while (n) {
if (n & 1) prod = prod * x % 1000000007;
x = x * x % 1000000007;
n >>= 1;
}
return prod;
}
void factorial() {
fact[0] = 1;
for (int i = 1; i <= 1000; i++) {
fact[i] = fact[i - 1] * i % 1000000007;
}
}
void mmi() {
for (int i = 0; i <= 1000; i++) inv[i] = fast_pow(fact[i], 1000000007 - 2);
}
long long nCr(long long n, long long r) {
if (r > n) return 0;
if (r == 0) return 1;
return fact[n] * (inv[n - r] * inv[r] % 1000000007) % 1000000007;
}
int main() {
factorial();
mmi();
int k;
cin >> k;
for (int i = 1; i <= k; i++) cin >> A[i];
long long sum = 0;
dp[0] = 1;
dp[1] = 1;
for (int i = 1; i <= k; i++) {
dp[i] = dp[i - 1] * nCr(sum + A[i] - 1, A[i] - 1) % 1000000007;
sum += A[i];
}
if (dp[k] < 0) dp[k] += 1000000007;
cout << dp[k];
return 0;
}
| 9 | CPP |
ans = 1
n = int(input())
s = int(input())
mod = 1000000007
for _ in range(1, n):
now = int(input())
s += now
k = 1
for i in range(now - 1):
k = k * (s - 1 - i) // (i + 1)
ans = ans * k % mod
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10001;
const int P = 1e9 + 7;
inline void add(int& a, int b) {
a += b;
if (a >= P) a -= P;
}
inline void mul(int& a, int b) { a = (long long)a * b % P; }
inline int inver(int x) {
int ret = 1, y = P - 2;
while (y) {
if (y & 1) mul(ret, x);
mul(x, x);
y >>= 1;
}
return ret;
}
int fac[N], inv[N];
void pre() {
fac[0] = inv[0] = 1;
for (int i = 1; i < N; ++i) {
fac[i] = i;
mul(fac[i], fac[i - 1]);
}
inv[N - 1] = inver(fac[N - 1]);
for (int i = N - 2; i > 0; i--) {
inv[i] = inv[i + 1];
mul(inv[i], i + 1);
}
}
int main() {
pre();
int k, x;
scanf("%d", &k);
int ans = 1;
int tot = 0;
for (int i = 0; i < k; ++i) {
scanf("%d", &x);
int tmp = 1;
mul(tmp, fac[tot + x - 1]);
mul(tmp, inv[tot]);
mul(tmp, inv[x - 1]);
mul(ans, tmp);
add(tot, x);
}
printf("%d\n", ans);
return 0;
}
| 9 | CPP |
c = []
k = int(input())
for i in range(k):
c.append(int(input()))
maxN = 1010
binomials = [[1], [1, 1]]
for i in range(2, maxN):
binomials.append([1])
for j in range(1, i):
binomials[i].append((binomials[i - 1][j - 1] + binomials[i - 1][j]) % 1000000007)
binomials[i].append(1)
dp = [1] * k
for i in range(1, k):
dp[i] = (dp[i - 1] * binomials[sum(c[:i + 1]) - 1][c[i] - 1]) % 1000000007
print(dp[k - 1])
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int balls[1000 + 1];
long long int d[1000 + 1][1000 + 1];
int main(int argc, const char* argv[]) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &balls[i]);
balls[i] += balls[i - 1];
}
for (int i = 0; i <= 1000; i++) {
d[0][i] = d[i][0] = 1;
}
for (int i = 1; i <= 1000; i++) {
for (int j = 1; j <= 1000; j++) {
d[i][j] = d[i - 1][j] + d[i][j - 1];
d[i][j] %= 1000000007;
}
}
long long int possibilities = 1;
for (int i = 1; i <= n; i++) {
possibilities *= d[balls[i - 1]][balls[i] - balls[i - 1] - 1];
possibilities %= 1000000007;
}
printf("%lld\n", possibilities);
return 0;
}
| 9 | CPP |
def c(k,l):
d=1
for i in range(k+1,l+k+1): d*=i
for i in range(l): d//=(i+1)
return d%1000000007
ans=1
n=int(input())
k=int(input())
for t in range(1,n):
a=int(input())
ans*=c(k,a-1)%1000000007
k+=a
print(ans%1000000007)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long comb[4001][4001];
int main() {
int i, j;
for (i = 0; i < 4001; i++) comb[i][0] = comb[0][i] = comb[i][i] = 1;
for (i = 1; i < 4001; i++)
for (j = 1; j < i; j++)
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % 1000000007;
int n;
cin >> n;
long long ans = 1, k, spaces = 0, t;
cin >> k;
for (i = 1; i < n; i++) {
spaces += k;
cin >> k;
ans = (ans * comb[spaces + k - 1][k - 1]) % 1000000007;
}
cout << ans;
cin >> i;
}
| 9 | CPP |
def main():
from math import factorial as f
n, res = 0, 1
for _ in range(int(input())):
m = int(input())
res = res * f(n + m - 1) // f(n) // f(m - 1) % 1000000007
n += m
print(res)
if __name__ == '__main__':
main()
| 9 | PYTHON3 |
import math as ma
m=10**9+7
n=int(input())
a=[]
for i in range(n):
a.append(int(input()))
b=a[0]
c=1
for i in range(1,n):
c=((c*((ma.factorial(b+a[i]-1))//(ma.factorial(b)*ma.factorial(a[i]-1)))%m))
b=(b+a[i])%m
print(c) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct T {
int a;
};
long long int bigmod(long long int a, long long int b, long long int mod) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long int hh = bigmod(a, b / 2, mod);
return (hh * hh) % mod;
} else {
return (a * bigmod(a, b - 1, mod)) % mod;
}
}
long long int ar[1000005], fact[1000005], ifac[1000005];
int main() {
long long int i, j, k, l, t, cs = 1, r = 1, s, m, n, a, b, c, d, e, f, g, h,
u, v, mod = 1000000007;
fact[0] = 1;
ifac[0] = bigmod(fact[0], mod - 2, mod);
for (i = 1; i <= 1000001; i++) {
fact[i] = (fact[i - 1] * i) % mod;
ifac[i] = bigmod(fact[i], mod - 2, mod);
}
scanf("%I64d", &n);
long long int ans = 1;
s = 0;
for (i = 0; i < n; i++) {
scanf("%I64d", &ar[i]);
s = s + ar[i];
if (i > 0) {
u = (ifac[ar[i] - 1] * ifac[s - 1 - ar[i] + 1]) % mod;
u = (fact[s - 1] * u) % mod;
ans = (ans * u) % mod;
}
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 7;
long long int mod = 1e9 + 7;
long long int comb[N][N], col[N];
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int k;
cin >> k;
comb[0][0] = 1;
for (int i = 0; i < k; ++i) {
cin >> col[i];
}
for (int i = 1; i < N; ++i) {
comb[i][0] = 1;
}
for (int i = 1; i < N; ++i) {
for (int j = 1; j < N; ++j) {
comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
comb[i][j] %= mod;
}
}
long long int res = 1;
long long int tot = 0;
for (int i = 0; i < k; ++i) {
res *= comb[tot + col[i] - 1][col[i] - 1];
res %= mod;
tot += col[i];
}
cout << res;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int ncr[1005][1005];
void calculate() {
ncr[0][0] = 1;
for (int i = 1; i < 1005; ++i) {
for (int j = 0; j < 1005; ++j) {
if (i < j) {
ncr[i][j] = 0;
continue;
}
if (j == 0)
ncr[i][j] = 1;
else
ncr[i][j] = (ncr[i - 1][j] + ncr[i - 1][j - 1]) % 1000000007;
}
}
}
int main() {
calculate();
for (int i = 0; i < 10; ++i) {
for (int j = 0; j < 10; ++j) {
}
}
int k;
cin >> k;
int a[k + 1];
for (int i = 1; i <= k; ++i) {
cin >> a[i];
}
long long int f[k + 1];
f[1] = 1;
int sum = a[1];
for (int i = 2; i <= k; ++i) {
f[i] = ncr[sum + a[i] - 1][a[i] - 1] % 1000000007;
f[i] *= f[i - 1];
f[i] %= 1000000007;
sum += a[i];
}
cout << f[k] << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2020;
const long long MOD = 1000000007;
long long a[MAXN];
long long ncr[MAXN][MAXN];
void myinit() {
ncr[0][0] = 1;
for (long long i = 1; i < MAXN; i++)
for (long long j = 0; j <= i; j++) {
ncr[i][j] = ncr[i - 1][j];
if (j > 0) ncr[i][j] = ((ncr[i][j] + ncr[i - 1][j - 1]) % MOD);
}
}
long long mynhr(long long n, long long r) { return ncr[n + r - 1][r - 1]; }
int main() {
myinit();
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
long long bucket = a[0] + 1;
long long ans = 1;
for (long long i = 1; i < n; i++) {
ans = (ans * mynhr(a[i] - 1, bucket)) % MOD;
bucket += a[i];
}
cout << (ans % MOD) << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[1003];
const int mod = 1000000007;
int comb[1005][1005], i, j;
int main() {
int lim = 1002;
for (i = 1; i <= lim; i++) comb[i][i] = comb[i][0] = 1;
for (i = 2; i <= lim; i++)
for (j = 1; j < i; j++) {
long long aux = comb[i - 1][j] + comb[i - 1][j - 1];
aux %= mod;
comb[i][j] = aux;
}
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
long long ans = 1;
long long nr = a[1];
for (i = 2; i <= n; i++) {
int en = a[i] - 1;
ans = (1LL * ans * comb[en + nr][en]) % mod;
nr += a[i];
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
inline T min(T a, T b, T c) {
return min(a, min(b, c));
}
vector<vector<int> > ComputeCombination(int n) {
vector<vector<int> > res(n + 1, vector<int>(n + 1));
for (int i = 0; i <= n; i++) {
res[i][0] = 1;
res[i][i] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j < i; j++) {
res[i][j] = (res[i - 1][j] + res[i - 1][j - 1]) % 1000000007;
}
}
return res;
}
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int k, tmp;
cin >> k;
long long ans = 1;
int sum = 0;
vector<vector<int> > nCr = ComputeCombination(1010);
for (int i = 0; i < k; i++) {
cin >> tmp;
ans = (ans * nCr[sum + tmp - 1][tmp - 1]) % 1000000007;
sum += tmp;
}
cout << ans << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
int n, k, c[1003], dp[1003][1003];
long long ans;
int main() {
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &c[i]);
}
for (int i = 0; i < 1003; i++) {
for (int j = 0; j < 1003; j++) {
if (i == 0 || j == 0)
dp[i][j] = 1;
else
dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
dp[i][j] %= 1000000007;
}
}
ans = 1;
for (int i = 1; i <= k; i++) {
ans = (ans * dp[n][c[i] - 1]) % 1000000007;
n += c[i];
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int n, con[1010][1010], dp[1010], a[1010], sum[1010];
void proc() {
con[0][0] = 1;
for (int i = 1; i < 1010; i++) {
con[i][0] = 1;
con[i][i] = 1;
for (int j = 1; j < i; j++)
con[i][j] =
(con[i - 1][j - 1] % 1000000007 + con[i - 1][j] % 1000000007) %
1000000007;
}
}
int main() {
proc();
gn(n);
for (int i = 1; i <= n; i++) {
gn(a[i]);
sum[i] = sum[i - 1] + a[i];
}
dp[1] = 1;
for (int i = 2; i <= n; i++)
dp[i] = (long long)dp[i - 1] * (con[sum[i] - 1][a[i] - 1]) % 1000000007;
println(dp[n]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a[1010];
long long c[1010][1010];
void preDeal() {
c[0][0] = c[1][0] = c[1][1] = 1;
for (int i = 1; i < 1010; i++) {
c[i][i] = c[i][0] = 1;
for (int j = 1; j < i; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007;
}
}
int main() {
int i;
long long k, sum, sum1;
preDeal();
while (scanf("%lld", &k) != EOF) {
sum1 = 1;
sum = 0;
for (i = 1; i <= k; i++) {
scanf("%lld", &a[i]);
sum += a[i];
}
for (i = k; i >= 1; i--) {
sum1 = (sum1 % 1000000007) * (c[sum - 1][a[i] - 1] % 1000000007);
sum1 = sum1 % 1000000007;
sum = sum - a[i];
}
printf("%lld\n", sum1 % 1000000007);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, x, fact[1000 + 10], sum, sol;
void precalc() {
fact[0] = 1;
for (int i = 1; i <= 1000; i++) fact[i] = fact[i - 1] * i % 1000000007;
}
long long lgput(long long a, long long n) {
if (!n) return 1;
if (n % 2 == 0) return lgput(a * a % 1000000007, n / 2);
return a * lgput(a * a % 1000000007, n / 2) % 1000000007;
}
long long C(long long n, long long k) {
long long val1 = fact[n];
long long val2 = fact[n - k] * fact[k] % 1000000007;
long long val = val1 * lgput(val2, 1000000007 - 2) % 1000000007;
return val;
}
int main() {
precalc();
cin >> n >> x;
sum = x;
sol = 1;
for (int i = 2; i <= n; i++) {
cin >> x;
sol = sol * C(sum + x - 1, x - 1) % 1000000007;
sum = sum + x;
}
cout << sol << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ans = 1;
int n, c[1050];
inline int Read() {
int x = 0;
char y;
do y = getchar();
while (y < '0' || y > '9');
do x = x * 10 + y - '0', y = getchar();
while (y >= '0' && y <= '9');
return x;
}
inline void In(int x, int y) {
int i, j, k, l = 0;
for (i = 2; i * i <= x; i++)
while (x % i == 0) x /= i, c[i] += y;
if (x > 1) c[x] += y;
return;
}
inline void C(int x, int y) {
for (int i = x + 1; i <= y; i++) In(i, 1);
for (int i = 2; i <= y - x; i++) In(i, -1);
return;
}
int main() {
int i, j, k, l, q = 0, w, e;
n = Read();
for (i = 1; i <= n; i++) w = Read(), C(w - 1, w - 1 + q), q += w;
for (i = 2; i <= 1000; i++)
for (j = 1; j <= c[i]; j++) ans = (ans * i) % 1000000007;
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int MAXN = 1009;
int n, k;
int a[MAXN];
long long c[MAXN][MAXN];
int main() {
cin >> k;
for (int i = 1; i <= k; ++i) {
cin >> a[i];
n += a[i];
}
for (int i = 0; i <= n; ++i) c[i][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
long long ans = 1;
for (int i = k; i >= 2; --i) ans = ans * c[n - 1][a[i] - 1] % mod, n -= a[i];
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N;
int arr[1010];
int sum[1010];
long long c[1010][1010], dp[1010][1010];
long long C(int n, int r) {
if (n == r || r == 0) return 1;
if (c[n][r] != -1) return c[n][r];
return c[n][r] = (C(n - 1, r - 1) % 1000000007 + C(n - 1, r) % 1000000007) %
1000000007;
}
long long solve(int ind, int pos) {
if (pos == sum[N - 1] + 1) {
if (ind == N) return 1;
return 0;
}
if (dp[ind][pos] != -1) return dp[ind][pos];
long long p1 = 0, p2 = 0;
if (pos - sum[ind] < 0)
p1 = solve(ind, pos + 1);
else {
p1 = solve(ind, pos + 1);
p2 = (solve(ind + 1, pos + 1) % 1000000007 *
C(pos - sum[ind] + arr[ind] - 1, arr[ind] - 1) % 1000000007) %
1000000007;
}
return dp[ind][pos] = (p1 % 1000000007 + p2 % 1000000007) % 1000000007;
}
int main() {
memset(c, -1, sizeof(c));
memset(dp, -1, sizeof(dp));
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i];
if (i == 0)
sum[i] = arr[i];
else
sum[i] = sum[i - 1] + arr[i];
}
cout << solve(0, 1) << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int ar[] = {0, 0, 1, -1};
int ac[] = {1, -1, 0, 0};
long long fast_pow(int n, int m) {
long long res = 1;
long long p = n;
while (m) {
if (m % 2) res *= p;
p *= p;
m /= 2;
}
return res;
}
int dp[1005][1005];
int a[1005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(9);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
long long res = 1;
int sum = 0;
dp[0][0] = 1;
for (int i = 1; i < 1005; i++)
for (int j = 0; j <= i; j++)
dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1], dp[i][j] %= 1000000007;
for (int i = 0; i < n; sum += a[i++])
res = res * dp[sum + a[i] - 1][a[i] - 1], res %= 1000000007;
cout << res << '\n';
}
| 9 | CPP |
#------------------------template--------------------------#
import os
import sys
# from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
ALPHA='abcdefghijklmnopqrstuvwxyz'
M=1000000007
EPS=1e-6
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
# vsInput()
def nCr(n, r, p=M):
num=1
den=1
for i in range(r):
num=(num * (n - i)) % p
den=(den * (i + 1)) % p
return (num * pow(den,p-2,p))%p
k=Int()
c=[]
for i in range(k):c.append(Int())
have_spaces=0
ans=1
for i in range(k):
have_spaces+=c[i]
possible=nCr(have_spaces-1,c[i]-1)
ans=(ans*possible)%M
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
long long int countFact(long long int n, long long int p) {
long long int k = 0;
while (n >= p) {
k += n / p;
n /= p;
}
return k;
}
long long int pow(long long int a, long long int b, long long int MOD) {
long long int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > MOD) x %= MOD;
}
y = (y * y);
if (y > MOD) y %= MOD;
b /= 2;
}
return x;
}
long long int InverseEuler(long long int n, long long int MOD) {
return pow(n, MOD - 2, MOD);
}
long long int factMOD(long long int n, long long int MOD) {
long long int res = 1;
while (n > 1) {
res = (res * pow(MOD - 1, n / MOD, MOD)) % MOD;
for (long long int i = 2, j = n % MOD; i <= j; i++) res = (res * i) % MOD;
n /= MOD;
}
return res;
}
long long int C(long long int n, long long int r, long long int MOD) {
if (countFact(n, MOD) > countFact(r, MOD) + countFact(n - r, MOD)) return 0;
return (factMOD(n, MOD) * ((InverseEuler(factMOD(r, MOD), MOD) *
InverseEuler(factMOD(n - r, MOD), MOD)) %
MOD)) %
MOD;
}
int main(int argc, char **argv) {
ios_base::sync_with_stdio(0);
long long int k, A[1005], r, ans;
cin >> k;
for (int(i) = 0; (i) < (k); ++(i)) cin >> A[i];
r = A[0] + 1;
ans = 1;
for (int(i) = (1); (i) <= (k - 1); ++(i)) {
ans = (ans * C(A[i] - 2 + r, r - 1, mod)) % mod;
r += A[i];
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int c[1000 + 5];
long long comb[1000 + 5][1000 + 5];
int main() {
comb[0][0] = 1;
for (int i = 1; i <= 1000; i++) {
comb[i][0] = 1;
for (int j = 1; j <= i; j++) {
comb[i][j] =
(long long)((comb[i - 1][j] + comb[i - 1][j - 1]) % 1000000007);
}
}
int k;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
scanf("%d", &c[i]);
}
long long ans = 1;
int sum = 0;
for (int i = 0; i < k; i++) {
ans = (ans * comb[sum + c[i] - 1][c[i] - 1]) % (long long)1000000007;
sum += c[i];
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long combin[1010][1010];
int main() {
combin[0][0] = 1;
for (int i = 1; i <= 1000; i++) {
combin[i][0] = 1;
for (int j = 1; j <= i; j++) {
combin[i][j] = (combin[i - 1][j] + combin[i - 1][j - 1]) % mod;
}
}
long long ans = 1, cnt = 0, k, x;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> x;
ans = (ans * combin[cnt + x - 1][x - 1]) % mod;
cnt += x;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 10;
const int MOD = 1e9 + 7;
const int dx[9] = {0, 1, -1, 0, 0, -1, -1, 1, 1};
const int dy[9] = {0, 0, 0, -1, 1, -1, 1, -1, 1};
const double pi = acos(-1.0);
int k, n = 0;
int c[MAXN][MAXN];
int main() {
c[0][0] = 1;
for (int i = 1; i <= 1000; i++) c[i][i] = 1, c[i][0] = 1;
for (int i = 1; i <= 1000; i++)
for (int j = 1; j <= 1000; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
if (c[i][j] >= MOD) c[i][j] -= MOD;
}
long long ans = 1;
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
int x;
scanf("%d", &x);
n += x;
ans = (ans * c[n - 1][x - 1]) % MOD;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1005;
const int MOD = 1e9 + 7;
int n, i, j, a[maxN];
long long Choose[maxN][maxN];
long long ans = 1, sum = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
Choose[0][0] = 1;
for (j = 0; j <= maxN - 5; j++) {
for (i = 0; i <= maxN - 5; i++) {
if (i == 0 || j == 0 || i == j) {
Choose[i][j] = 1;
} else if (i <= j) {
Choose[i][j] = Choose[i - 1][j - 1] + Choose[i][j - 1];
Choose[i][j] %= MOD;
}
}
}
for (i = 0; i < n; i++) {
sum += a[i];
sum %= MOD;
ans *= Choose[a[i] - 1][sum - 1];
ans %= MOD;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e3 + 10;
const long long MOD = 1e9 + 7;
long long dp[MAX][MAX];
long long ncr(long long n, long long k) {
long long& ret = dp[n][k];
if (ret != -1) return ret;
if (k == 0) return ret = 1;
if (k == n) return ret = 1;
return ret = (ncr(n - 1, k) + ncr(n - 1, k - 1)) % MOD;
}
long long arr[MAX], tot;
long long ways = 1;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
memset(dp, -1, sizeof(dp));
int k;
cin >> k;
for (int(i) = (0); (i) < (k); (i)++) {
cin >> arr[i];
tot += arr[i];
}
for (int i = k - 1; i >= 0; i--) {
long long temp = ncr(tot - 1, arr[i] - 1);
ways = (ways * temp) % MOD;
tot -= arr[i];
}
cout << (ways) << "\n";
;
}
| 9 | CPP |
__author__ = 'taras-sereda'
from pprint import pprint as pp
n = int(input())
maxn = 1000
mod = 1000000007
coef = [[0 for i in range(maxn)]for i in range(maxn)]
for i in range(maxn):
coef[i][0] = 1
for j in range(1, maxn):
coef[i][j] = (coef[i-1][j] + coef[i-1][j-1]) % mod
colors = [int(input()) for i in range(n)]
res = 1
total = 0
for i in range(n):
res = (res*coef[total+colors[i]-1][colors[i]-1]) % mod
total += colors[i]
print(res)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
long long int ans = 1;
while (y > 0) {
if (y % 2 != 0) {
ans = (ans * x) % 1000000007ll;
}
x = (x * x) % 1000000007ll;
y /= 2;
}
return (ans % 1000000007ll);
}
int main() {
long long int k, a[1010], i, j, ans = 0, sum = 0, x, dp[1010][1010];
cin >> k;
for (i = 1; i <= k; i++) {
cin >> a[i];
}
dp[0][0] = 1;
dp[0][1] = 1;
for (i = 1; i <= k; i++) {
for (j = 1; j <= a[i]; j++) {
if (j == 1)
dp[i][j] = dp[i - 1][a[i - 1]];
else
dp[i][j] = ((((dp[i][j - 1] % 1000000007ll) * (sum % 1000000007ll)) %
1000000007ll) *
(power(j - 1, 1000000007ll - 2))) %
1000000007ll;
sum++;
dp[i][j] %= 1000000007ll;
}
}
cout << dp[k][a[k]];
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long exp(long long a, long long b) {
long long ans = 1, apow = a;
while (b > 0) {
if (b % 2) ans = (ans * apow) % mod;
b /= 2;
apow = (apow * apow) % mod;
}
return ans;
}
long long fact[1001], invfact[1001];
int main() {
long long k, i, j;
long long n, p, ans, mul, ball, m;
fact[1] = 1;
invfact[1] = 1;
for (i = 2; i <= 1001; i++) {
fact[i] = (fact[i - 1] * i) % mod;
invfact[i] = exp(fact[i], mod - 2);
}
invfact[0] = 1;
scanf("%lld", &k);
ans = 1;
ball = 0;
for (i = 0; i < k; i++) {
scanf("%lld", &j);
p = 1;
for (m = ball + j - 1, n = 1; n <= j - 1; n++, m--) p = (p * m) % mod;
p = (p * invfact[j - 1]) % mod;
ans = (ans * p) % mod;
ball += j;
}
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int p[1005][1005], a[1005];
void pre() {
int i, j;
for (i = 0; i <= 1001; i++) {
for (j = 0; j <= i; j++) {
if (j == 0 || j == i)
p[i][j] = 1;
else
p[i][j] = (p[i - 1][j - 1] + p[i - 1][j] * 1LL) % 1000000007;
}
}
}
int main() {
int n, sum, i;
long long int ans;
cin >> n;
pre();
for (i = 0; i < n; i++) {
cin >> a[i];
}
sum = a[0];
ans = 1;
for (i = 1; i < n; i++) {
ans = ans * (p[sum + a[i] - 1][a[i] - 1]) % 1000000007;
sum += a[i];
}
cout << ans;
return 0;
}
| 9 | CPP |
pc = c = 0
res = 1
for i in range(int(input())):
pc += c
c = int(input())
for k in range(1, c):
res = res * (pc + c - k) // k
res %= 1000000007
print(res) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long c[1005], d[1005][1005], s[1005], dp[1005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> c[i];
s[0] = 1;
for (int i = 1; i <= 1000; ++i) {
d[i][1] = 1;
s[i] = s[i - 1] + 1;
}
for (int j = 2; j <= 1000; ++j) {
d[0][j] = 1;
for (int i = 1; i <= 1000; ++i) {
d[i][j] = s[i];
s[i] = (s[i - 1] + d[i][j]) % 1000000007;
}
}
long long sum = c[0];
dp[0] = 1;
for (int i = 1; i < n; ++i) {
dp[i] = (dp[i - 1] * d[c[i] - 1][sum + 1]) % 1000000007;
sum += c[i];
}
cout << dp[n - 1] % 1000000007;
}
| 9 | CPP |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.