• 題意:

  如果一個 \(1\to N\) 的排列 \(P=[P_1, P_2, ... P_N]\) 中的任意元素 \(P_i\) 都滿足 \(|P_i-i| ≤ K\) ，我們就稱 \(P\) 是 \(K\)-偏差排列。
  給定 \(N\) 和 \(K\) ，請你計算一共有少個不同的排列是 \(K\)-偏差排列。
  例如對於 \(N=3\) ，有 \(3\) 個 \(1\)-偏差排列：\([1, 2, 3], [1, 3, 2], [2, 1, 3]\)。
  由於答案可能非常大，你只需要輸出答案模 \(1000000007\) 的余數。
  對於 \(70\%\) 的數據，\(1 ≤ N ≤ 1000\)
  對於 \(100\%\)

  的數據，\(1 ≤ N ≤ 1000000000, 1 ≤ K ≤ 3\)

• 題解:

  一道好題~
  這是它的最初版本 #1732 : 1-偏差排列 ．
  那個找規律就是 斐波那契數列 了, dp 的話也是一樣的結果 .

  對於這個題我們可以沿用那題思路, 考慮一個位置 \(i\) 能放哪些數, 根據定義能放 \([i-k, i+k]\) 中共 \(2k+1\) 個數.
  考慮狀壓到 \(i\) 這個點, 這些數中的哪些被放了, 每次轉移的時候考慮放入一個數, 這個數之前不能出現, 這樣就是合法轉移了.
  最後到 \(n\) 的時候, 不能放比 \(n\) 大的數, 且小於等於 \(n\) 的數都要放進去, 只會有那個位置存在正確答案, 這個狀態 \(sta=2 ^ {k + 1} - 1\)

  (也就是意味著 \([n - k, n]\)都得選) .
  當 \(n < k\) 的時候要特判掉一些詭異的特殊情況 .

  然後這樣直接寫就有 \(70pts\) 了.
  有一些不合法狀態不能轉移, 也就是要放的數不存在於 \([1, n]\) 之間.

  這樣的話, 就是矩陣快速冪套路優化了, 考慮對這個轉移系數建立矩陣, 然後它的 \(n\) 次冪中的 \((sta,sta)\) 這個位置就會存在最後的答案咯...

• 代碼:

  70pts:

  #include <bits/stdc++.h>
  #define For(i, l, r) for(register int i = (l), i##end = (int)(r); i <= i##end; ++i)
   
  
  using namespace std;
  
  typedef long long ll;
  
  const ll Mod = 1e9 + 7;
  
  int n, k, all;
  ll ans = 0, dp[2][1500] = {0};
  
  int main () {
      cin >> n >> k;
      if (n <= 2) return printf ("%d\n", n), 0;
  
      all = (1 << (2 * k + 1)) - 1;
  
      dp[0][0] = 1;
  
      int cur = 0;
      For (i, 1, n) {
          For (j, 0, all) if(dp[cur][j]) {
              int sta = (j >> 1);
  
              For (s, 0, 2 * k) if (!(sta & (1 << s))) {
                  int tmp = i - k + s;
                  if (tmp < 1 || tmp > n) continue ;
  
                  (dp[cur ^ 1][sta | (1 << s)] += dp[cur][j]) %= Mod;
              }
  
              dp[cur][j] = 0;
          }
          cur ^= 1;
      }
  
      int Sta = (1 << (k + 1)) - 1;
  
      printf ("%lld\n", dp[cur][Sta]);
      return 0;
  }

  100pts:

  #include <bits/stdc++.h>
  #define For(i, l, r) for(register int i = (l), i##end = (int)(r); i <= i##end; ++i)
  #define Set(a, v) memset(a, v, sizeof(a))
  using namespace std;
  
  void File() {
  #ifdef zjp_shadow
      freopen ("P1743.in", "r", stdin);
      freopen ("P1743.out", "w", stdout);
  #endif
  }
  
  const int Mod = 1e9 + 7, Maxn = 130;
  
  int n, k, all;
  
  struct Matrix {
      int a[Maxn][Maxn]; Matrix() { Set(a, 0); }
      void Unit() { For (i, 0, all) a[i][i] = 1; }
  };
  
  inline Matrix operator * (Matrix a, Matrix b) {
      Matrix res;
      For (i, 0, all) For (k, 0, all) if (a.a[i][k])
          For (j, 0, all) (res.a[i][j] += 1ll * a.a[i][k] * b.a[k][j] % Mod) %= Mod;
      return res;
  }
  
  inline Matrix fpm(Matrix x, int power) {
      Matrix res; res.Unit();
      for (; power; power >>= 1, x = x * x)
          if (power & 1) res = res * x;
      return res;
  }
  
  Matrix Bas, Ans;
  
  int ans = 0;
  
  int main () {
      File();
  
      cin >> n >> k;
  
      if (n <= 2) return printf ("%d\n", n), 0;
  
      all = (1 << (2 * k + 1)) - 1;
  
      For (i, 0, all) {
          int j = (i >> 1);
          For (s, 0, 2 * k) if (!(j & (1 << s))) 
              ++ Bas.a[i][j | (1 << s)];
      }
      Ans = fpm(Bas, n);
  
      int Sta = (1 << (k + 1)) - 1;
  
      printf ("%d\n", Ans.a[Sta][Sta]);
  
      return 0;
  }

hihoCoder#1743:K-偏差排列（矩陣快速冪+狀壓dp）