hihoCoder#1743:K-偏差排列（矩阵快速幂+状压dp）

题意

如果一个 $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;
}

__EOF__

本文作者：zjp_shadow
本文链接：https://www.cnblogs.com/zjp-shadow/p/9042753.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！