solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
long long int c[1002][1002], w[1002];
int main() {
ios_base::sync_with_stdio(false);
int i, j, k, n;
cin >> n;
c[0][0] = 1;
for (i = 1; i <= 1000; i++) {
c[i][0] = 1;
for (j = 1; j <= i; j++) {
c[i][j] = (c[i - 1][j] % 1000000007 + c[i - 1][j - 1] % 1000000007) %
1000000007;
}
}
long long int b = 0;
for (i = 1; i <= n; i++) {
cin >> w[i];
b += w[i];
}
long long int res = 1;
for (i = n; i >= 1; i--) {
res = ((res % 1000000007) * (c[b - 1][w[i] - 1] % 1000000007)) % 1000000007;
b = b - w[i];
}
cout << res;
}
| 9 | CPP |
#include <bits/stdc++.h>
int c[1001];
long long fact[1001];
long long rfact[1001];
long long ppp(long long x, long long p) {
if (p == 0) return 1;
if (p % 2) {
return (ppp(x, p - 1) * x) % 1000000007;
} else {
long long half = ppp(x, p / 2);
return (half * half) % 1000000007;
}
}
long long ccc(long long top, long long bottom) {
return (((fact[top] * rfact[top - bottom]) % 1000000007) * rfact[bottom]) %
1000000007;
}
int main() {
fact[0] = 1;
rfact[0] = 1;
for (int i = 1; i <= 1000; i++) {
fact[i] = (fact[i - 1] * i) % 1000000007;
rfact[i] = ppp(fact[i], 1000000005);
}
int k;
std::cin >> k;
for (int i = 1; i <= k; i++) {
std::cin >> c[k + 1 - i];
}
long long low = c[k];
long long p = 1;
long long top = c[k - 1] + c[k] - 1;
long long bottom = c[k];
for (int i = 2; i <= k; i++) {
long long pp = ccc(top, bottom);
p = (p * pp) % 1000000007;
top += c[k - i];
bottom += c[k - i + 1];
}
std::cout << p << std::endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long C[1001][1001];
const int mod = 1e9 + 7;
void calc() {
for (int i = 0; i < 1001; i++) C[i][0] = C[i][i] = 1;
for (int i = 1; i < 1001; i++)
for (int j = 1; j < i; j++)
C[i][j] = ((C[i - 1][j - 1] % mod) + (C[i - 1][j] % mod)) % mod;
}
int main() {
ios::sync_with_stdio(false);
calc();
int n;
cin >> n;
vector<long long> v;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
}
long long cnt = v[0];
long long res = 1;
for (int i = 1; i < n; i++) {
cnt += v[i];
res = (res * C[cnt - 1][v[i] - 1]) % mod;
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#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 n, long long p) {
if (p == 0) return 1;
if (p == 1) return n;
long long b = fast_pow(n, p / 2);
if (p % 2) return (((b * b) % 1000000007) * n) % 1000000007;
return (b * b) % 1000000007;
}
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 |
#include <bits/stdc++.h>
using namespace std;
long long gt[1000001 + 1];
long long power(long long a, long long n, long long m) {
long long cur = a, ans = 1;
while (n) {
if (n % 2) ans = ans * cur % m;
cur = cur * cur % m;
n /= 2;
}
return ans;
}
long long inv(long long a, long long m) { return power(a, m - 2, m); }
long long C(long long k, long long n) {
return gt[n] * inv(gt[k], 1000000007) % 1000000007 *
inv(gt[n - k], 1000000007) % 1000000007;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long a[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i];
long long ans = 1, cur = a[1];
gt[0] = 1;
for (int i = 1; i <= 1000001; i++) gt[i] = gt[i - 1] * i % 1000000007;
for (int i = 2; i <= n; i++) {
ans *= C(cur, a[i] - 1 + cur);
ans %= 1000000007;
cur += a[i];
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long yht[1111][1111];
int col[1111];
int main() {
yht[0][1] = 1;
for (int i = 1; i <= 1000; i++)
for (int j = 1; j <= i; j++)
yht[i][j] = (yht[i - 1][j - 1] + yht[i - 1][j]) % mod;
int k;
scanf("%d", &k);
int sum = 0;
for (int i = 1; i <= k; i++) {
cin >> col[i];
sum += col[i];
}
long long ans = 1;
for (int i = k; i >= 1; i--) {
ans = ans * yht[sum][col[i]] % mod;
sum -= col[i];
}
printf("%I64d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long vis[1005][1005];
int num[1005];
int main() {
vis[0][0] = 1;
vis[1][0] = 1;
vis[1][1] = 1;
for (int i = 2; i <= 1000; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
vis[i][j] = 1;
else
vis[i][j] = (vis[i - 1][j] + vis[i - 1][j - 1]) % mod;
}
}
int n;
int sum = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &num[i]);
sum += num[i];
}
long long ans = 1;
for (int i = n - 1; i >= 0; i--) {
ans = (ans * vis[sum - 1][num[i] - 1]) % mod;
sum = sum - num[i];
}
printf("%lld\n", ans % mod);
return 0;
}
| 9 | CPP |
k = int(input())
c = [int(input()) for i in range(k)]
mod, ans, s= 1000000007, 1, 0
ri = [0, 1]
for i in range(2, 1000010):
ri.append((mod//i) * (mod-ri[mod%i])%mod);
for p in c:
for i in range(1, p):
ans = ans * (s + i) * ri[i] % mod
s += p
print(ans)
| 9 | PYTHON3 |
mod = 1_000_000_007
def C(n, r):
if r > n - r:
r = n - r
val = 1
for i in range(1, r + 1):
val *= n - r + i
val //= i
return val % mod
n = int(input())
a = []
for _ in range(n):
a.append(int(input()))
z = [0 for _ in range(n)]
cum = 0
val = 1
for i in range(n):
cum += a[i]
val *= C(cum - 1, a[i] - 1)
val %= mod
print(val)
| 9 | PYTHON3 |
MOD = 10**9+7
import os
import math
def combination(n,k):
return (math.factorial(n)//math.factorial(k)//math.factorial(n-k))%MOD
def main():
k = int(input().strip())
a=[]
for i in range(k):
a.append(int(input().strip()))
dp = [1]
used=a[0]
for i in range(1,k):
used+=a[i]
dp.append((dp[i - 1] * combination(used - 1, a[i] - 1))%MOD)
print(dp[-1])
if __name__ == "__main__":
main()
"""
3
2
2
1
4
1
2
3
4
"""
| 9 | PYTHON3 |
k=int(input())
l=[int(input()) for i in range(k)]
MOD=10**9+7
fact=[0]*(10**6+5)
fact[0]=1
for i in range(1,10**6+5):
fact[i]=(fact[i-1]%MOD*i%MOD)%MOD
def MI(a,MOD):
return pow(a,MOD-2,MOD)
def c(n, k):
if n==k or k==0:
return 1
if n<k:
return 0
return (fact[n]*MI(fact[k],MOD)%MOD*MI(fact[n-k],MOD)%MOD)%MOD
ans=1
sm=l[0]
for i in range(1,k):
curr=l[i]
ans=ans*(c(sm+curr-1,curr-1))
ans%=MOD
sm+=l[i]
print(ans) | 9 | PYTHON3 |
from math import factorial
n = int(input())
ans = 1
s = 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>
using namespace std;
int c[1005][1005];
int a[1005];
int main() {
int i, j, k;
c[1][0] = c[1][1] = 1;
for (i = 2; i < 1005; i++) {
c[i][0] = 1;
for (j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
scanf("%d", &k);
int x, sum = 0;
for (i = 1; i <= k; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
long long res = 1;
for (i = k; i > 1; i--) {
res = (res * (long long)c[sum - 1][a[i] - 1]) % 1000000007;
sum -= a[i];
}
cout << res << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long nCr[1010][1010];
int main() {
nCr[0][0] = 1;
for (int i = 1; i < 1010; ++i) {
nCr[i][0] = 1;
for (int j = 1; j <= i; ++j)
nCr[i][j] = (nCr[i - 1][j] + nCr[i - 1][j - 1]) % 1000000007;
}
int k;
cin >> k;
long long n = 0, ans = 1;
while (k--) {
int tmp;
cin >> tmp;
ans *= nCr[n + tmp - 1][tmp - 1];
ans %= 1000000007;
n += tmp;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
t = 10**9 + 7
comb = [[0 for i in range(1001)]for i in range(1001)]
comb[0][0] = 1
for i in range(1, 1001):
comb[i][0] = 1
for j in range(1, i + 1):
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % t
ans = 1
f = 0
for _ in range(int(input())):
c = int(input())
ans = (ans * comb[f + c - 1][c - 1]) % t
f += c
print(ans % t) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int T = 1001;
int C[T], DP[T], KP[T][T];
int main() {
long long k, j = -1, mod = 1000000007, tmp = 1, th = 0;
for (int i = 0; i < T; i++) {
KP[i][0] = 1;
for (int j = 1; j < i + 1; j++) {
KP[i][j] = (KP[i - 1][j] + KP[i - 1][j - 1]) % mod;
}
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> C[i];
j += C[i];
}
for (int i = 0; i < k; i++) {
th += C[i];
tmp *= KP[th - 1][C[i] - 1];
tmp %= mod;
}
cout << tmp;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 1;
vector<vector<long long int> > v(1005);
int i, j;
for (i = 0; i <= 1000; i++) {
j = 0;
while (j <= i) {
if (j == 0 || i == j) {
v[i].push_back(a);
} else {
v[i].push_back((v[i - 1][j] + v[i - 1][j - 1]) % 1000000007);
}
j++;
}
}
long long int k, n1, var1, var2, x;
long long int ans = 1;
cin >> k;
cin >> n1;
var1 = n1 - 1;
if (k == 1) {
cout << ans << endl;
} else {
for (i = 1; i < k; i++) {
cin >> x;
var1 = var1 + x;
var2 = x - 1;
ans = (ans * (v[var1][var2])) % 1000000007;
}
cout << ans << endl;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a1[1001][1001];
int main() {
for (int i = 0; i < 1001; ++i) a1[i][0] = 1;
for (int i = 1; i < 1001; ++i)
for (int j = 1; j <= i; ++j)
a1[i][j] = (a1[i - 1][j - 1] + a1[i - 1][j]) % 1000000007;
int n, k, a, b;
long long o = 1;
scanf("%d%d", &n, &a);
for (int i = 1; i < n; ++i, a += b) {
scanf("%d", &b);
o = o * a1[a + b - 1][b - 1] % 1000000007;
}
printf("%d\n", o);
}
| 9 | CPP |
from math import *
from collections import deque
from copy import deepcopy
import sys
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def multi(): return map(int,input().split())
def strmulti(): return map(str, inp().split())
def lis(): return list(map(int, inp().split()))
def lcm(a,b): return (a*b)//gcd(a,b)
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def stringlis(): return list(map(str, inp().split()))
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def printlist(a) :
print(' '.join(str(a[i]) for i in range(len(a))))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#copied functions end
#start coding
k=int(input())
ans=1
sum=0
for i in range(k):
num=int(input())
sum+=num
ans*=(ncr(sum-1,num-1))
# print(ans)
print(ans%1000000007)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 1005;
long long dp[N][N];
long long arr[N];
int main() {
for (int i = 1; i < N; ++i) {
dp[i][0] = 1;
for (int j = 1; j <= i; ++j) {
if (i == j)
dp[i][j] = 1;
else if (i > j)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % MOD;
}
}
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> arr[i];
long long ans = 1, sum = arr[1];
for (int i = 2; i <= n; ++i) {
sum += arr[i];
ans = (ans * dp[sum - 1][arr[i] - 1]) % MOD;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
k, mod, top = int(input()), 1000000007, 1000
c = [ int(input()) for _ in range(k) ]
ncr = [ [0] * top for _ in range(top) ] # rotates pascal lol
ncr[0][0] = 1
for n in range(1, top):
ncr[n][0] = 1
for r in range(top):
ncr[n][r] = (ncr[n - 1][r] + ncr[n - 1][r - 1]) % mod
ways, colors = 1, 0
for i in range(k):
ways = ( ways * ncr[ colors + c[i] - 1 ][ c[i] - 1 ] ) % mod
colors += c[i]
print(ways) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long dp[1005][1005];
int k;
int c[1002];
int main() {
cin >> k;
int n = 0;
for (int i = 1; i <= k; i++) {
cin >> c[i];
n += c[i];
}
dp[0][0] = 1;
for (int i = 0; i <= n; i++) {
dp[i][0] = 1;
for (int j = 1; j <= i; j++) {
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % mod;
}
}
int cb = 0;
long long ans = 1;
for (int i = 1; i <= k; i++) {
ans = (ans * dp[cb + c[i] - 1][c[i] - 1]) % mod;
cb += c[i];
}
cout << ans << endl;
return 0;
}
| 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 long long m = 1000 * 1000 * 1000 + 7, maxN = 1000 + 10;
long long p[maxN];
long long dp[maxN];
long long a[maxN];
long long se[maxN][maxN];
int main() {
for (int i = 0; i < 1000; i++) {
se[i][i] = 1;
se[i][0] = 1;
}
for (int i = 2; i < 1000; i++) {
for (int j = 1; j < i; j++) {
se[i][j] = (se[i - 1][j] + se[i - 1][j - 1]) % m;
}
}
int n;
cin >> n;
p[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
p[i] = p[i - 1] + a[i];
}
for (int i = n; i > 0; i--) {
dp[i] = (se[p[i] - 1][a[i] - 1]) % m;
}
dp[0] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = (dp[i - 1] * dp[i]) % m;
}
cout << dp[n];
return 0;
}
| 9 | CPP |
import sys
input = sys.stdin.readline
MAX = 1010
MOD = 10**9+7
fact = [0]*MAX #fact[i]: i!
inv = [0]*MAX #inv[i]: iの逆元
finv = [0]*MAX #finv[i]: i!の逆元
fact[0] = 1
fact[1] = 1
finv[0] = 1
finv[1] = 1
inv[1] = 1
for i in range(2, MAX):
fact[i] = fact[i-1]*i%MOD
inv[i] = MOD-inv[MOD%i]*(MOD//i)%MOD
finv[i] = finv[i-1]*inv[i]%MOD
def C(n, r):
if n<r:
return 0
if n<0 or r<0:
return 0
return fact[n]*(finv[r]*finv[n-r]%MOD)%MOD
k = int(input())
c = [int(input()) for _ in range(k)]
s = sum(c)
acc = 0
p = [0]*(s+1)
p[0] = 1
for ci in c:
np = [0]*(s+1)
p_acc = p[0]
for i in range(1, s+1):
np[i] = (p_acc*C(i-acc-1, ci-1))%MOD
p_acc += p[i]
acc += ci
p = np
print(p[s]) | 9 | PYTHON3 |
from heapq import heapify, heappush, heappop
from collections import Counter, defaultdict, deque, OrderedDict
from sys import setrecursionlimit, maxsize
from bisect import bisect_left, bisect, insort_left, insort
from math import ceil, log, factorial, hypot, pi
from fractions import gcd
from copy import deepcopy
from functools import reduce
from operator import mul
from itertools import product, permutations, combinations, accumulate, cycle
from string import ascii_uppercase, ascii_lowercase, ascii_letters, digits, hexdigits, octdigits
prod = lambda l: reduce(mul, l)
prodmod = lambda l, mod: reduce(lambda x, y: mul(x,y)%mod, l)
def read_list(t): return [t(x) for x in input().split()]
def read_line(t): return t(input())
def read_lines(t, N): return [t(input()) for _ in range(N)]
mod = 10**9+7
def inv(x):
return pow(x, mod-2, mod)
K = read_line(int)
balls = read_lines(int, K)
s = balls[0]
ans = 1
for ball in balls[1:]:
ans *= ball
ans %= mod
for i in range(s+1, s+ball):
ans *= i
ans %= mod
for i in range(ball):
ans *= inv(i+1)
ans %= mod
s += ball
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
template <class T>
T sabs(T x) {
if (x < 0)
return x * -1;
else
return x;
}
template <class T>
T sgcd(T x, T y) {
if (y == 0)
return x;
else
return sgcd(y, x % y);
}
template <class T>
T smax(T x, T y) {
if (x > y)
return x;
else
return y;
}
template <class T>
T smin(T x, T y) {
if (x > y)
return y;
else
return x;
}
template <class T>
T smod(T a, T b, T m) {
T res = 1, x = b;
while (b > 0) {
if (x & 1) res = ((res % m) * (x % m)) % m;
x = (x * x) % m;
b = (b >> 1);
}
return res;
}
using namespace std;
inline void writeInt(int x) {
if (x == -1) {
putchar('-');
putchar('1');
putchar('\n');
} else {
int i = 10;
char buf[11];
buf[10] = ' ';
do {
buf[--i] = x % 10 + '0';
x /= 10;
} while (x);
do {
putchar(buf[i]);
} while (buf[i++] != ' ');
}
}
inline void fastInput(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
long long int MOD = 1e9 + 7;
int dp[1005][1005];
void init() {
for (int i = 0; i <= 1000; i++) {
dp[i][0] = 1;
dp[0][i] = 0;
}
dp[0][0] = 1;
for (int i = 1; i <= 1000; i++) {
for (int j = 1; j <= i; j++) {
long long int term = dp[i - 1][j] + dp[i - 1][j - 1];
term %= MOD;
dp[i][j] = term;
}
}
}
int main() {
init();
int a, k;
long long int ans = 1, res = 0;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a;
res += a;
ans *= dp[res - 1][a - 1];
ans %= MOD;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
import math
def euclid_algorithm(a, b):
t1, t2 = abs(a), abs(b)
#saving equalities:
#t1 == x1 * a + y1 * b,
#t2 == x2 * a + y2 * b.
x1, y1, x2, y2 = int(math.copysign(1, a)), 0, 0, int(math.copysign(1, b))
if t1 < t2:
t1, t2 = t2, t1
x1, y1, x2, y2 = x2, y2, x1, y1
while t2 > 0:
if x1 * a + y1 * b != t1:
print('inshalla')
k = int(t1 // t2)
t1, t2 = t2, t1 % t2
#t1 - k * t2 == (x1 - k * x2) * a + (y1 - k * y2) * b
x1, y1, x2, y2 = x2, y2, x1 - k * x2, y1 - k * y2
return t1, x1, y1
def opposite_element(x, p):
gcd, k, l = euclid_algorithm(x, p)
if gcd != 1:
return -1
return k % p
def fact_mod(n, p):
prod = 1
for i in range(2,n+1):
prod *= i
prod %= p
return prod
k = int(input())
c = []
for i in range(k):
c.append(int(input()))
prefix_sum = 0
p = 10 ** 9 + 7
denominator = 1
for c_i in c:
denominator *= fact_mod(c_i - 1, p)
denominator %= p
prefix_sum += c_i
denominator *= prefix_sum
denominator %= p
numenator = fact_mod(prefix_sum, p)
print(numenator * opposite_element(denominator, p) % p)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
scanf("%d", &k);
;
int sum = 0, x;
long long int C[1010][1010];
for (int i = 0; i < 1010; i++) {
C[i][0] = C[i][i] = 1;
}
for (int i = 1; i < 1010; i++) {
for (int j = 1; j < i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
C[i][j] %= 1000000007;
}
}
long long int ans = 1;
for (int i = 0; i < k; i++) {
scanf("%d", &x);
;
sum += x;
ans *= C[sum - 1][x - 1];
ans %= 1000000007;
}
cout << ans << "\n";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
const int mod = 1e9 + 7;
int nCk[MAXN][MAXN];
inline int Add(int a, int b) { return (a + b) % mod; }
inline int Mult(int a, int b) { return (int)(((long long)a * b) % mod); }
int Povrh(int n, int k) { return nCk[n][k]; }
void Init() {
nCk[0][0] = 1;
for (int i = 1; i < MAXN; i++) {
nCk[i][0] = 1;
for (int j = 1; j <= i; j++) {
nCk[i][j] = Add(nCk[i - 1][j], nCk[i - 1][j - 1]);
}
}
}
int k;
int arr[MAXN];
int sol = 1;
int main() {
Init();
scanf("%d", &k);
for (int i = 0; i < k; i++) scanf("%d", &arr[i]);
int len = 0;
for (int i = 0; i < k; i++) {
sol = Mult(sol, Povrh(len + arr[i] - 1, arr[i] - 1));
len = Add(len, arr[i]);
}
printf("%d\n", sol);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long found[1005];
long long qpow(long long a, long long b) {
a = a % mod;
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
found[1] = 1;
for (int i = 2; i <= 1000; ++i) {
found[i] = found[i - 1] * i % mod;
}
int n, now;
long long res = 1;
int cnt = 1;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> now;
if (now >= 2) res = qpow(found[now - 1], mod - 2) * res % mod;
for (int j = 0; j < now - 1; ++j) {
res = res * cnt % mod;
++cnt;
}
++cnt;
}
cout << res;
return 0;
}
| 9 | CPP |
from math import factorial
n = int(input())
c = [int(input()) for _ in range(n)]
r, s = 1, 0
for i in range(n):
r *= factorial(s+c[i]-1) // factorial(s) // factorial(c[i]-1)
r %= 1000000007
s += c[i]
print(r)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long dp[1005][1005];
int n;
cin >> n;
dp[0][0] = 1;
for (int i = 1; i < 1005; ++i) {
dp[i][0] = 1;
for (int j = 1; j <= i; ++j)
dp[i][j] = (dp[i - 1][j] + dp[i - 1][j - 1]) % 1000000007;
}
long long arr[n + 1];
long long sum = 0;
long long a = 1;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
a = (a * dp[sum + arr[i] - 1][arr[i] - 1]) % 1000000007;
sum += arr[i];
}
cout << a << '\n';
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int cnt[1005];
long long c[1005][1005];
int main() {
c[0][0] = c[1][0] = c[1][1] = 1;
for (int i = 2; i <= 1000; i++) {
for (int j = 0; j <= i; j++) {
if (i == 0 || i == j)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007;
}
}
int k;
cin >> k;
for (int i = 1; i <= k; i++) {
int t;
cin >> cnt[i];
}
long long ans = 1;
int cs = 0;
for (int i = 1; i <= 1000; i++) {
if (cnt[i]) {
ans = (ans * c[cs + cnt[i] - 1][cnt[i] - 1]) % 1000000007;
cs += cnt[i];
}
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ch[1001][1001];
int main() {
for (int i = 0; i < 1001; i++) ch[i][0] = 1;
for (int i = 0; i < 1001; i++) {
for (int j = 1; j < 1001; j++) {
if (i < j) {
ch[i][j] = 0;
continue;
}
ch[i][j] = ch[i - 1][j] + ch[i - 1][j - 1];
ch[i][j] %= 1000000007;
}
}
int k;
cin >> k;
vector<int> a(k);
int n = 0;
for (int i = 0; i < k; i++) {
cin >> a[i];
n += a[i];
}
long long r = 1;
long long sm = 0;
for (int i = k - 1; i >= 0; i--) {
r *= ch[n - 1][a[i] - 1];
r %= 1000000007;
n -= a[i];
}
cout << r << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long k;
cin >> k;
long long arr[k];
for (auto &x : arr) cin >> x;
long **dp = new long *[1001];
for (auto i = (0); i <= (1000); i++) dp[i] = new long[1001];
long long mod = 1e9 + 7;
for (auto i = (0); i <= (1000); i++) {
for (auto j = (0); j <= (i); j++) {
if (j == 0 || j == i)
dp[i][j] = 1;
else
dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % mod;
}
}
long long x[2];
x[1] = 1;
long long tc = arr[0];
for (auto i = (2); i <= (k); i++) {
tc += arr[i - 1];
x[i % 2] = (x[(i - 1) % 2] * dp[tc - 1][arr[i - 1] - 1] % mod) % mod;
}
cout << x[k % 2];
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ncr[1001][1001];
long long mod = 1e9 + 7;
int main(void) {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int c[1001];
for (int i = 0; i < n; ++i) cin >> c[i];
for (int i = 0; i < 1001; ++i) {
for (int j = 0; j <= i; ++j) {
if (i == 0 || i == j || j == 0)
ncr[i][j] = 1;
else {
ncr[i][j] = (ncr[i - 1][j] + ncr[i - 1][j - 1]) % mod;
}
}
}
long long int ans = 1;
long long int total = c[0];
for (int i = 1; i < n; ++i) {
ans = (ans * ncr[total + c[i] - 1][c[i] - 1]) % mod;
total += c[i];
}
cout << ans;
return 0;
}
| 9 | CPP |
from math import factorial as f
n, ans, sm, mod = map(int, input().split() + [1, 0, 1000000007])
def ncr(x, y):
return f(x) // (f(y) * f(x - y))
for _ in range(n):
x = int(input())
ans = (ans * ncr(sm + x - 1, x - 1)) % mod
sm += x
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, tu[1001], mod = 1000000007, fac[9000];
long long qpow(long long a, long long b) {
long long ans = 1;
a %= mod;
for (long long i = b; i; i >>= 1, a = a * a % mod)
if (i & 1) ans = ans * a % mod;
return ans;
}
long long C(long long n, long long m) {
if (m > n || m < 0) return 0;
long long s1 = fac[n], s2 = fac[n - m] * fac[m] % mod;
return s1 * qpow(s2, mod - 2) % mod;
}
int main() {
fac[0] = 1;
for (long long a = 1; a <= 1000; a++) fac[a] = fac[a - 1] * a % mod;
cin >> n;
for (long long a = 1; a <= n; a++) cin >> tu[a];
long long zhonglei = 1, he = tu[1];
for (long long a = 2; a <= n; a++) {
he += tu[a];
zhonglei *= C(he - 1, tu[a] - 1) % mod;
zhonglei %= mod;
}
cout << zhonglei;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long ans = 1;
long long exp(long long taban, long long us, long long md) {
long long carpan = taban % md;
if (carpan == 0) return 0;
long long temp = us;
long long res = 1;
while (temp) {
if (temp % 2) res = (res * carpan) % md;
temp /= 2;
carpan = (carpan * carpan) % md;
}
return res;
}
vector<long long> fact;
vector<long long> inv_fact;
void fact_init(int n) {
fact.resize(n + 5);
inv_fact.resize(n + 5);
fact[0] = inv_fact[0] = 1;
for (int i = 1; i <= n; i++) {
fact[i] = (fact[i - 1] * i) % 1000000007;
inv_fact[i] = exp(fact[i], 1000000007 - 2, 1000000007);
}
}
long long komb(long long a, long long b) {
if (a < b) return 0;
return fact[a] * (inv_fact[a - b] * inv_fact[b] % 1000000007) % 1000000007;
}
int main() {
fact_init(1005);
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int sum = arr[0];
for (int i = 1; i < n; i++) {
sum += arr[i];
ans *= komb((sum - 1), arr[i] - 1);
ans = ans % 1000000007;
}
cout << ans;
return 0;
}
| 9 | CPP |
from math import *
n = int(input())
k1 = int(input())
last_vars = 1
num_pos = k1
for i in range(n-1):
ki = int(input())
num_pos += ki
ki -= 1
Cnk = 1
for k in range(num_pos-ki,num_pos):
Cnk *= k
Cnk //= factorial(ki)
last_vars *= Cnk
print(last_vars%1000000007) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long C(long long int n, long long int r, long long int MOD) {
vector<vector<long long> > C(n + 1, vector<long long>(r + 1, 0));
for (int i = 0; i <= n; i++) {
for (int k = 0; k <= r && k <= i; k++)
if (k == 0 || k == i)
C[i][k] = 1;
else
C[i][k] = (C[i - 1][k - 1] + C[i - 1][k]) % MOD;
}
return C[n][r];
}
int main() {
long long int i, j, k;
cin >> k;
long long int a[k], b[k];
for (i = 0; i < k; i++) {
cin >> a[i];
}
b[0] = 1;
long long int sum = a[0];
for (i = 1; i < k; i++) {
sum = sum + a[i];
b[i] = C(sum - 1, a[i] - 1, 1000000007);
}
long long int ans = 1;
for (i = 0; i < k; i++) {
ans = ans * b[i];
if (ans >= 1000000007) ans = ans % 1000000007;
}
cout << ans << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long di = (1e9) + 7;
long long arr[1111], ar[1111];
long long gcd(long long a, long long b) {
long long c;
while (b) {
c = a % b;
a = b;
b = c;
}
return a;
}
int main() {
long long a, b, c, d, e, f, g, h;
cin >> a;
e = f = 0;
g = 0;
for (d = 0; d < a; d++) {
cin >> c;
g += c;
if (d) {
for (int i = g - c + 1, j = 1; i < g; i++, j++) {
arr[e++] = i;
ar[f++] = j;
}
}
}
for (d = 0; d < f; d++) {
c = ar[d];
for (int i = 0; i < e && c > 1; i++) {
g = gcd(c, arr[i]);
c /= g;
arr[i] /= g;
}
}
for (d = 0, g = 1; d < e; d++) {
g *= arr[d];
g %= di;
}
cout << g << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const int MAXN = 1010;
int K;
long long c[1005];
template <class T>
vector<vector<T> > pascal_triangle_mod(T n, T mod) {
vector<vector<T> > f = vector<vector<T> >(n);
f[0].push_back(1);
for (int i = 1; i < n; ++i) {
f[i] = vector<T>(i + 1);
f[i][0] = 1;
for (int j = 1; j < i; ++j) {
f[i][j] = f[i - 1][j] + f[i - 1][j - 1];
if (f[i][j] > mod) {
f[i][j] -= mod;
}
}
f[i][i] = 1;
}
return f;
}
vector<vector<long long> > ans;
int main() {
ios_base::sync_with_stdio(false);
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
cin >> K;
for (int i = 0; i < K; i++) cin >> c[i];
ans = pascal_triangle_mod<long long>((long long)1200, MOD);
long long res = 1;
int bask = 0;
int ball = 0;
for (int i = 0; i < K; i++) {
bask += 1;
ball = c[i] - 1;
res *= ans[ball + bask - 1][bask - 1];
if (res >= MOD) res %= MOD;
bask += (c[i] - 1);
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int maxn = 1005;
int N;
int c[maxn];
long long int pov[maxn][maxn];
long long int dp[maxn];
void rijesi() {
pov[0][0] = 1;
for (int n = 1; n < maxn; n++) {
pov[n][0] = 1;
for (int k = 1; k <= n; k++) {
pov[n][k] = pov[n - 1][k - 1] + pov[n - 1][k];
pov[n][k] %= mod;
}
}
dp[0] = 1;
int ukupno = c[0];
for (int i = 1; i < N; i++) {
dp[i] = dp[i - 1] * pov[ukupno + c[i] - 1][c[i] - 1];
dp[i] %= mod;
ukupno += c[i];
}
printf("%I64d\n", dp[N - 1]);
}
void ucitaj() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &c[i]);
}
int main(void) {
ucitaj();
rijesi();
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
const long long MOD = 1000000007;
int cnt[MAXN];
long long fac[MAXN], ans = 1;
long long POW(long long exp, long long power) {
if (power == 0) return 1;
long long ansP = POW(exp, power / 2);
ansP = ansP * ansP % MOD;
if (power % 2 == 1) ansP = ansP * exp % MOD;
return ansP;
}
long long C(long long n, long long r) {
long long ansC = (fac[n] * (POW(fac[r] * fac[n - r] % MOD, MOD - 2))) % MOD;
return ansC;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fac[0] = 1;
fac[1] = 1;
for (int i = 2; i < MAXN; i++) {
fac[i] = i * fac[i - 1] % MOD;
}
int k;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> cnt[i];
}
int length = cnt[0];
for (int i = 1; i < k; i++) {
ans *= C(cnt[i] + length - 1, length);
ans %= MOD;
length += cnt[i];
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXK = 1005;
const int MOD = 1e9 + 7;
int k, col[MAXK];
long long sum, res, f[MAXK], c[MAXK][MAXK];
long long nhan(long long a, long long b) {
a = a % MOD;
if (a <= 1 || b <= 1) return (a * b) % MOD;
return (nhan(a * 2, b / 2) + a * (b % 2)) % MOD;
}
int main() {
cin >> k;
for (int i = 1; i <= k; i++) cin >> col[i];
for (int i = 0; i <= 1001; i++) c[i][0] = 1;
for (int i = 1; i <= 1001; i++)
for (int j = 1; j <= 1001; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
f[1] = 1;
sum = col[1];
for (int i = 2; i <= k; i++) {
sum += col[i];
f[i] = nhan(f[i - 1], c[sum - 1][col[i] - 1]);
}
cout << f[k];
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long c[1001][1001];
long long md = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (long long i = 0; i < 1001; i++) {
for (long long j = 0; j <= i; j++) {
if (i == j || j == 0) {
c[i][j] = 1;
} else
c[i][j] = ((c[i - 1][j] % md) + (c[i - 1][j - 1] % md)) % md;
}
}
long long n;
cin >> n;
long long sum = 0;
long long ans = 1;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
ans = ((ans % md) * (c[sum + x - 1][x - 1] % md)) % md;
sum += x;
}
cout << ans % md << endl;
}
| 9 | CPP |
from math import factorial
n = int(input())
ans = 1
s = 0
mod = (10**9) + 7
for i in range(n):
a = int(input())
ans *= factorial(s+a-1)//(factorial(s) * factorial(a-1))
ans = ans%mod
s += a
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
const int N = 2000;
const long long MOD = 1e9 + 7;
long long C[N][N];
int num[N];
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] + C[i - 1][j - 1];
while (C[i][j] >= MOD) {
C[i][j] -= MOD;
}
}
}
int k;
scanf("%d", &k);
for (int i = 1; i <= k; i++) {
scanf("%d", &num[i]);
}
long long ans = 1;
long long cnt = num[1];
for (int i = 2; i <= k; i++) {
ans = (ans * C[cnt + num[i] - 1][num[i] - 1]) % MOD;
cnt += num[i];
}
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int const MOD = 1000000007, MAX = 10000;
int binomialCoeff(int n, int k) {
int C[n + 1][k + 1];
int i, j;
for (i = 0; i <= n; i++) {
for (j = 0; j <= min(i, k); j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = (((C[i - 1][j - 1] % MOD) + (C[i - 1][j] % MOD)) % MOD);
}
}
return C[n][k];
}
int main() {
int s = 0;
vector<int> sumas, val;
int n;
scanf("%d", &n);
long long memo[n + 1];
memset(memo, 0, sizeof(memo));
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
s += x;
sumas.push_back(s);
val.push_back(x);
}
memo[0] = 1;
for (int i = 1; i < n; i++) {
int cn = sumas[i] - 1;
int ck = val[i] - 1;
memo[i] = (((memo[i - 1] % MOD) * (binomialCoeff(cn, ck) % MOD)) % MOD);
}
printf("%d\n", memo[n - 1]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 7;
const int M = 4e5;
const int lim = 1e3;
const int p = 1e9 + 7;
const int inf = 0x3f3f3f3f;
long long inv[N], fac[N], a[N];
void init() {
fac[0] = inv[0] = inv[1] = 1;
for (long long i = 1; i <= lim; i++) fac[i] = fac[i - 1] * i % p;
for (long long i = 2; i <= lim; i++) inv[i] = (p - p / i) * inv[p % i] % p;
for (long long i = 1; i <= lim; i++) inv[i] = inv[i - 1] * inv[i] % p;
}
long long C(int n, int m) { return fac[n] * inv[m] % p * inv[n - m] % p; }
int main() {
init();
int n, sum = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
sum += a[i];
}
long long ans = 1;
for (int i = n - 1; i >= 0; i--) {
ans = (ans * C(sum - 1, a[i] - 1)) % p;
sum -= a[i];
}
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7FFFFFFF;
const int MOD = 1000000000 + 7;
const double EPS = 1e-10;
const double PI = 2 * acos(0.0);
const int maxn = 1000 + 66;
int cnt[maxn];
long long C[maxn][maxn];
void GetComMod(long long val, long long mod) {
memset(C, 0, sizeof(C));
for (long long i = 0; i <= val; i++) {
for (long long j = 0; j <= i; j++) {
if (!j || i == j)
C[i][j] = 1 % mod;
else
C[i][j] = (C[i - 1][j - 1] % mod + C[i - 1][j] % mod) % mod;
}
}
C[0][0] = 0 % mod;
}
int main() {
GetComMod(1000 + 2, MOD);
int k;
cin >> k;
for (int i = 1; i <= k; i++) cin >> cnt[i];
long long res = 1, tempsum = cnt[1];
for (int i = 2; i <= k; i++) {
res = (res % MOD * C[tempsum + cnt[i] - 1][cnt[i] - 1]) % MOD;
tempsum += cnt[i];
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long double min(long double a, long double b) {
if (a < b) return a;
return b;
}
inline long double max(long double a, long double b) {
if (a < b) return b;
return a;
}
int n;
int k;
int arr[1100];
long long res;
int main() {
int f[1111][1111];
cin >> k;
for (int(i) = (0); (i) < (k); ++(i)) {
cin >> arr[i];
n += arr[i];
}
res = 1;
int cnt = n;
for (int i = 0; i <= cnt; ++i) f[i][0] = 1;
for (int i = 1; i <= cnt; ++i)
for (int j = 1; j <= cnt; ++j)
f[i][j] = (f[i - 1][j - 1] + f[i - 1][j]) % 1000000007;
for (int i = k - 1; i >= 0; i--) {
res *= f[n - 1][arr[i] - 1];
res = res % 1000000007;
n -= arr[i];
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long fact[1001];
pair<long long, long long> add_pair(pair<long long, long long> a,
pair<long long, long long> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
return a.first < b.first;
}
long long power(long long a, long long b) {
long long res = 1;
a = a % 1000000007;
while (b > 0) {
if (b & 1) {
res = (res * a) % 1000000007;
b--;
}
a = (a * a) % 1000000007;
b = b >> 1;
}
return res;
}
long long fermat_inv(long long y) { return power(y, 1000000007 - 2); }
void factorial() {
long long i;
fact[0] = 1;
fact[1] = 1;
for (i = 2; i < 1001; i += 1) fact[i] = (i * fact[i - 1]) % 1000000007;
}
long long bin(long long n, long long r) {
return (((fact[n] * fermat_inv(fact[n - r])) % 1000000007) *
fermat_inv(fact[r])) %
1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long k, i;
cin >> k;
long long c[k], pr[k + 1], dp[k + 1];
factorial();
for (i = 0; i < k; i += 1) cin >> c[i];
for (i = 0; i < k; i += 1) pr[i + 1] = c[i];
pr[0] = 0;
for (i = 0; i < k; i += 1) pr[i + 1] += pr[i];
dp[0] = 0;
dp[1] = 1;
for (i = 2; i < k + 1; i += 1) {
dp[i] = (dp[i - 1] * bin(pr[i] - 1, c[i - 1] - 1)) % 1000000007;
}
cout << dp[k] << '\n';
return 0;
}
| 9 | CPP |
def main():
MOD = int(1e9 + 7)
def power(x, p):
if p == 0:
return 1
if p & 1:
return x * power(x, p - 1) % MOD
return power(x * x % MOD, p >> 1) % MOD
import sys
k, *c = [int(i) for i in sys.stdin.read().split()]
inv_factorial = [1] * 1001
factorial = [1] * 1001
for i in range(2, 1001):
factorial[i] = factorial[i - 1] * i % MOD
inv_factorial[i] = power(factorial[i], MOD - 2)
result = 1
size = 0
for i in c:
size += i
m = factorial[size - 1] * inv_factorial[i - 1] % MOD * inv_factorial[size - i] % MOD
result = result * m % MOD
print(result)
main()
| 9 | PYTHON3 |
from math import factorial
k,s,res=int(input()),int(input()),1
for i in range(1,k):
x=int(input())
s+=x
res=(res*factorial(s-1)//factorial(x-1)//factorial(s-x))%1000000007
print(res) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int k;
long long a[1111];
map<long long, long long> mp1;
map<long long, long long> mp2;
void C(long long a, long long b) {
for (long long i = a; i >= a - b + 1; --i) mp1[i]++;
for (long long i = b; i >= 1; --i) mp2[i]++;
}
long long q_pow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
void exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, x, y);
long long t = x;
x = y;
y = t - a / b * y;
}
int main() {
long long sum = 0;
scanf("%d", &k);
for (int i = 1; i <= k; ++i) {
scanf("%lld", a + i);
sum += a[i];
}
for (int i = k; i >= 1; --i) {
C(sum - 1, a[i] - 1);
sum -= a[i];
}
long long ans1 = 1, ans2 = 1;
for (map<long long, long long>::iterator iter = mp1.begin();
iter != mp1.end(); ++iter) {
ans1 = (ans1 * q_pow(iter->first, iter->second)) % mod;
}
if (ans1 == 0) ans1 = mod;
for (map<long long, long long>::iterator iter = mp2.begin();
iter != mp2.end(); ++iter) {
ans2 = (ans2 * q_pow(iter->first, iter->second)) % mod;
}
if (ans2 == 0) ans2 = mod;
long long x, y;
long long t = gcd(ans2, mod);
long long tmpMod = mod / t;
ans2 /= t;
ans1 /= t;
exgcd(ans2, tmpMod, x, y);
printf("%lld\n", ((x % mod + mod) % mod * ans1) % mod);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int extgcd(int a, int b, int &x, int &y) {
int d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
int mod_inverse(int a, int m) {
int x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
int main() {
std::ios_base::sync_with_stdio(false);
int line;
scanf("%d", &line);
int number[1000];
int a = line;
while (a > 0) {
scanf("%d", &number[line - a]);
a--;
}
long long up = 1;
int sum = 0;
for (int d = 1; d < line; d++) {
sum = sum + number[d - 1];
if (number[d] != 1) {
for (int c = 1; c < number[d]; c++) {
int num = sum + c;
up = up * (num) % 1000000007;
up = up * mod_inverse(c, 1000000007);
up = up % 1000000007;
}
}
}
cout << up;
return 0;
}
| 9 | CPP |
k = int(input())
a = []
for _ in range(k):
a.append(int(input()))
n = sum(a)
N = 1000000007
def getCombi(a,n):
b = min(a,n-a)
ret = 1
for i in range(1,b+1):
ret = (ret*(n+1-i))//i
return ret%N
ret = 1
for i in range(k-1,0,-1):
ai = a[i] - 1
ni = sum(a[:i])
ret *= getCombi(ai,ni+ai)
ret %= N
print(ret)
| 9 | PYTHON3 |
from sys import stdin
n=int(stdin.readline())
from math import factorial as f
lst=[int(stdin.readline()) for _ in range(n)]
summa=sum(lst)
res=1
for i,x in enumerate(reversed(lst)):
x-=1
summa-=1
res*=(f(summa)//(f(summa-x)*f(x)))
res=res%1000000007
summa-=x
print(res) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1010, mod = 1e9 + 7;
int k, c[Maxn], s[Maxn];
long long fac[Maxn][Maxn];
void init() {
int i, j;
fac[0][0] = 1;
for (i = 1; i <= 1000; i++) {
fac[i][0] = 1;
for (j = 1; j <= 1000; j++)
fac[i][j] = (fac[i - 1][j - 1] + fac[i - 1][j]) % mod;
}
}
int main(int argc, const char* argv[]) {
ios::sync_with_stdio(0);
int i;
cin >> k;
for (i = 1; i <= k; i++) cin >> c[i], s[i] = s[i - 1] + c[i];
init();
long long ans = 1;
for (i = 1; i <= k; i++) ans = 1LL * ans * fac[s[i] - 1][c[i] - 1] % mod;
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int k, c[1005][1005], mod = 1000000007, a[1005], dp[1005];
int add(int a, int b) {
long long c = a + b;
if (c >= mod) c -= mod;
return (int)c;
}
int main() {
c[0][0] = 1;
for (int i = 1; i <= 1003; ++i) {
c[i][0] = 1;
for (int j = 1; j <= i; ++j) {
c[i][j] = add(c[i - 1][j], c[i - 1][j - 1]);
}
}
scanf("%d", &k);
for (int i = 1; i <= k; ++i) scanf("%d", &a[i]);
long long ans = 1;
int sum = 0;
for (int i = 1; i <= k; ++i) {
ans = (ans * c[sum + a[i] - 1][a[i] - 1]) % mod;
sum += a[i];
}
printf("%lld\n", ans);
return 0;
}
| 9 | CPP |
MOD = int(1e9 + 7)
C = [[0]*(1001) for i in range(1001)]
C[0][0] = 1
for n in range(1,1001):
C[n][0] = 1
C[n][n] = 1
for k in range(1,n):
C[n][k] = C[n-1][k-1] + C[n-1][k]
k = int(input())
r = 1
n = 0
for i in range(k):
c = int(input())
n += c
r = (r * C[n-1][c-1]) % MOD
print(r)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long comb[1003][1003], sum;
int k, c[1003];
int main() {
cin >> k;
for (int i = 0; i < k; i++) cin >> c[i];
comb[0][0] = 1;
for (int i = 1; i < 1001; i++) {
comb[i][0] = 1, comb[i][i] = 1;
for (int j = 1; j < i; j++) {
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % mod;
}
}
long long sol = 1;
for (int i = 0; i < k; i++) {
sum += c[i];
sol = (sol * comb[sum - 1][c[i] - 1]) % mod;
}
cout << sol << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool sortbydesc(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
if (a.second < b.second)
return true;
else
return false;
}
long long int bin[1001][1001];
long long int binomial(long long int n, long long int k) {
if (bin[n][k] != -1) return bin[n][k];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int bin[1001][1001];
memset(bin, 0, sizeof(bin));
bin[1][0] = 1 % 1000000007;
bin[1][1] = 1 % 1000000007;
for (long long int i = 2; i < 1001; i++) {
bin[i][0] = 1 % 1000000007;
for (long long int j = 1; j < i + 1; j++) {
bin[i][j] = (bin[i - 1][j] + bin[i - 1][j - 1]) % 1000000007;
}
}
vector<long long int> v, k;
long long int a;
v.push_back(0);
k.push_back(0);
for (long long int i = 1; i < n + 1; i++) {
cin >> a;
k.push_back(a);
v.push_back(a + v[i - 1]);
}
long long int ans = 1;
for (long long int i = 2; i < n + 1; i++) {
ans = (ans * bin[v[i] - 1][k[i] - 1]) % 1000000007;
}
cout << ans;
}
| 9 | CPP |
f = [1] * (10 ** 6)
for i in range(2, 10 ** 3 + 1):
f[i] = f[i - 1] * i
k = int(input())
s = 0
ans = 1
for i in range(k):
c = int(input())
ans *= (f[(s + c - 1)] // f[c - 1] // f[s]) % (10 ** 9 + 7)
s += c
print(ans % (10 ** 9 + 7)) | 9 | PYTHON3 |
def fpow(a,n):
ret = 1
a = a % mod
while n:
if n&1:
ret = ret*a%mod
a = a*a%mod
n >>= 1
return ret
def prob(i, j):
return factorial[i]*fpow(factorial[j]*factorial[i-j]%mod,mod-2)%mod
mod = 1000000007
sum_colors = 0
factorial = [1]
colors = []
tot = 1
for x in range(1, 1000000, 1):
factorial.append((factorial[x-1])*x%mod)
n_colors = int(input())
for x in range(n_colors):
_in = int(input())
colors.append(_in)
sum_colors += _in
for x in range(n_colors-1, -1, -1):
tot = tot * prob(sum_colors-1, colors[x]-1)%mod
sum_colors -= colors[x]
print(tot)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int fast_exp(long long int base, int exp) {
if (exp == 0) return 1;
if (exp == 1)
return base;
else {
if (exp % 2 == 0) {
long long int k, temp;
temp = exp >> 1;
k = fast_exp(base, temp) % mod;
k = k % mod * k % mod;
k %= mod;
long long int base1 = k;
if (base1 >= mod)
return base1 % mod;
else
return base1;
} else {
long long int k, temp;
temp = (exp - 1);
temp = temp >> 1;
k = fast_exp(base, temp) % mod;
k = k % mod * k % mod;
k %= mod;
long long int ans = (base % mod);
ans *= (k % mod);
ans %= mod;
if (ans >= mod)
return ans % mod;
else
return ans;
}
}
}
int a[1005];
int main() {
unsigned long long int n, k, i;
unsigned long long int fans = 0, ans = 0, temp, len, seq = 0, t1;
cin >> k;
for (i = 1; i <= k; i++) {
cin >> a[i];
}
fans = 1;
len = 0;
fans = 1;
seq = 1;
long long int num = 1, den = 1;
for (i = 1; i <= k; i++) {
temp = a[i];
len++;
temp--;
t1 = 1;
while (temp--) {
seq *= (len);
den *= t1;
den %= mod;
t1++;
len++;
seq %= mod;
}
}
long long int d1 = fast_exp(den, mod - 2);
seq *= d1;
seq %= mod;
cout << seq << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long cnt[2048];
bool IsPrime(long long x) {
long long X = sqrt(x), i;
for (i = 2; i <= X; i++) {
if (x % i == 0) return false;
}
return false;
}
int main() {
long long ans = 1;
long long n, sum = 0, i, j;
cin >> n;
for (i = 0; i < n; i++) {
long long a;
cin >> a;
long long jj = i;
for (int i = sum + 1; i < sum + a; i++) {
long long a = i, j;
for (j = 2; j <= sqrt(a); j++) {
if (IsPrime(a)) break;
while (a % j == 0) {
a /= j;
cnt[j]++;
}
}
cnt[a]++;
}
sum += a;
for (int i = 1; i < a; i++) {
long long a = i, j;
for (j = 2; j <= sqrt(a); j++) {
if (IsPrime(a)) break;
while (a % j == 0) {
a /= j;
cnt[j]--;
}
}
cnt[a]--;
}
}
for (i = 1; i <= n; i++) {
long long a = i, j;
}
for (i = 1; i < 2048; i++) {
for (j = 1; j <= cnt[i]; j++) {
ans *= i;
ans %= mod;
}
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N;
long long C[1001][1001];
long long dp[1001];
long long color[1001];
long long combination(int n, int p) {
if (n == p || p == 0) {
return C[n][p] = 1;
}
if (C[n][p] != -1) {
return C[n][p];
} else {
long long ans = combination(n - 1, p) % 1000000007L;
ans = ans + (combination(n - 1, p - 1) % 1000000007L);
return C[n][p] = ans % 1000000007L;
}
}
long long solve(int k) {
if (k == 1) {
return 1;
} else if (dp[k] != -1) {
return dp[k];
} else {
long long sum = 0;
for (int i = 1; i <= k; i++) {
sum += color[i];
}
sum--;
long long ans = combination(sum, color[k] - 1);
ans *= solve(k - 1);
ans %= 1000000007L;
return dp[k] = ans;
}
}
int main() {
scanf("%d\n", &N);
for (int i = 1; i <= N; i++) {
cin >> color[i];
}
memset(dp, -1, sizeof dp);
memset(C, -1, sizeof C);
long long ans = solve(N);
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) {
if ((value += other.value) >= mod()) value -= mod();
return *this;
}
Modular& operator-=(const Modular& other) {
if ((value -= other.value) < 0) value += mod();
return *this;
}
template <typename U>
Modular& operator+=(const U& other) {
return *this += Modular(other);
}
template <typename U>
Modular& operator-=(const U& other) {
return *this -= Modular(other);
}
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type&
operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) *
rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) {
return *this *= Modular(inverse(other.value, mod()));
}
template <typename U>
friend const Modular<U>& abs(const Modular<U>& v) {
return v;
}
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T>& lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T>& lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
bool IsZero(const Modular<T>& number) {
return number() == 0;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
constexpr int md = (int)1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
const int maxn = 2e6 + 1;
vector<Mint> fact(maxn, (Mint)1);
Mint nCr(int n, int r) {
Mint ans = fact[n] / (fact[r] * fact[n - r]);
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
fact[0] = fact[1] = 1;
for (int i = 2; i < maxn; i++) fact[i] *= fact[i - 1] * i;
int k;
cin >> k;
Mint ans = 1;
vector<int> a(k);
for (auto& i : a) cin >> i;
int sum = a[0];
for (int i = 1; i < k; i++) {
sum += a[i];
ans *= nCr(sum - 1, a[i] - 1);
}
cout << ans << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T1, class T2, class T3, class T4>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4) {
gn(x1, x2, x3), gn(x4);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void gn(T1 &x1, T2 &x2, T3 &x3, T4 &x4, T5 &x5) {
gn(x1, x2, x3, x4), gn(x5);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4, T5 x5) {
printsp(x1), printsp(x2), printsp(x3), printsp(x4), println(x5);
}
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 a[1010], c[1010][1010];
int main() {
for (int i = 0; i < 1010; i++) {
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
}
int n;
gn(n);
for (int i = 0; i < n; i++) gn(a[i]);
int ans = 1, sum = a[0];
for (int i = 1; i < n; i++) {
ans = 1LL * ans * c[sum + a[i] - 1][a[i] - 1] % 1000000007;
sum += a[i];
}
println(ans);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MaxK = 1e3 + 7;
const long long MOD = 1000000007;
int c[MaxK];
long long comb[MaxK][MaxK], dp[MaxK];
int main() {
int k, n = 0;
cin >> k;
for (int i = 0; i < (int)k; ++i) {
cin >> c[i];
n += c[i];
}
comb[0][0] = 1;
for (int i = 1; i < MaxK; ++i) {
comb[i][0] = 1;
for (int j = 1; j <= i; ++j) {
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]);
if (comb[i][j] >= MOD) comb[i][j] -= MOD;
}
}
long long res = 1;
n = 0;
for (int i = 0; i < k; ++i) {
res = (res * comb[n + c[i] - 1][c[i] - 1]) % MOD;
n += c[i];
}
cout << res << "\n";
return 0;
}
| 9 | CPP |
from math import factorial as f
def ncr(n, r): return f(n) // (f(r) * f(n - r))
k = int(input())
k += -1
ans = 1
t1 = int(input())
while k:
k += -1
t2 = int(input())
ans *= ncr(t1 + t2 - 1, t2 - 1)
t1 += t2
print(ans % 1000000007)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
const int MOD = 1000000007;
using namespace std;
long long int nCr[2010][2010];
void init() {
int i, j;
for (i = 0; i <= 2000; i++) {
for (j = 0; j <= min(i, 2000); j++) {
if (j == 0 || j == i)
nCr[i][j] = 1;
else
nCr[i][j] = (nCr[i - 1][j] % MOD + nCr[i - 1][j - 1] % MOD) % MOD;
}
}
}
int main() {
int k, i;
init();
cin >> k;
int C[k];
int sum[k];
for (i = 0; i < k; i++) cin >> C[i];
sum[0] = C[0];
for (i = 1; i < k; i++) sum[i] = sum[i - 1] + C[i];
long long int a, b;
a = 1;
for (i = 1; i < k; i++) {
b = ((a % MOD) * (nCr[sum[i - 1] + C[i] - 1][C[i] - 1] % MOD)) % MOD;
a = b;
}
cout << a << "\n";
return 0;
}
| 9 | CPP |
n=int(input())
ret=1
sum=0
mod=1000000007
for a in range(n):
q=int(input())
e=1
for b in range(q-1):
e*=(sum+1+b)
sil=1
for b in range(2,q):
sil*=b
e//=sil
e%=mod
ret*=e
ret%=mod
sum+=q
print(ret)
| 9 | PYTHON3 |
MOD = 1000000007
fact = [1] * 1001
for i in range(1,1001):
fact[i] = fact[i-1]*i
fact[i]%=MOD
def comb(n,r):
return (fact[n] * pow(fact[n-r],MOD-2,MOD) * pow(fact[r],MOD-2,MOD))%MOD
N = int(input())
List = []
for i in range(N):
List.append(int(input()))
dp = [1] * (N+1)
curr = 0
Ans = 1
for i in range(1,N+1):
Ans = Ans * comb(curr + List[i-1] - 1, List[i-1] - 1)
Ans %= MOD
curr += List[i-1]
print(Ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, a[1007], MOD = 1000 * 1000 * 1000 + 7, f[1000007], dp[1007], ch,
zn, ans = 1, tp[1007][1007], j;
int main() {
tp[0][0] = 1;
for (i = 1; i <= 1000; i++) {
tp[i][0] = 1;
for (j = 1; j <= i; j++) {
tp[i][j] = (tp[i - 1][j] + tp[i - 1][j - 1]) % MOD;
}
}
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
long long sum = 0;
for (i = 0; i < n; i++) {
sum += a[i];
ans = ans * tp[sum - 1][a[i] - 1];
ans %= MOD;
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long pas[2222][2222], ans = 1, mod = 1000000007;
int main() {
for (int i = 0; i < 2222; i++)
for (int j = 0; j < 2222; j++) pas[0][j] = pas[i][j] = 1;
for (int i = 2; i < 2222; i++)
for (int j = 1; j < i; j++) {
pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
pas[i][j] %= mod;
}
long long k;
cin >> k;
long long s = 0;
vector<int> arr(1111);
for (int i = 0; i < k; i++) {
cin >> arr[i];
s += arr[i];
}
s--;
for (int i = k - 1; i >= 0; i--) {
ans *= pas[s][arr[i] - 1];
ans %= mod;
;
s -= arr[i];
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[1006];
long long fac[1000006];
long long power(long long a, long long i) {
if (i == 0) return 1 % 1000000007;
long long t = power(a, i / 2);
long long ans = t * t % 1000000007;
if (i % 2 == 1) ans = ans * a % 1000000007;
return ans;
}
long long work(long long m, long long i) {
return ((fac[m] % 1000000007) *
(power(fac[i] * fac[m - i] % 1000000007, 1000000007 - 2) %
1000000007)) %
1000000007;
}
int main() {
fac[0] = 1;
for (int i = 1; i < 1000006; i++) fac[i] = (fac[i - 1] * i) % 1000000007;
long long ans = 1;
long long sum = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = n; i >= 1; i--) {
ans = ans * work(sum - 1, a[i] - 1) % 1000000007;
sum -= a[i];
}
cout << ans;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2500;
const unsigned long long M = 1000000007;
unsigned long long c[N][N];
unsigned long long cal(int n, int m) {
unsigned long long &cur = c[n][m];
if (cur) return cur;
if (n == m || m == 0) return cur = 1;
return cur = (cal(n - 1, m - 1) + cal(n - 1, m)) % M;
}
int main() {
int i, j;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++) c[i][j] = 0;
unsigned long long ans, tot;
int k, ai;
scanf("%d", &k);
scanf("%d", &ai);
ans = 1;
tot = ai;
for (i = 1; i < k; i++) {
scanf("%d", &ai);
ans = (ans * cal(tot + ai - 1, ai - 1)) % M;
tot += ai;
}
printf("%I64u\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long k, a[1002], p = 1000000007, l, ans, f[1002][1002];
int main() {
for (int i = 1; i <= 1000; i++)
for (int j = 0; j <= i; j++) {
if (j == 0 || j == i)
f[i][j] = 1;
else
f[i][j] = (f[i - 1][j] + f[i - 1][j - 1]) % p;
}
cin >> k;
for (int i = 1; i <= k; i++) cin >> a[i];
l = a[1];
ans = 1;
for (int i = 2; i <= k; i++) {
long long t = a[i] - 1;
if (t > 0) ans = (ans * f[t + l][t]) % p;
l += a[i];
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long factorial[2000];
long long pow_mod_base2(long long base, long long exp, long long mod) {
long long rv = 1;
base = base % mod;
while (exp > 0) {
if (exp & 1) {
rv = (rv * base) % mod;
}
exp >>= 1;
base = (base * base) % mod;
}
return rv;
}
long long inv(long long n, long long mod) {
return pow_mod_base2(n, mod - 2, mod);
}
long long C(long long n, long long k, long long mod) {
if (n < k) return 0;
return factorial[n] * inv(factorial[n - k], mod) % mod *
inv(factorial[k], mod) % mod;
}
long long sum[1001];
long long c[1001], f[1001];
int main() {
factorial[0] = 1;
for (int i = 1; i <= 2000; i++) {
factorial[i] = (factorial[i - 1] * i) % MOD;
}
int n;
cin >> n;
sum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> c[i];
sum[i] = sum[i - 1] + c[i];
if (i == 1) {
f[i] = 1;
continue;
}
f[i] = (f[i - 1] * C(sum[i - 1] + c[i] - 1, sum[i - 1], MOD)) % MOD;
}
cout << f[n] % MOD << endl;
return 0;
}
| 9 | CPP |
ans=1
prev=0
M=10**9+7
for _ in range(int(input())):
x=int(input())
prev+=x
if(_==0):
continue
a=1
for i in range(1,x):
a=a*(prev-i)//(i)
ans=(ans*a)%M
print(ans)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1005];
int cnt[1005];
const int MOD = 1000000007;
long long c[1005][1005];
long long dp[1005];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
cnt[0] = a[0];
for (int i = 1; i < n; ++i) cnt[i] += cnt[i - 1] + a[i];
memset(c, 0, sizeof(c));
for (int i = 0; i < 1005; ++i)
for (int j = 0; j <= i; ++j)
if (j == 0)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % MOD;
dp[0] = 1;
for (int i = 1; i < n; ++i) {
dp[i] = 0;
for (int j = 1; j <= a[i]; ++j) {
dp[i] += dp[i - 1] * c[cnt[i] - j - 1][a[i] - j];
dp[i] %= MOD;
}
}
cout << dp[n - 1] << endl;
return 0;
}
| 9 | CPP |
#not my solution saw the editorial ?>?
def color(arr):
s=0
ans=1
for i in arr:
temp=1
s+=i
if s==i:
continue
for placement in range(1,i):
temp=(temp*(s-placement))//placement
ans*=temp%(10**9+7)
return ans%(10**9+7)
blanck=[]
for i in range(int(input())):
blanck.append(int(input()))
print(color(blanck)) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)2e9;
const long long INFL = (long long)9e18;
const int MAXINT = ((~0) ^ (1 << 31));
const long long MAXLL = ((~0) ^ ((long long)1 << 63));
template <class T>
inline T pow2(T a) {
return a * a;
}
template <class T>
inline bool mineq(T& a, T b) {
return (a > b) ? (a = b, true) : false;
}
template <class T>
inline bool maxeq(T& a, T b) {
return (a < b) ? (a = b, true) : false;
}
const int maxn = (int)1111;
;
const int MOD = (int)1e9 + 7;
;
long long fact[maxn], rfact[maxn];
long long powmod(long long a, long long b) {
if (!b) return 1;
long long t = powmod(a, b / 2);
t = (t * t) % MOD;
if (b & 1) t = (t * a) % MOD;
return t;
}
long long cmb(long long n, long long k) {
if (k > n) return 0;
return ((fact[n] * rfact[n - k]) % MOD * rfact[k]) % MOD;
}
long long k, cnt[maxn], n = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
fact[0] = 1;
for (int i = 1; i < (int)(maxn); i++) fact[i] = (fact[i - 1] * i) % MOD;
for (int i = 0; i < (int)(maxn); i++) rfact[i] = powmod(fact[i], MOD - 2);
cin >> k;
for (int i = 0; i < (int)(k); i++) {
cin >> cnt[i];
n += cnt[i];
}
long long ans = 1;
for (int i = k - 1; i >= (int)(0); i--) {
ans = (ans * cmb(n - 1, cnt[i] - 1)) % MOD;
n -= cnt[i];
}
cout << ans;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int fact[1000001];
long long int a[1001], ans[1001];
long long int ex(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b % 2 == 1)
return (a * ex((a * a) % m, b >> 1, m)) % m;
else
return ex((a * a) % m, b >> 1, m) % m;
}
long long int inline inv(long long int x) {
return ex(x, 1000000007 - 2, 1000000007);
}
long long int inline comb(long long int a, long long int b) {
return ((fact[a] * inv(fact[b]) % 1000000007) * inv(fact[a - b])) %
1000000007;
}
int main() {
long long int k;
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t tStart = clock();
fact[0] = 1;
for (int i = int(1); i <= int(1000000); i++)
fact[i] = (fact[i - 1] * i) % 1000000007;
cin >> k;
for (int i = int(1); i <= int(k); i++) cin >> a[i];
ans[1] = 1;
long long int R = 0;
for (int i = int(2); i <= int(k); i++) {
R += a[i - 1];
long long int b = a[i];
ans[i] = ((ans[i - 1] * (comb(b - 1 + R, R))) % 1000000007);
}
cout << ans[k] << "\n";
return 0;
}
| 9 | CPP |
def fact(x):
res = 1
while x > 0:
res *= x
x -= 1
return res
k = int(input())
lst=[]
for i in range(0, k):
x = int(input())
lst.append(x)
l = lst[0]
ans = 1
for i in range(1, k):
l += lst[i] - 1
ans *= fact(l) // (fact(l - lst[i] + 1) * fact(lst[i] - 1))
l += 1
print(ans % (1000 * 1000 * 1000 + 7))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int k, c[1000 + 10], sum;
long long a[1010][1000 + 10];
long long ans[1000 + 10];
const long long mod = 1000000007;
void calc() {
for (int i = 0; i < 1000 + 10; i++) a[0][i] = 1;
for (int i = 1; i < 1010; i++) {
for (int j = i; j < 1000 + 10; j++) {
a[i][j] = a[i - 1][j - 1] + a[i][j - 1];
a[i][j] %= mod;
}
}
}
int main() {
calc();
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> c[i];
}
ans[1] = 1;
sum = c[1];
for (int i = 2; i <= k; i++) {
ans[i] = ans[i - 1] * a[sum][(sum + c[i] - 1)];
ans[i] %= mod;
sum += c[i];
}
cout << ans[k] << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
int color[1003], total;
long long bc[1005][1005], res = 1LL;
int main() {
ios_base ::sync_with_stdio(0);
int k;
cin >> k;
for (int i = 1; i <= k; i++) cin >> color[i];
bc[0][0] = 1;
for (int i = 1; i <= 1004; i++) {
bc[i][0] = bc[i][i] = 1;
for (int j = 1; j < i; j++)
bc[i][j] = (bc[i - 1][j] + bc[i - 1][j - 1]) % mod;
}
for (int i = 1; i <= k; i++) {
res = (res * 1LL * bc[total + color[i] - 1][color[i] - 1]) % mod;
total += color[i];
}
cout << res;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int ModD = 1e9 + 7;
long long n, a[1005], f[1005], c[1005][1005], d[1005][1005];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= 1000; ++i) d[0][i] = 1, c[0][i] = 1;
for (int i = 1; i <= 1000; ++i)
for (int j = 1; j <= 1000; ++j) {
if (j == 1)
c[i][j] = 1;
else
c[i][j] = d[i][j - 1];
d[i][j] = (d[i - 1][j] + c[i][j]) % ModD;
}
int so = a[1];
f[1] = 1;
for (int i = 2; i <= 1000; ++i) {
f[i] = (f[i - 1] * c[a[i] - 1][so + 1]) % ModD;
so += a[i];
}
cout << f[n];
fclose(stdin);
fclose(stdout);
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int INF = (1LL << 31) - 1;
const long long LINF = LLONG_MAX;
const int maxn = 1e3 + 1;
long long C[maxn][maxn], a[maxn], n, ans = 1;
long long c(int r, int n) {
if (r == 0 || r == n) return 1ll;
if (C[r][n]) return C[r][n];
C[r][n] = c(r - 1, n - 1);
C[r][n] %= mod;
C[r][n] += c(r, n - 1);
C[r][n] %= mod;
return C[r][n];
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
int s = 0, t = 0;
for (int i = 0; i < n; i++) cin >> a[i], t += a[i];
for (int i = n - 1; i >= 0; i--) {
ans *= c(a[i] - 1, t - s - 1) % mod;
ans %= mod;
s += a[i];
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long cnk[1010][1010], n, c[1010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> c[i];
cnk[0][0] = 1;
for (int i = 1; i < 1010; i++) {
cnk[i][0] = 1;
for (int j = 1; j <= i; j++)
cnk[i][j] = (cnk[i - 1][j - 1] + cnk[i - 1][j]) % 1000000007;
}
long long res = 1, sum = c[1];
for (int i = 2; i <= n; i++) {
res = (res * cnk[sum + c[i] - 1][c[i] - 1]) % 1000000007;
sum += c[i];
}
cout << res;
return 0;
}
| 9 | CPP |
#!/usr/bin/env python
# 554C_colored.py - Codeforces.com 554C Colored quiz
#
# Copyright (C) 2015 Sergey
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Input
The first line of input will have one integer k (1<=k<=1000) the number
of colors.
Then, k lines will follow. The i-th line will contain ci, the number of
balls of the i-th color (1<=ci<=1000).
The total number of balls doesn't exceed 1000.
Output
A single integer, the number of ways that Kyoya can draw the balls from
the bag as described in the statement, modulo 1_000_000_007.
"""
# Standard libraries
import unittest
import sys
import re
# Additional libraries
###############################################################################
# Colored Class
###############################################################################
class Colored:
""" Colored representation """
MOD = 1000000007
def __init__(self, args):
""" Default constructor """
self.list = args
def fact(self, n):
result = 1
for i in range(n):
result *= i + 1
return result
def binom(self, n, k):
return (self.fact(n) // (self.fact(n - k) * self.fact(k)))
def f(self, i):
if i == 0:
return 1
bin = self.binom(sum(self.list[:i+1]) - 1, self.list[i] - 1)
return (bin % self.MOD) * self.f(i - 1)
def calculate(self):
""" Main calcualtion function of the class """
result = self.f(len(self.list) - 1) % self.MOD
return str(result)
###############################################################################
# Executable code
###############################################################################
def get_inputs(test_inputs=None):
it = iter(test_inputs.split("\n")) if test_inputs else None
def uinput():
""" Unit-testable input function wrapper """
if it:
return next(it)
else:
return input()
# Getting string inputs
num = int(uinput())
nums = [int(uinput()) for i in range(num)]
# Decoding inputs
inputs = nums
return inputs
def calculate(test_inputs=None):
""" Base class calculate method wrapper """
return Colored(get_inputs(test_inputs)).calculate()
###############################################################################
# Unit Tests
###############################################################################
class unitTests(unittest.TestCase):
def test_sample_tests(self):
""" Quiz sample tests. Add \n to separate lines """
self.assertEqual(calculate("3\n2\n2\n1"), "3")
self.assertEqual(calculate("4\n1\n2\n3\n4"), "1680")
self.assertEqual(calculate(
"10\n100\n100\n100\n100\n100\n100\n100" +
"\n100\n100\n100"), "12520708")
s = "1000"
for n in range(1000):
s += "\n1"
self.assertEqual(calculate(s), "1")
def test_get_inputs(self):
""" Input string decoding testing """
self.assertEqual(get_inputs("2\n1\n3"), [1, 3])
def test_Colored_class__basic_functions(self):
""" Colored class basic functions testing """
# Constructor test
d = Colored([2, 1])
self.assertEqual(d.list, [2, 1])
# Factorial using modulo
self.assertEqual(d.fact(4), 24)
# Binominal
self.assertEqual(d.binom(2, 1), 2)
# Dynamic programming function, solution for i colors
self.assertEqual(d.f(0), 1)
self.assertEqual(d.f(1), 1)
if __name__ == "__main__":
# Avoid recursion limitaions
sys.setrecursionlimit(10000)
if sys.argv[-1] == "-ut":
unittest.main(argv=[" "])
# Print the result string
print(calculate())
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long M = 1000000007;
long long fac(long long n) {
if (n == 0)
return 1;
else
return ((n % M) * (fac(n - 1) % M)) % M;
}
long long pro(long long x, long long y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return pro((x * x) % M, y / 2);
else
return ((x % M) * (pro((x * x) % M, (y - 1) / 2)) % M) % M;
}
signed main() {
long long k, z = 0, ans = 1;
cin >> k;
while (k--) {
long long x, a, b;
cin >> x;
if (z == 0)
z += x;
else {
x--;
a = pro(fac(x), M - 2);
b = pro(fac(z), M - 2);
long long p = ((a % M) * (b % M)) % M;
long long s = ((fac(z + x) % M) * (p % M)) % M;
ans = ((ans % M) * (s % M)) % M;
z += x + 1;
}
}
cout << ans % M;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MODNUM = 1000000007;
int main() {
int totalColors;
cin >> totalColors;
vector<int> src(totalColors);
vector<int> sums(totalColors);
cin >> src[0];
sums[0] = src[0];
for (int i = 1; i < totalColors; ++i) {
cin >> src[i];
sums[i] = sums[i - 1] + src[i];
}
int MAXNK = 1500;
vector<int> empv(MAXNK, 0);
vector<vector<int> > C(MAXNK, empv);
for (int i = 0; i < MAXNK; ++i) C[i][0] = 1;
for (int i = 1; i < MAXNK; ++i) C[0][i] = 0;
for (int i = 1; i < MAXNK; ++i)
for (int j = 1; j < MAXNK; ++j) {
C[i][j] = ((long long)C[i - 1][j] + C[i - 1][j - 1]) % MODNUM;
}
vector<int> ans(totalColors, 1);
ans[0] = 1;
for (int i = 1; i < totalColors; ++i) {
ans[i] = ((long long)ans[i - 1] * C[sums[i - 1] + src[i] - 1][src[i] - 1]) %
MODNUM;
}
cout << ans[totalColors - 1] << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long st[1005][1005];
long long zuhe(long long x, long long y) {
if (y == 0 || x == y)
return 1;
else
return (zuhe(x - 1, y) + zuhe(x - 1, y - 1)) % mod;
}
void play() {
for (int i = 1; i <= 1000; i++)
for (int j = 0; j <= i; j++) {
if (i == j)
st[i][j] = 1;
else if (j == 0)
st[i][j] = 1;
else {
st[i][j] = (st[i - 1][j] + st[i - 1][j - 1]) % mod;
}
}
}
int main() {
int t;
int ans[1005];
int sum[1005];
cin >> t;
play();
for (int i = 0; i < t; i++) cin >> ans[i];
sum[0] = ans[0];
for (int i = 1; i < t; i++) sum[i] = sum[i - 1] + ans[i];
long long answer = 1;
for (int i = t - 1; i >= 0; i--) {
if (ans[i] == 1) continue;
long long m = sum[i] - 1;
long long n = ans[i] - 1;
answer = (answer * st[m][n]) % mod;
}
cout << answer << endl;
;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
long long mod = 1000000007LL;
long long comb[1024][1024];
void get_comb() {
for (int i = 0; i < 1001; i++) comb[0][i] = 0LL;
for (int i = 0; i < 1001; i++) comb[i][0] = 1LL;
for (int i = 1; i < 1001; i++) {
for (int j = 1; j <= i; j++) {
comb[i][j] = comb[i - 1][j] + comb[i - 1][j - 1];
if (comb[i][j] >= mod) comb[i][j] -= mod;
}
}
}
int num[1024];
int main() {
int n;
get_comb();
while (cin >> n) {
for (int i = 0; i < n; i++) {
cin >> num[i];
}
int sum = 0;
long long ans = 1LL;
for (int i = 0; i < n; i++) {
ans *= comb[num[i] - 1 + sum][num[i] - 1];
ans %= mod;
sum += num[i];
}
cout << ans << endl;
}
return 0;
}
| 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.