//我很喜欢暴力，于是我就写了一个暴力的dp
//可以说相当暴力了
#include<iostream>
using namespace std;
unsigned long long dp[30][20][20];
int main()
{
    int n,i,j,k,a,b,u,v; 
    unsigned long long ans=0;
    cin>>n>>a>>b;
    dp[0][0][0]=1;
    for(i=1;i<=n;i++)
     for(j=0;j<=a;j++)
      for(k=0;k<=b;k++)
       for(u=0;u<=j;u++)
        for(v=0;v<=k;v++)
         dp[i][j][k]+=dp[i-1][u][v];
    for(i=0;i<=a;i++)
     for(j=0;j<=b;j++)
      ans+=dp[n][i][j];
    cout<<ans;
    return 0; 
}

杨辉三角就是好
#include<bits/stdc++.h>
using namespace std;
unsigned long long c[50][50];
int n,a,b;
void pre(){
for(int i=0;i<=40;i++) c[i][0]=1;
for(int i=0;i<=40;i++){
for(int j=1;j<=i;j++){
c[i][j]=c[i-1][j-1]+c[i-1][j];
}
}
}
int main(){
cin>>n>>a>>b;
pre();
cout<<c[a+n][n]*c[b+n][n]<<endl;
}

组合数学~Easy
#include<cmath>
#include<vector>
#include<cstdio>
#include<string>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ULL unsigned long long
#define for1(v,a,b) for (int v=a;v<=b;v++)
#define for2(v,a,b) for (int v=a;v>=b;v--)
using namespace std;
int n,a,b;
ULL ans;
ULL Gcd(ULL x,ULL y){
if (y==0) return x;
return Gcd(y,x%y);
}
ULL C(int x,int y){
ULL xx,yy,p;
xx=yy=1;
while (y){
xx*=x;
yy*=y;
p=Gcd(xx,yy);
xx/=p;
yy/=p;
x-=1;
y-=1;
}
return xx;
}
int main(){
scanf("%d%d%d",&n,&a,&b);
ans=C(n+a,a)*C(n+b,b);
cout<<ans;
return 0;
}

排列组合问题
#include<iostream>
using namespace std;
int main()
{
int n,a,b;
cin>>n;
cin>>a;
cin>>b;
unsigned long long int x=1;
unsigned long long int y=1;
for(int i=n+1;i<=n+a;i++)
x=x*(i)/(i-n);
for(int j=n+1;j<=n+b;j++)
y=y*(j)/(j-n);
cout<<x*y;
return 0;

}

这道题特别坑，用long long int 还不够,要unsigned long long int 才行。
其次，我发现对于这种题，直接动态规划，思路特别简单，而那些灵巧的递推需要灵感才能发现。
算法大意：g(a,n)表示把a个相同的球放入n个不同的盒子(必须放进去)。
那么，ans=【g(a,n)+g(a-1,n)+g(a-2,n)......+g(0,n)】*[g(b,n)+g(b-1,n)+.....+g(0,n)].
而g(a,n)=g(a,n-1) 表示第一个盒子放0个球，
+g(a-1,n-1) 表示第一个盒子放一个球
+。。+g(0,n-1) 表示第一个盒子放a个球
#include<iostream>
#include<string.h>
#include<math.h>
using namespace std;

long long int g[17][23];
int n, a, b;
void init(){
int i, j,k;
memset(g, 0, sizeof(g));
for (i = 0; i <= n; i++)g[0][i] = 1;
for (i = 1; i <= 15; i++){
for (j = 1; j <= n; j++){
g[i][j] = 0;
for (k = 0; k <= i; k++){
g[i][j] += g[i-k][j-1];
}
}
}
}
int main(){
freopen("in.txt", "r", stdin);

cin >> n >> a >> b;
init();
int i;
unsigned long long int ga, gb;
ga = gb = 0;
for (i = 0; i <= a; i++){
ga += g[a - i][n];
}
for (i = 0; i <= b; i++)
gb += g[b - i][n];
cout <<(unsigned long long ) (ga*gb) << endl;
return 0;
}

你确定测试数据没有问题？
为什么第5个点过不去~……都跪了~

我看了测试数据10 15 15的预期输出10684791937600呀~
我本地输出也是这个结果呀~ 为什么提交了之后就WA呀？

#include <iostream>

int main() {
int n = 0, a = 0, b = 0;
std::cin >> n >> a >> b;

unsigned long long totalA = 1, totalB = 1;
for ( int i = 1; i <= a; ++ i ) {
totalA *= (n + i) / (i * 1.0);
}
for ( int i = 1; i <= b; ++ i ) {
totalB *= (n + i) / (i * 1.0);
}

std::cout << totalA * totalB << std::endl;

return 0;
}

O(n^5)的算法竟然能0ms，真不科学
二二的公式：
"f" ["i,j,k" ]"=" ∑_"m=0" ^"i" ▒∑_"n=0" ^"j" ▒"f" ["m,n,k-1" ]

编译成功

测试数据 #0: Accepted, time = 0 ms, mem = 580 KiB, score = 10
测试数据 #1: Accepted, time = 0 ms, mem = 576 KiB, score = 10
测试数据 #2: Accepted, time = 0 ms, mem = 576 KiB, score = 10
测试数据 #3: Accepted, time = 0 ms, mem = 580 KiB, score = 10
测试数据 #4: Accepted, time = 0 ms, mem = 580 KiB, score = 10
测试数据 #5: Accepted, time = 0 ms, mem = 580 KiB, score = 10
测试数据 #6: Accepted, time = 0 ms, mem = 576 KiB, score = 10
测试数据 #7: Accepted, time = 0 ms, mem = 580 KiB, score = 10
测试数据 #8: Accepted, time = 0 ms, mem = 572 KiB, score = 10
测试数据 #9: Accepted, time = 0 ms, mem = 580 KiB, score = 10
Accepted, time = 0 ms, mem = 580 KiB, score = 100
代码
#include<cstdio>
int n,a,b;
unsigned long long r[21][16][16];
int main(){
scanf("%d%d%d",&n,&a,&b);
for (int i=0; i<=a; i++)
for (int j=0; j<=b; j++) r[0][i][j]=1;
for (int z=1; z<=n; z++)
for (int i=0; i<=a; i++)
for (int j=0; j<=b; j++)
for (int k=0; k<=i; k++)
for (int l=0; l<=j; l++) r[z][i][j]+=r[z-1][k][l];
printf("%I64u" ,r[n][a][b]);
}

很奇怪
一直记得重复组合的公式是 C（n+r-1,r）;
把a，b分别带入，相乘应该就是答案。样例可以过，其他点全挂。
看了几个大牛的题解，写到应该写成 C(n+r,r);
的确，这样就可以过，但一直想不通。
后来知道了：因为这里有不放的情况，我们把不放在盒子里，看成也是一个盒子。那么n实际上就是 n+1
然后，看到qword ，秒杀。。。
DXE-SYF

点击查看程序源码+详细题解

日啊用REAL因为精度不够第十个点WA了纠结N久

组合数学or动规

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

此题甚水

編譯通過...

├ 測試數據 01：答案正确... 0ms

├ 測試數據 02：答案正确... 0ms

├ 測試數據 03：答案正确... 0ms

├ 測試數據 04：答案正确... 0ms

├ 測試數據 05：答案正确... 0ms

├ 測試數據 06：答案正确... 0ms

├ 測試數據 07：答案正确... 0ms

├ 測試數據 08：答案正确... 0ms

├ 測試數據 09：答案正确... 0ms

├ 測試數據 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗時：0ms

var f:array[0..21,0..16,0..17]of qword;

a,b,n,i,j,k,ll,l:longint;

begin

readln(n,a,b);

for i:=0 to a do

for j:=0 to b do f[0,i,j]:=1;

for i:=1 to n do

for j:=0 to a do

for k:=0 to b do

for l:=0 to j do

for ll:=0 to k do

f:=f+f;

writeln(f[n,a,b]);

end.

AC得都不想AC了...

INT64和QWORD，占用空间一样，取值范围一样（INT64算上负的），可是在本题里————QWORD AC，INT64 90！

f表示前i个数放j个蓝球k个红球的方案数

f:=f+f(0

必须用qword，用extended由于精度问题第１０个点过不去

var

n,a,b,x:longint;

ji:qword;

procedure jie(var n,m:longint);

var

i:longint;

t:extended;

begin

t:=1;

for i:=1 to m do t:=t*(n-i+1)/i;

ji:=ji*round(t);

end;

begin

ji:=1;

read(n,a,b);

x:=n+a;

jie(x,a);

x:=n+b;

jie(x,b);

write(ji);

end.

交了4次终于AC了，还是不用函数好，用了就有问题

这种题……

我高中排列组合白学了……

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

3次才AC!