Problem:
Score : 900 points

Problem Statement

Snuke loves permutations. He is making a permutation of length N.

Since he hates the integer K, his permutation will satisfy the following:

Let the permutation be a_1, a_2, ..., a_N. For each i = 1,2,...,N, |a_i - i| \neq K.

Among the N! permutations of length N, how many satisfies this condition?

Since the answer may be extremely large, find the answer modulo 924844033(prime).

Constraints

2 ≦ N ≦ 2000

1 ≦ K ≦ N-1

Input

The input is given from Standard Input in the following format:

N K

Output

Print the answer modulo 924844033.

Sample Input 1

3 1

Sample Output 1

2

2 permutations (1, 2, 3), (3, 2, 1) satisfy the condition.

Sample Input 2

4 1

Sample Output 2

5

5 permutations (1, 2, 3, 4), (1, 4, 3, 2), (3, 2, 1, 4), (3, 4, 1, 2), (4, 2, 3, 1) satisfy the condition.

Sample Input 3

4 2

Sample Output 3

9

Sample Input 4

4 3

Sample Output 4

14

Sample Input 5

425 48

Sample Output 5

756765083

Solution in C++ (GCC 5.4.1) (judge verdict: Accepted)

#include<bits/stdc++.h>
#define reg register
#define mod 924844033
#define maxn 3001
using namespace std;
int n, K, fac[maxn], dp[maxn][maxn][3], ans;
int d[maxn], g[maxn][maxn], cnt, sum, p, siz[maxn];
int inc(int x, int y){
    return x + y >= mod ? x + y - mod : x + y;
}
int main(){
    cin >> n >> K;
    fac[0] = 1;
    for(int i = 1; i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
    for(int i = 1; i <= n; i++) {
        if(d[i]) continue;
        dp[0][0][0] = 1; p = 0; cnt++;
        for(int now = i, j = 1; now <= n; now += 2 * K, j++){
            p++; d[now] = 1;
            for(int k = 0; k <= j; k++){
                dp[j][k][0] = 0; dp[j][k][1] = 0; dp[j][k][2] = 0;
                dp[j][k][0] = inc(dp[j - 1][k][1], inc(dp[j - 1][k][2], dp[j - 1][k][0]));
                if(k && now > K) dp[j][k][1] = inc(dp[j - 1][k - 1][0], dp[j - 1][k - 1][1]);
                if(k && now + K <= n) dp[j][k][2] = inc(dp[j - 1][k - 1][2], dp[j - 1][k - 1][0]);
                if(k && now + K <= n) dp[j][k][2] = inc(dp[j][k][2], dp[j - 1][k - 1][1]);
            }
        }
        for(int j = 0; j <= p; j++) g[cnt][j] = inc(dp[p][j][0], inc(dp[p][j][2], dp[p][j][1])); siz[cnt] = p;
    }
    for(int i = 1; i <= cnt; i++){
        sum += siz[i];
        for(int j = siz[i]; j >= 0; j--)
            for(int k = 1; k <= sum - siz[i]; k++)
                g[i][j + k] = inc(g[i][j + k], 1ll * g[i][j] * g[i - 1][k] % mod);
    }
    for(int i = 0; i <= n; i++) {
        g[cnt][i] = 1ll * g[cnt][i] * fac[n - i] % mod;
        if(i + 1 & 1) ans = inc(ans, g[cnt][i]);
        else ans = inc(ans, mod - g[cnt][i]); 
     }
    cout << ans << endl;

}