LeetCode 629. K个逆序对数组（DP）

1. 题目

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

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

由于答案可能很大，只需要返回 答案 mod 10⁹ + 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
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2. 动态规划

• $f(i,j)$表示i个数，j个逆序对的组合方式种类
• i个数的j个逆序对的组合，可以在i-1个数的基础上得到
• 把第i个数插入到前面i-1的i个空位上，相应的逆序数会变化
• f(i - 1, j)插在最后，逆序增加0，插在倒数第1个前面，逆序数为1，为保持总逆序数j，那i-1个数的逆序数为j-1，依次类推
• $f(i,j)=f(i-1,j)+f(i-1,j-1)+...+f(i-1,j-i+1)$

class Solution {
public:
    int kInversePairs(int n, int k) {
        //f(i,j)表示i个数，j个逆序对的组合方式
        //f(i, j) = f(i - 1, j) + f(i - 1, j - 1) + ... + f(i - 1, j - i + 1)
        int dp[n+1][k+1] = {0};
        int i, j, time, idx;
        for(i = 1; i <= n; i++)
        	dp[i][0] = 1;
        for(i = 2; i <= n; i++)
        {
        	for(j = 1; j <= k; j++)
        	{
        		time = i;
        		idx = j;
        		while(time-- && idx >= 0)
        		{
        			dp[i][j] += dp[i-1][idx];
        			dp[i][j] %= 1000000007;
        			idx--;
        		}
        	}
        }
        return dp[n][k];
    }
};

时间复杂度 $O(k\ast n^2)$

3. 优化的DP

• $f(i,j)=f(i-1,j)+f(i-1,j-1)+...+f(i-1,j-i+1)$
• 代入j=j-1到上式
• $f(i,j-1)=f(i-1,j-1)+f(i-1,j-2)+...+f(i-1,j-i)$
• 做差，$f(i,j)-f(i,j-1)=f(i-1,j)-f(i-1,j-i)$
• 即 $f(i,j)=f(i,j-1)+f(i-1,j)-f(i-1,j-i)$

class Solution {
public:
    int kInversePairs(int n, int k) {
        int dp[n+1][k+1] = {0};
        int i, j, maxk, M = 1000000007;
        for(i = 1; i <= n; i++)
        	dp[i][0] = 1;
        for(i = 2; i <= n; i++)
        {
        	maxk = i*(i-1)/2;//最大的逆序数
        	for(j = 1; j <= k && j <= maxk; j++)
        	{
    			dp[i][j] = dp[i][j-1]%M + (M + dp[i-1][j]-(j>=i ? dp[i-1][j-i]:0))%M;
    			//dp[i-1][j] 不一定比 dp[i-1][j-i] 大（正态分布），+M防止负数
    			dp[i][j] %= M;
        	}
        }
        return dp[n][k];
    }
};

时间复杂度 $O(k\ast n)$