【Leetcode】634. Find the Derangement of An Array

题目地址：

https://leetcode.com/problems/find-the-derangement-of-an-array/

求$n$个元素的错排数。

法1：动态规划。设$f[n]$是$n$元错排数。设$a_1,a_2,...,a_n$是个错排，那么$a_n\ne n$，如果$a_k=n$，我们考虑$k$放在了哪儿。如果$a_n=k$，那么其余的数的错排方案数就是$f[n-2]$；如果$a_n\ne k$，那么对于$n-1$个数的每一个错排，都可以将这个错排中的$a_k$换到$a_n$那里去，所以此时有$f[n-1]$个错排。综上$$f[n]=(n-1)(f[n-1]+f[n-2])$$初始条件$f[1]=0$，注意$f[0]$应该取$1$，错排的定义是$\forall a_i,a_i\ne i$，这对于空集是成立的。代码如下：

public class Solution {
    public int findDerangement(int n) {
        int MOD = (int) (1E9 + 7);
        long[] dp = new long[n + 1];
        dp[0] = 1;
        dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            dp[i] = (i - 1) * (dp[i - 1] + dp[i - 2]);
            dp[i] %= MOD;
        }
        
        return (int) dp[n];
    }
}

时空复杂度$O(n)$。

考虑滚动数组优化：

public class Solution {
    public int findDerangement(int n) {
        int MOD = (int) (1E9 + 7);
        long[] dp = new long[2];
        dp[0] = 1;
        dp[1] = 0;
        for (int i = 2; i <= n; i++) {
            dp[i & 1] = (i - 1) * (dp[i - 1 & 1] + dp[i - 2 & 1]);
            dp[i & 1] %= MOD;
        }
        
        return (int) dp[n & 1];
    }
}

时间复杂度不变，空间$O(1)$。

法2：直接用数学公式算。有若干种办法求这个公式。这里介绍一个概率论的方法。设$A_i$为事件$a_i=i$，那么相当于要求$$1-P(\bigcup _{i=1}^n{A}_i)$$而由容斥原理，有：$$\begin{gathered} P(\bigcup _{i=1}^n{A}_i)=\sum _{i}P(A_i)-\sum _{i_1<i_2}P(A_{i_1}{A}_{i_2})+ \\ \sum _{i_1<i_2<i_3}P(A_{i_1}{A}_{i_2}{A}_{i_3})-...+(-1{)}^{n-1}P(A_{i_1}...A_{i_n}) \end{gathered}$$由对称性，$P(A_i)=\frac{1}{n},P(A_i{A}_j)=\frac{1}{n(n-1)},...,P(A_1{A}_2...A_n)=\frac{1}{n!}$，所以$$P(\bigcup _{i=1}^n{A}_i)=1-\frac{1}{2!}+\frac{1}{3!}-\frac{1}{4!}+...+(-1{)}^{n-1}\frac{1}{n!}$$而事件的总数是$n!$，所以错排数就是$$n!(\frac{1}{2!}-\frac{1}{3!}+\frac{1}{4!}-...+(-1{)}^n\frac{1}{n!})$$代码如下：

public class Solution {
    public int findDerangement(int n) {
        if (n == 1) {
            return 0;
        }
        if (n == 2) {
            return 1;
        }
        
        int MOD = (int) (1E9+7);
        long fac = 1, res = 0;
        for (int i = n; i >= 0; i--) {
            res = (res + fac * (i % 2 == 0 ? 1 : -1) + MOD) % MOD;
            fac = (fac * i) % MOD;
        }
        
        return (int) ((res + MOD) % MOD);
    }
}

时间复杂度一样，空间$O(1)$。