Leetcode 629

题意

题目链接
从$1$到$N$一共$N$个数组成的一个数组，求逆序对为$m$的方法数有多少个

思路

动态规划

定义$dp[i][j]$表示前$i$个数(也就是$1$到$i$)组成的数组中逆序对为$j$的方法数，考虑把数字$i+1$放置在数组的最前面，那么会增加$i$个逆序对;如果放在第一个数之后，会增加$i-1$个逆序对,以此类推，如果放置在最后，那么会增加$0$个逆序对,因此我们有如下的方程
$$dp[i][j]=\sum _{k=0}^{i-1}dp[i-1][j-k]$$
因此我们可以写出如下的代码

    public int kInversePairs_2(int n, int k) {
        //dp[i][j]: 前i个数的逆序对为j的方案数
        //dp[i][j] = dp[i-1][j-k] k∈(0, i-1)
        int[][] dp = new int[n + 5][k + 5];
        int mod = 10_0000_0007;
        dp[1][0] = 1;
        for (int i = 2; i <= n; i++) {
            for (int j = 0; j <= k; j++) {
                if (j > (i - 1) * i / 2) dp[i][j] = 0;
                else if (j == 0) dp[i][j] = 1;
                else {
                    for (int kk = 0; kk <= i - 1; kk++) {
                        if (j - kk < 0) break;
                        dp[i][j] += dp[i - 1][j - kk];
                        dp[i][j] %= mod;
                    }
                }
            }
        }
        return dp[n][k];
    }

这个代码的时间复杂度是$O(N^3)$的,直接提交会得到一个$TLE$(时间超时)的答案

优化

下面我们进行优化如上的$dp$方程
$$\begin{array}{rl}dp[i][j]& =\sum _{k=0}^{i-1}dp[i-1][j-k]\\ & =\sum _{k=1}^{i}dp[i-1][j-k]+dp[i-1][j]-dp[i-1][j-i]\\ & =\sum _{k=0}^{i}dp[i-1][j-1-k]+dp[i-1][j]-dp[i-1][j-i]\\ & =dp[i][j-1]+dp[i-1][j]-dp[i-1][j-i]\end{array}$$
注意在写代码的时候$dp[i-1][j-i]$这一项要保证 $j-i>0$
代码如下

    public int kInversePairs(int n, int k) {
        //dp[i][j]: 前i个数的逆序对为j的方案数
        //dp[i][j] = dp[i-1][j-1] + dp[i-1][j] - dp[i-1][j-i];
        int[][] dp = new int[n + 5][k + 5];
        int mod = 10_0000_0007;
        dp[1][0] = 1;
        for (int i = 2; i <= n; i++) {
            for (int j = 0; j <= k; j++) {
                if (j > (i - 1) * i / 2) dp[i][j] = 0;
                else if (j == 0) dp[i][j] = 1;
                else {
                    dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
                    dp[i][j] %= mod;
                    if (j - i >= 0) {
                        dp[i][j] -= dp[i - 1][j - i];
                        dp[i][j] += mod;
                        dp[i][j] %= mod;
                    }
                }
            }
        }
        return dp[n][k];
    }

时间复杂度为$O(N^2)$