AHOI2009中国象棋

首先以行为阶段，根据象棋的规则，在同一行中，至多只能有两个炮，同理:在同一列中，至多只能有两个炮
思考一个可以覆盖整个状态空间的dp数组：
dp[i]表示到了第i行
接下来我们想：某列中的炮能否通过位运算求得
我们能够发现，可能我们目前在第i行，但是在某个j行的p列有一个炮，我们要知道第i行的第p列能否放置炮。但是j可能与i相差甚远，我们不能直接通过位运算得到，逐行枚举又会耗费大量不必要的时间。
那么我们就干脆将列的状态记录在数组里，我们想我们其实并不关心到第i行时哪一列有1个炮，哪一列有两个炮，我们只需要知道到第i行时，有多少列有1个炮，有多少列有两个炮，剩下的问题我们能够通过枚举状态解决
这样就有了dp数组：
dp[i][j][k]表示到第i行时，有j列有一个炮，k列有两个炮

假设第i行只放一个炮，那么放置的方法数累加(DP方程)就是:
1.这一个炮放在了原来没有炮的位置
dp[i][j][k] += dp[i - 1][j - 1][k] * (m - j - k)
2.这一个炮放在了原来有一个炮的位置
dp[i][j][k] += dp[i - 1][j + 1][k - 1] * j

假设第i行放置了两个炮
1.这一行两个炮都放在了原来没有炮的位置
dp[i][j][k] += dp[i - 1][j - 2][k] * (m - j - k) * (m - j - k - 1) / 2;
2.这一行一个炮放在了原来有一个炮的位置，一个炮放在了原来没有炮的位置
dp[i][j][k] += dp[i - 1][j][k - 1] * (m - j - k) * j
3.这一行的两个炮都放在了原来有一个炮的位置
dp[i][j][k] += dp[i - 1][j + 2][k - 2] * j * (j - 1) / 2;

假设第i行没有放炮
dp[i][j][k] += dp[i - 1][j][k]
=-=？？好像没了？接着就是处理一下每种情况能够使用的限制条件
初态:dp[0][0][0] = 1;
末态:Σdp[n][i][j]

恩是的，这是我原本的思路，但我这么写后，不知道为什么就挂了。

挂了！样例都过不了！

于是我毅然决然的把有前驱推当前状态的写法改为了由当前状态推后继状态，然后就...A了.....

方程差别不大，不做修改，直接看代码吧...

 #include<bits/stdc++.h>
 #define ll long long
 using namespace std;
 const int p = ;
 const int maxn = ;
 ll f[maxn][maxn][maxn];
 int n, m;

 inline  int read() {
     int x = , y = ;
     char ch = getchar();
     while(!isdigit(ch)) {
         if(ch == '-') y = -;
         ch = getchar();
     }
     while(isdigit(ch)) {
         x = (x << ) + (x << ) + ch - '';
         ch = getchar();
     }
     return x * y;
 }

 inline int count(int k) {
 return k * (k - ) / ;}

 int main() {
     memset(f, , sizeof(f));
     n = read(), m = read();
     f[][][] = ;
     for(int i = ; i < n; ++i)
         for(int j = ; j <= m; ++j)
             for(int k = ; k + j <= m; ++k)
                 if(f[i][j][k]) {
                     f[i + ][j][k] = (f[i][j][k] + f[i + ][j][k]) % p;
                     if(m - j - k >= ) f[i + ][j + ][k] = (f[i + ][j + ][k] + f[i][j][k] * (m - j - k)) % p;
                     if(j >= ) f[i + ][j - ][k + ] = (f[i + ][j - ][k + ] + f[i][j][k] * j) % p;
                     if(m - j - k >= ) f[i + ][j + ][k] = (f[i + ][j + ][k] + f[i][j][k] * count(m - j - k)) % p;
                     if(m - j - k >=  && j >= ) f[i + ][j][k + ] = (f[i + ][j][k + ] + f[i][j][k] * (m - j - k) * j) % p;
                     if(j >= ) f[i + ][j - ][k + ] = (f[i + ][j - ][k + ] + f[i][j][k] * count(j)) % p;
                     f[i][j][k] %= p;
                 }
     ll ans = ;
     for(int i = ; i <= m; ++i)
         for(int j = ; j + i <= m; ++j)
             ans = (ans + f[n][i][j]) % p;
     cout << ans << '\n';
     return ;
 }