JAVA程序设计：K个逆序对数组（LeetCode：629）

给出两个整数 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]。

思路：经典动态规划。

      我们用 f(i, j) 表示数字 [1 .. i] 的排列中恰好包含 j 个逆序对的个数。在状态转移时，我们考虑数 i 放置的位置与逆序对个数的关系。我们在数字 [1 .. i - 1] 组成的排列中放入 i 时，有 i 种放置方法：如果将 i 放在最后，则逆序对数量不变；如果将 i 放在倒数第二个，则逆序对数量增加 1；如果将 i 放在第一个，则逆序对数量增加 i - 1。这是因为 i 是 [1 .. i] 中的最大值，因此将它放置在 [1 .. i - 1] 的排列中的任意一个位置，它都会与在它之后的那些数形成逆序对。如果它后面有 k 个数，则会形成 k 个逆序对。

因此我们可以写出状态转移方程：

f(i, j) = f(i - 1, j) + f(i - 1, j - 1) + ... + f(i - 1, j - i + 1)

但是该状态转移会导致算法复杂度达到O(n*n*k)，超时是必然的，此时我们要考虑的问题是如何优化它。

我们比较f(i,j)和f(i,j-1)： 

                                  

此时，我们可以通过O(n*k)的复杂度完成状态的转移啦

class Solution {
	
	private int mod=1000000007;
	
    public int kInversePairs(int n, int k) {
        
    	int[][] dp=new int[n+1][k+1];
        
        for(int i=1;i<=n;i++)
        	for(int j=0;j<=k && j<=i*(i-1)/2;j++) {
        		if(i==1 && j==0) {dp[i][j]=1;break;}
        		else if(j==0) dp[i][j]=1;
        		else dp[i][j]=((dp[i][j-1]+dp[i-1][j])%mod+mod-((j-i)>=0?dp[i-1][j-i]:0))%mod;
        	}
        
        return dp[n][k];
    }
}