【LeetCode 629】K个逆序对数组——DP动态规划+优化

一、题目

给出两个整数 n 和 k，找出所有包含从 1 到 n 的数字，且恰好拥有 k 个逆序对的不同的数组的个数。

逆序对的定义如下：对于数组的第i个和第 j个元素，如果满i < j且 a[i] > a[j]，则其为一个逆序对；否则不是。

由于答案可能很大，只需要返回 答案 mod 109 + 7 的值。

示例 1:

输入: n = 3, k = 0
输出: 1
解释: 
只有数组 [1,2,3] 包含了从1到3的整数并且正好拥有 0 个逆序对。
示例 2:

输入: n = 3, k = 1
输出: 2
解释: 
数组 [1,3,2] 和 [2,1,3] 都有 1 个逆序对。
说明:

 n 的范围是 [1, 1000] 并且 k 的范围是 [0, 1000]。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/k-inverse-pairs-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、效率

 

三、代码

class Solution {
public:
    int kInversePairs(int n, int k) 
    {
        int mod = (int)1e9 + 7;
        // dp[i][j]代表[1..i]中有j个逆序对的不同数组的个数
        // vector<vector<int>> dp(n + 1, vector<int>(k + 1, 0));

        int** dp = new int* [n + 1];
        for (int i = 0; i <= n; ++i)
            dp[i] = new int[k + 1]();

        // [1]中有0个逆序对的数组的个数为1
        dp[1][0] = 1;
        for (int i = 2; i <= n; ++i)
        {
            // [1...i]中最多有(i - 1) * i / 2个逆序对，即[i, i - 1, i - 2 ... 3, 2, 1]
            // [i, i - 1, i - 2 ... 3, 2, 1]中共有(i - 1) + (i - 2) + ... + 3 + 2 + 1 = (i - 1) * i / 2个逆序对
            int max = (i - 1) * i / 2;
            // 优化for循环终止条件，因为j <= k && j <= max
            max = max < k ? max : k;
            long long sum = 0;  // 利用sum进行优化

            // for (int j = 0; j <= k && j <= max; ++j)
            for (int j = 0; j <= max; ++j)
            {
                /*
                // m代表在i后面有几个数（i是[i ... i]中最大的数）
                // 例如数组xx...xx i xxx(一共有i-1个x，i为最大值),假设xx...x(一共i-1个x)的逆序对为n个,此时m为3
                // 则xx...xx i xxx的逆序对有n + 3个，因为只有3个数在i后面，并且都小于i
                // 那么，反过来，如果要求逆序对为j个有多少种不同数组，则需要求m = 0, 1, .. j时，dp[i-1][j-m]的值分别是多少，并加起来
                // 因为，dp[i-1][j-m]的逆序对为j-m，当i插入xxx...xxx(一共有i - 1个x)中（即为 xxx...x i xx..x）并且i后面有m个数时
                // 新的排列的逆序对为j - m + m = j个,即dp[i-1][j-m]的值为dp[i][j]的一部分，因为m可以为0,1,2...(注意，m不可能大于i-1)
                // 当把所有的dp[i - 1][j - m]加起来时，则是dp[i][j]的值
                for (int m = 0; m <= j && m < i; ++m)
                {
                    dp[i][j] += dp[i - 1][j - m];
                    dp[i][j] %= mod;
                }  
                */

                // 利用sum对上面的for循环进行优化
                // 由于每次求和，当j < i时，都只增加dp[i - 1][j]，对此进行优化
                if (j < i)
                {
                    sum += dp[i - 1][j];
                }
                else
                {
                    sum += dp[i - 1][j];
                    sum -= dp[i - 1][j - i];
                }
                dp[i][j] = sum % mod;   // 不能用sum对mod取余，因为sum可能要减去dp[i - 1][j - i]，取余后再减可能为负数
            }
        }        

        int res = dp[n][k];

        for (int i = 0; i <= n; ++i)
            delete[] dp[i];

        delete[] dp;

        return res;
    }
};