【面试高频题】难度 4/5，经典“逆序对”面试题

原创

宫水三叶 2023-04-09 09:50:06 ©著作权

文章标签 后端 Java 算法逆序对数组 文章分类 Python 后端开发

©著作权归作者所有：来自51CTO博客作者宫水三叶的原创作品，请联系作者获取转载授权，否则将追究法律责任

题目描述

这是 LeetCode 上的 629. K个逆序对数组 ，难度为困难。

Tag : 「序列 DP」、「前缀和」

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

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

由于答案可能很大，只需要返回答案 mod $【面试高频题】难度 4/5，经典“逆序对”面试题_Java$

示例 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]。

序列 DP

从 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_02$ 和 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_03$ 数据范围均为 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_04$

定义 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_05$ 为考虑使用数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_逆序对_06$ ，凑成逆序对数量恰好为 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_07$

不失一般性的考虑 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_05$ 该如何计算，对第 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 个数（即数值为 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 的数）所在位置进行讨论，共有 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$

假设第 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 个数所在位置为 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_03$ ，由于数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 为整个数组的最大值，因此数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 与前面所有数均不形成逆序对，与后面的所有数均形成逆序对。因此与数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 直接相关的逆向对的数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_17$ ，由此也得出与 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 不相关的逆序对数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_19$ ，而与 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 不相关的逆序对数量由 $【面试高频题】难度 4/5，经典“逆序对”面试题_逆序对_21$

举个 🌰 帮助大家理解：

当数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 放置在下标为 $【面试高频题】难度 4/5，经典“逆序对”面试题_逆序对_23$ 的位置上，那么由数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 产生的逆序对数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_Java_25$ ，总的逆序对数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_07$ ，因此由数值范围为 $【面试高频题】难度 4/5，经典“逆序对”面试题_Java_27$ （与数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 不相关）构成的逆序对数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_29$ ，即 $【面试高频题】难度 4/5，经典“逆序对”面试题_Java_30$ ；
当数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 放置在下标为 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_32$ 的位置上，那么由数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 产生的逆序对数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_34$ ，总的逆序对数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_07$ ，因此由数值范围为 $【面试高频题】难度 4/5，经典“逆序对”面试题_Java_27$ （与数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 不相关）构成的逆序对数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_38$ ，即 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_39$ ；
...
当数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 放置在下标为 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_03$ 的位置上，那么由数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 产生的逆序对数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_逆序对_43$ ，总的逆序对数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_07$ ，因此由数值范围为 $【面试高频题】难度 4/5，经典“逆序对”面试题_Java_27$ （与数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 不相关）构成的逆序对数量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_19$ ，即 $【面试高频题】难度 4/5，经典“逆序对”面试题_Java_48$ 。

综上，最终 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_05$ 转移方程为（ $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_03$ 为数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$

$【面试高频题】难度 4/5，经典“逆序对”面试题_数组_52$

共有 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_53$ 个状态，每个 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_05$ 的计算需要枚举数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 所在位置并进行累加，总的复杂度为 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_56$ ，计算量为 $【面试高频题】难度 4/5，经典“逆序对”面试题_后端_57$ ，会 TLE。

状态数量不可减少，考虑如何优化单个状态的转移过程。

不难发现 $【面试高频题】难度 4/5，经典“逆序对”面试题_Java_58$ 部分为上一次转移结果 $【面试高频题】难度 4/5，经典“逆序对”面试题_逆序对_21$ 的某个前缀，可以使用前缀和数组进行优化，从而将计算单个状态的复杂度从 $【面试高频题】难度 4/5，经典“逆序对”面试题_Java_60$ 降到 $【面试高频题】难度 4/5，经典“逆序对”面试题_Java_61$ 。

一些细节：为处理负数问题，我们可以在取模之前先加一次 mod；另外需要对 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_07$ 和 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 的大小进行分情况讨论，防止数值 $【面试高频题】难度 4/5，经典“逆序对”面试题_数组_09$ 放置的位置“过于靠前”导致组成逆序对的数量超过 $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_07$ 。

代码（ $【面试高频题】难度 4/5，经典“逆序对”面试题_Java_66$ $【面试高频题】难度 4/5，经典“逆序对”面试题_算法_67$ 分别为使用 long 和不使用 long）：

class Solution {
    int mod = (int)1e9+7;
    public int kInversePairs(int n, int k) {
        long[][] f = new long[n + 1][k + 1];
        long[][] sum = new long[n + 1][k + 1];
        f[1][0] = 1;
        Arrays.fill(sum[1], 1);
        for (int i = 2; i <= n; i++) {
            for (int j = 0; j <= k; j++) {
                f[i][j] = j < i ? sum[i - 1][j] : sum[i - 1][j] - sum[i - 1][j - (i - 1) - 1];
                f[i][j] = (f[i][j] + mod) % mod;
                sum[i][j] = j == 0 ? f[i][j] : sum[i][j - 1] + f[i][j];
                sum[i][j] = (sum[i][j] + mod) % mod;
            }
        }
        return (int)f[n][k];
    }
}

class Solution {
    int mod = (int)1e9+7;
    public int kInversePairs(int n, int k) {
        int[][] f = new int[n + 1][k + 1];
        int[][] sum = new int[n + 1][k + 1];
        f[1][0] = 1;
        Arrays.fill(sum[1], 1);
        for (int i = 2; i <= n; i++) {
            for (int j = 0; j <= k; j++) {
                f[i][j] = j < i ? sum[i - 1][j] : (sum[i - 1][j] - sum[i - 1][j - (i - 1) - 1] + mod) % mod;
                sum[i][j] = j == 0 ? f[i][j] : (sum[i][j - 1] + f[i][j]) % mod;
            }
        }
        return f[n][k];
    }
}