leetcode-查询带键的排列

 题目是LeetCode第184场周赛的第二题，链接：查询带键的排列。具体描述可见原题。

 首先就是暴力模仿法，根据题意直接模仿整个操作即可，当然这样的复杂度肯定是最高的。时间复杂度为$O(mn)$，空间复杂度为$O(m)$。

 JAVA版代码如下：

class Solution {
    public int[] processQueries(int[] queries, int m) {
        int[] P = new int[m];
        for (int i = 0; i < m; ++i) {
            P[i] = i + 1;
        }
        int[] result = new int[queries.length];
        for (int i = 0; i < queries.length; ++i) {
            int idx = 0;
            while (idx < m) {
                if (P[idx] == queries[i]) {
                    break;
                }
                else {
                    ++idx;
                }
            }
            result[i] = idx;
            int temp = P[idx];
            for (int j = idx; j >= 1; --j) {
                P[j] = P[j - 1];
            }
            P[0] = temp;
        }
        return result;
    }
}

 提交结果如下:

 然后是树状数组的方法，这里的树状数组用于记录各个位置上是否有数字，有数字即为1，否则为0，那么这样从1到i这一段的区间和getSum(i)得到的就是树状数组中索引为i的数前面（包括自身）一共有多少个数，也就是说这个数在数组P中的索引就是getSum(i)-1。为了避免频繁的数组移动，这里开辟了一个大小为n+m+1的树状数组，初始化的时候我们把P中的m个数放到树状数组的最后面（不是真的放，就是置1罢了，也就是update(n + i, 1)）同时记录这个数值到位置的映射关系（即value2index[i] = n + i）。然后对于queries的每个数，做如下操作：

• 获取queries[i]在树状数组中的位置indexQuery = value2index[queries[i]]
• 获得queries[i]在数组P中的索引getSum(indexQuery)-1并加入结果数组
• 把queries[i]从树状数组中原本位置中删除（即update(indexQuery, -1)），然后再加到新的起始位置n-i上去（即update(n - i, 1)），同时需要更新映射关系（value2index[queries[i]] = n - i）

 在树状数组中操作的时间复杂度为$O(log(m+n))$，所以总的时间复杂度为$O(nlog(m+n))$，空间复杂度为$O(m+n)$。

 JAVA版代码如下：

class Solution {
    // 树状数组
    private int[] tree;

    private int lowbit(int x) {
        return x & (-x);
    }

    // 树状数组的更新操作，将idx位置上的数加上value
    private void update(int idx, int value) {
        while (idx < tree.length) {
            tree[idx] += value;
            idx += lowbit(idx);
        }
    }

    // 数组数组的区间查询，返回从1到idx区间的和
    private int getSum(int idx) {
        int sum = 0;
        while (idx > 0) {
            sum += tree[idx];
            idx -= lowbit(idx);
        }
        return sum;
    }

    public int[] processQueries(int[] queries, int m) {
        int n = queries.length;
        // 用一个树状数组，数组从1-i的区间和getSum(i)代表在i前面有多少个数（包括自身）
        // 所以一个数对应到P中的真实索引就是getSum(i)-1
        tree = new int[n + m + 1];
        // P中的1-m这m个数到其在树状数组中索引的一个映射
        int[] value2index = new int[m + 1];
        for (int i = 1; i <= m; ++i) {
            // 初始化，把P中m个数先放到树状数组的后m个位置
            value2index[i] = n + i;
            update(n + i, 1);
        }

        int[] result = new int[n];
        for (int i = 0; i < n; ++i) {
            int indexQuery = value2index[queries[i]];
            result[i] = getSum(indexQuery) - 1;
            // 把位置indexQuery上的数给移动到起始位置，当前位置的数删除，所以需要-1
            update(indexQuery, -1);
            // 放置这个被删除的数的起始位置
            value2index[queries[i]] = n - i;
            // 需要重新从起始位置开始更新树状数组
            update(n - i, 1);
        }
        return result;
    }
}

 提交结果如下:

 Python版代码如下：

class Solution:
    def processQueries(self, queries: List[int], m: int) -> List[int]:
        n = len(queries)
        tree = [0 for _ in range(n + m + 1)]

        def lowbit(x):
            return x & (-x)

        def update(idx, value):
            while idx <= n + m:
                tree[idx] += value
                idx += lowbit(idx)
        
        def getSum(idx):
            s = 0
            while idx > 0:
                s += tree[idx]
                idx -= lowbit(idx)
            return s

        value2index = [n + i for i in range(m + 1)]
        for i in range(n + 1, n + m + 1):
            update(i, 1)
        
        result = []
        for i in range(n):
            indexQuery = value2index[queries[i]]
            result.append(getSum(indexQuery) - 1)
            update(indexQuery, -1)
            update(n - i, 1)
            value2index[queries[i]] = n - i

        return result

 提交结果如下: