Permutation p is an ordered set of integers p₁,  p₂,  ...,  p_n, consisting of n distinct positive integers, each of them doesn‘t exceed n. We‘ll denote the i-th element of permutation p as p_i. We‘ll call number n the size or the length of permutation p₁,  p

We‘ll call position i (1 ≤ i ≤ n) in permutation p₁, p₂, ..., p_n good, if |p[i] - i| = 1. Count the number of permutations of size n with exactly k good positions. Print the answer modulo 1000000007 (10⁹

The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 0 ≤ k ≤ n).

Print the number of permutations of length n with exactly k good positions modulo 1000000007 (10⁹ + 7).

1 0

1

2 1

0

3 2

4

4 1

6

7 4

328

The only permutation of size 1 has 0 good positions.

Permutation (1, 2) has 0 good positions, and permutation (2, 1) has 2 positions.

Permutations of size 3:

1. (1, 2, 3) — 0 positions
2. — 2 positions
3. — 2 positions
4. — 2 positions
5. — 2 positions
6. (3, 2, 1) — 0 positions

題意：給定N，M，讓你求有多少N的排列，使得|a[i]-i|==1的個數為M。

思路：用dp[i][j][now][next];表示前面i個有j個滿足上述條件，而且第i為和第i+1位被占的情況位now和next。那麽不難寫出方程。

但是我寫出代碼後，發現(2,1)是錯的，我輸出2，答案是0；因為不可能只有1個在臨位。那可以發現，現在是dp[N][M][now][next]*(N-j)!代表的結果是大於M的，還需要容斥。

容斥：dp[N][M]的貢獻，減去dp[N][M+1]的貢獻，加上...

可以發現，每一個好的位置有M+1個的排列，再算有j個的排列時都會被算M+1次（因為對於這個j+1排列，每一個好位置被無視掉以後都會構成一個j排列）

同理，每一個好的位置有j+2個的排列則會再算j個的排列時重復C(M+2,2)

.... 每一個好的位置有j個的排列會在算i(i < j)的排列時被計算C(M+j,M);

即dp[N][M+j]的系數C(M+j,M)；

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=1010;
const int Mod=1e9+7;
int dp[maxn][maxn][2][2],fac[maxn],rev[maxn];
int qpow(int a,int x)
{
    int res=1; while(x){
        if(x&1) res=1LL*res*a%Mod;
        x>>=1; a=1LL*a*a%Mod;
    } return res;
}
int C(int N,int M) { return 1LL*fac[N]*rev[M]%Mod*rev[N-M]%Mod;}
int main()
{
    int N,M;
    scanf("%d%d",&N,&M);
    fac[0]=1; rev[0]=1;
    rep(i,1,N) fac[i]=1LL*fac[i-1]*i%Mod;
    rev[N]=qpow(fac[N],Mod-2);
    for(int i=N-1;i>=1;i--) rev[i]=1LL*rev[i+1]*(i+1)%Mod;
    dp[0][0][0][0]=1;
    rep(i,0,N-1) {
      rep(j,0,i){
        rep(p,0,1){
          rep(q,0,1){
              if(!dp[i][j][p][q]) continue;
              if(p==0&&i) (dp[i+1][j+1][q][0]+=dp[i][j][p][q])%=Mod; //i+1放左邊
              (dp[i+1][j+1][q][1]+=dp[i][j][p][q])%=Mod; //放右邊
              (dp[i+1][j][q][0]+=dp[i][j][p][q])%=Mod; //兩邊都不放
          }
        }
      }
    }
    int ans=0;
    rep(i,M,N){
        int tmp=1LL*(dp[N][i][1][0]+dp[N][i][0][0])%Mod*C(i,M)%Mod*fac[N-i]%Mod;
        if((i-M)%2==0) {
            ans+=tmp;
            if(ans>=Mod) ans-=Mod;
        }
        else{
           ans-=tmp;
           if(ans<0) ans+=Mod;
        }
    }
    printf("%d\n",ans);
    return 0;
}

CodeForces - 285E: Positions in Permutations(DP+組合數+容斥)