空间漫游(SAC大佬的测试)

题目描述
由于球哥和巨佬嘉诚交了很多保护费,我们有钱进行一次 d 维空间漫游。
d 维空间中有 d 个正交坐标轴,可以用这些坐标轴来描述你在空间中的位置和移动的方
向。例如,d = 1 时,空间是一个数轴,方向有左或右;d = 2 时,空间是一个平面,方向为
上下左右之一;d = 3 时,空间是一个三维空间,方向为上下左右前后之一;d≥4 时同理。
形式化地描述,d 维空间中共有 2d 个方向,分别对应平行于 d 个坐标轴的正方向和负
方向。虽然这 2d 个方向可以线性组合出无限个方向,但这不在本题的讨论范围中。可以用
一个 d 维向量来描述一个 d 维空间中的方向,其中一维是 1 或-1,其余维度均为 0。如,d=4
时,几个可能的方向是(0,1,0,0)、(0,0,-1,0)等,而(1,1,0,0)不是一个本题中讨论的方向。
你在开始漫游之前,要为自己制定一条路线。你打算一共走 2N 步,每步选择 2d 个方
向中的一个,并沿着该方向走 1 单位长度的距离。并且,你希望漫游结束后能回到开始时的
起点。
请计算有多少条不同的路线满足上述要求,并输出其 mod 1,000,000,007 的值。两条路
线被认为不同当且仅当存在一步,两条路线在该步选择的方向不同。
输入格式
输入仅一行,两个用空格分开的非负整数 d,N。
输出格式
输出仅一行,仅一个整数表示符合要求的路线条数 mod 1,000,000,007。
样例输入 1
2 0
样例输出 1
1
样例解释 1
长度为 0 的路线只有一条
样例输入 2
2 1
样例输出 2
4
样例解释 2
路线 1:(1,0), (-1,0)
路线 2:(-1,0), (1,0)
路线 3:(0,1), (0,-1)
路线 4:(0,-1), (0,1)
样例输入 3
3 2
样例输出 3
90

%%%SAC巨佬https://home.cnblogs.com/u/NaVi-Awson

5 分算法
对于 N = 0,显然路线只有一条,输出 1 即可,复杂度 O(1)。

20 分算法
结合 5 分算法,对于另外的 d = 1,我们可以用 f[i][j]表示第 i 步走到 j 这个位置的方
案数,f[i][j] = f[i-1][j-1]+f[i-1][j+1],因为会有负值,我们可以将整个数组向右平移,即
可求解。复杂度 O(N^2 )。

60 分算法
结合 20 分算法,并且由它启发,我们开三维的数组 f[i][x][y],第 i 步走到二位位置
坐标(x,y)方案数,由四个方向转移过来,复杂度 O(N^3 )。

100 分算法
我们发现到后面维度 d 适合 n 一个数量级的,显然我们不可以单独地把每一个维度拿
出来单独研究。
我们发现既然要求走到原点,那是不是就是在每个正交轴上的投影均为 0。就等于说我
在某一维度上向“外”走 m 步,就一定要走回来 m 步。
我们试着定义方程 f[i][j]表示在前 i 个维度向外走了 j 步(即总共走了 2*j 步)的方案数。
如何转移?我们正考虑当前的 i 维,我并不关心前 i-1 维是怎样走的,那是不是状态是
由 f[i-1][j-k],0<=k<=j 转移过来的。那么我肯定不能简单的相加。

考虑本质,f[i-1][j-k]表示从前 i-1 维向外走了 j-k 步,那么剩下的 k 步是要在这一维里面走的。

我要把 j-k 和 k 有机融合在一起。

我们想到了组合数。
C(2*k,2*j) 表示我们在这总共走的 2*j 步中选取 2*k 步为当前这一维走的。
那么对于 f[i][j-k],我们还要乘上一个 C (2*k,2*j)
但这还是不够,我们还没考虑这 2*k 步中是怎样走的。因为我们刚才说过了 2*k 步有向
“外”走的也有向“内”走的,那么还有乘一个 C(k,2*k) 。
综上转移方程就是
f[i][j]=sum{f[i-1][j-k]* C(k,2*k)*C(2*j,2*k)}

对于组合数用阶乘逆元
复杂度 O(d*N^2 )

 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 using namespace std;
 typedef long long lol;
 int Mod=;
 lol A[],B[],f[][];
 int d,n;
 lol C(int x,int y)
 {
   if (x==||y==) return ;
   lol fz=B[x];
   lol fm=(A[y]*A[x-y])%Mod;
   return (fz*fm)%Mod;
 }
 int main()
 {int i,j,k;
   cin>>d>>n;
   A[]=;
   A[]=;
   for (i=;i<=*n;i++)
     A[i]=((Mod-Mod/i)*A[Mod%i])%Mod;
   for (i=;i<=*n;i++)
     A[i]=(A[i]*A[i-])%Mod;
   B[]=;
   for (i=;i<=*n;i++)
     B[i]=(B[i-]*i)%Mod;
   f[][]=;
   for (i=;i<=d;i++)
     {
       for (j=;j<=n;j++)
     {
       for (k=;k<=j;k++)
         {
           f[i][j]+=(f[i-][j-k]*C(*j,*k)%Mod)*C(*k,k)%Mod;
           f[i][j]%=Mod;
         }
     }
     }
 cout<<f[d][n];
 }