K：leetcode 5381.查询带键的排列 这题简单，但我还能优化。精益求精，才是算法的乐趣所在！

前言：

本题来自leetcode第184场周赛的第二小题。以前参加过周赛，觉得很有趣。苦于最近一段时间比较忙就没坚持参加了(实际上是借口来着....)，由于昨晚思考一些事情，导致睡不着，所以起得有点早，就参加了本场周赛，然后就碰到了这道题。

这题本身并不难，但是在比赛结束后，参看了别人的题解。基本都是用暴力模拟的方式来解决的(虽然也能accept)，但本人觉得有着改进空间。为此，特地整理了思路，并将思路整理成文，以期能够共同获得进步。

为循序渐进的讲解该题，按照以往的习惯，先从最简单的方式入手，再逐步考虑优化。

题目:

给你一个待查数组 queries ，数组中的元素为 1 到 m 之间的正整数。 请你根据以下规则处理所有待查项 queries[i]（从 i=0 到 i=queries.length-1）：

一开始，排列 P=[1,2,3,...,m]。

对于当前的 i ，请你找出待查项 queries[i] 在排列 P 中的位置（下标从 0 开始），然后将其从原位置移动到排列 P 的起始位置（即下标为 0 处）。注意， queries[i] 在 P 中的位置就是 queries[i] 的查询结果。

请你以数组形式返回待查数组? queries 的查询结果。

示例 1：

输入：queries = [3,1,2,1], m = 5

输出：[2,1,2,1]

解释：待查数组 queries 处理如下：

对于 i=0: queries[i]=3, P=[1,2,3,4,5], 3 在 P 中的位置是 2，接着我们把 3 移动到 P 的起始位置，得到 P=[3,1,2,4,5] 。

对于 i=1: queries[i]=1, P=[3,1,2,4,5], 1 在 P 中的位置是 1，接着我们把 1 移动到 P 的起始位置，得到 P=[1,3,2,4,5] 。

对于 i=2: queries[i]=2, P=[1,3,2,4,5], 2 在 P 中的位置是 2，接着我们把 2 移动到 P 的起始位置，得到 P=[2,1,3,4,5] 。

对于 i=3: queries[i]=1, P=[2,1,3,4,5], 1 在 P 中的位置是 1，接着我们把 1 移动到 P 的起始位置，得到 P=[1,2,3,4,5] 。

因此，返回的结果数组为 [2,1,2,1] 。

示例 2：

输入：queries = [4,1,2,2], m = 4

输出：[3,1,2,0]

示例 3：

输入：queries = [7,5,5,8,3], m = 8

输出：[6,5,0,7,5]

数据结构：

List，Array

结合题意，因为要获取元素的下标值，为此，我们可以生成一个数组P，其包含了元素1~m，每次执行一次查找操作就遍历数组P，并把该元素的下标作为结果记录下来，之后将该元素提取到数组的起始位置。

以题干案例为例：

输入:queries=[3,1,2,1],m=5;

执行步骤如下：

1. 先生成数组P=[1,2,3,4,5]
2. 查找queries第1个元素3，遍历数组P后得到结果result=[2],之后修改数组P，将数组P中的元素3提到数组起始位置，之后数组P=[3,1,2,4,5]
3. 查找queries第2个元素1，遍历数组P后得到结果result=[2,1],之后修改数组P，将数组P中的元素1提到数组起始位置，之后数组P=[1,3,2,4,5]
4. 查找queries第3个元素2，遍历数组P后得到结果result=[2,1,2],之后修改数组P，将数组P中的元素2提到数组起始位置，之后数组P=[2,1,3,4,5]
5. 查找queries第4个元素1，遍历数组P后得到结果result=[2,1,2,1],之后修改数组P，将数组P中的元素1提取到数组起始位置，之后数组P=[1,2,3,4,5]

该过程的代码如下：

public?int[]?processQueries(int[]?queries,?int?m)?{
????//存放元素1~m的数组
????int[]?P?=?new?int[m];
????for(int?i=0;i<m;i++){
????????P[i]?=?i+1;
????}
????//用于存放结果
????int[]?result?=?new?int[queries.length];
????//遍历queries的元素
????for(int?i=0;i<queries.length;i++){
????????//查找元素在P中的下标
????????for(int?j?=0;j<P.length;j++){
????????????if(P[j]==queries[i]){
????????????????result[i]?=?j;
????????????????System.arraycopy(P,0,P,1,j);
????????????????P[0]?=?queries[i];
????????????????break;
????????????}
????????}
????}
????return?result;
}

分析：

很容易就可以分析出来，该算法的时间复杂度为O(nm)，空间复杂度为O(m)

那么，通过上面的分析过程，我们可以改进优化哪个点呢？很明显的，一个可以优化的地方是数组P。数组元素移动的次数与n成正比，每次将数组P中的第index个元素提取到起始位置，都需要将0~index-1的元素往后移动一位，并将第index元素插入到P[0]中。这种场景，采用链表的方式来解决，会更好，于是可以将代码改进为如下形式。

该过程的代码如下：

public?int[]?processQueries(int[]?queries,?int?m)?{
????int[]?result?=?new?int[queries.length];
????List<Integer>?P?=?new?LinkedList<Integer>();
????//生成数组P
????for(int?i=1;i<=m;i++){
????????P.add(i);
????}
????for(int?i=0;i<queries.length;i++){
????????int?index?=?P.indexOf(queries[i]);
????????result[i]?=?index;
????????P.remove(index);
????????P.add(0,queries[i]);
????}
????return?result;
}

分析：

改进了数据结构之后，算法的时间复杂度依旧为O(nm)，空间复杂度为O(m)，改进只是改进了时间复杂度的常系数。那么是否还有改进的空间呢？显然有，否则也不会有这文章。

我们换个思路来思考在数组P中查找元素下标的过程。首先，我们可以将数组P划分为两部分，一部分是已经查找过的queries[0]_{queries[index-1]的元素，我们**称这部分元素为A**，其必定排序在P的前面，且为乱序的。另一部分由剩下的其它元素所组成，我们**称这部分元素为B，其可能乱序也可能有序，但是元素必定是严格按照升序排列的**，也就是未出现在queries[0]}queries[index-1]中的元素。

我们还注意到几个情况

1. 当数组P完全有序时，即P=[1,2,3,4,...,m]，queries[index]在数组P中的下标是queries[index] -1。假设queries[index] == 2,则其结果应该返回1，所谓的元素在P中的下标，也就是元素queries[index]在P中前面有几个元素。
2. 当查找的元素在A中时，由于A为乱序的，为此我们只能遍历A，得到元素queries[index]的下标值进行返回。
3. 当要查找的元素在B中，且B为完全有序时，即P=[A,B]，B=[k,k+1,k+2,.....m]，则元素queries[index]在数组P中的下标为queries[index]-1。我们还可以知道，无论A的排列顺序为何种，均不影响结果。假设A=[2,1,4,3] ,B=[5,6,7,8,9]，queries[index]==6，则其结果为5。当A=[1,2,4,3]时，该结果返回依旧为5不变。
4. 当要查找的元素在B中，且B为部分有序(元素按照升序排列，但是会缺少部分值)时，即P=[A,B]，B=[k,k+1,k+2,k+4,k+5,...,m],此时我们应该返回的元素queries[index]在数组P中的下标为queries[index]-1+maxThanOnA,其中maxThanOnA为A中大于元素queries[index]值的数目，也就是B中大于queries[index]的值被移动到A中的元素个数。假设queries[index]== k+5，则其应当返回k+4，也就是queries[index]-1的值，因为B中的k+3被移动到A中了，无论其在哪个位置，都不影响k+5前面的元素个数这个结果。为此，下标依旧为queries[index]-1。当queries[index]==k+2时，由于元素k+3被移动到了A中，其使得元素k+2前面的元素个数多了一个，为此，其结果应该返回k+2。

综上分析，我们可以用一个List记录A中的元素的情况。当元素queries[index]在A中时，遍历A获取结果，并将进行查询的那个元素移动到A的起始位置中，否则，统计A中大于queries[index]的元素个数，直接返回queries[index]-1+maxThanOnA，并将queries[index]放置到A的起始位置中。

该算法的代码如下：

public?int[]?processQueries(int[]?queries,?int?m)?{
????//用于存放结果
????int[]?result?=?new?int[queries.length];
????//用于放置乱序(A)的那些个元素
????List<Integer>?list?=?new?LinkedList<Integer>();
????for(int?i=0;i<queries.length;i++){
????????//遍历乱序的元素的索引
????????int?index?=?0;
????????//记录列表中比当前元素大的元素个数
????????int?maxThanOnA?=?0;
????????while(index<list.size()){
????????????int?number?=?list.get(index);
????????????if(number?==?queries[i]){
????????????????result[i]?=?index;
????????????????list.remove(index);
????????????????list.add(0,number);
????????????????break;
????????????}else?if(number>queries[i]){
????????????????maxThanOnA++;
????????????}
????????????index++;
????????}
????????//在列表中找到了元素
????????if(index<list.size()){
????????????continue;
????????}
????????result[i]?=?queries[i]-1+maxThanOnA;
????????list.add(0,queries[i]);
????}
????return?result;
}

分析：

该算法的时间复杂度为O(n^2)，空间复杂度也为O(n)。

总结:

综上所述，当m>>>n时，时间复杂度为O(n)的算法更加有利。最坏情况下，也是m==n，此时，无论采取何种算法，时间复杂度为O(n^2)，空间复杂度为O(n)。

原文地址：https://www.cnblogs.com/MyStringIsNotNull/p/12687832.html