2021年11月11日-K个逆序对数组

629. K个逆序对数组

• 使用动态规划求解，dp[i][j] 表示包含 1 - i 的数字的序列并且刚好拥有 j 个逆序对的个数

• 所以就有递推公式 dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1] + … + dp[i - 1][k]

• 在 dp[i - 1][k] 的情况下，加上数字 i，所能构成的逆序对最多为 k + i - 1 个，所以 k + i - 1 >= j

• 那么 k = Math.max(j + 1 - i, 0)

 class Solution {
    public int kInversePairs(int n, int k) {
         final int MOD = 1000_000_007;
        int[][] dp = new int[n + 1][k + 1];
        dp[1][0] = 1;
        for (int i = 1; i < dp.length; i++) {
            for (int j = 0; j < dp[0].length; j++) {
                int temp = Math.max(j + 1 - i, 0);
                for (int l = j; l >= temp ; l--) {
                    dp[i][j] += dp[i - 1][l];
                    dp[i][j] %= MOD;
                }
            }
        }
        return dp[n][k];
    }
}

不过上述代码会超时，仔细观察发现求 temp~j 的和可以转化为前缀和的做法求解来减少时间复杂度

class Solution {
    public int kInversePairs(int n, int k) {
        final int MOD = 1000_000_007;
        int[][] dp = new int[n + 1][k + 1];
        int[][] preSum = new int[2][dp[0].length];
        dp[1][0] = 1;
        for (int i = 1; i < dp.length; i++) {
            int now = i % 2;
            int last = (i - 1) % 2;
            for (int j = 0; j < dp[0].length; j++) {
                int temp = Math.max(j + 1 - i, 0);
                if (i == 1) {
                    for (int l = j; l >= temp; l--) {
                        dp[i][j] += dp[i - 1][l];
                        dp[i][j] %= MOD;
                    }
                } else {
                    // 注意这里的操作是为了避免因为 MOD 导致减法出现的问题
                    if (preSum[last][j] < preSum[last][temp]) {
                        dp[i][j] = (preSum[last][j] + MOD - preSum[last][temp] + dp[i - 1][temp]) % MOD;
                    } else {
                        dp[i][j] = (preSum[last][j] - preSum[last][temp] + dp[i - 1][temp]) % MOD;
                    }
                }
                if (j == 0) {
                    preSum[now][j] = dp[i][j];
                } else {
                    preSum[now][j] = preSum[now][j - 1] + dp[i][j];
                    preSum[now][j] %= MOD;
                }
            }
        }
        return dp[n][k];
    }
}

溢出真的难整，还有前缀和就因为写错个符号，找了我半天的错误◑﹏◐