根据给定条件在 Q 查询后查找 Array 元素

给定一个长度为N的数组arr[]和 3 种类型（1、2、3）的Q个查询，其操作如下：

• 类型 1：查询的输入为1 ，任务是反转数组。
• 类型 2：查询的输入为(2 x) ，任务是在结果数组中查找x的索引。
• 类型 3：查询的输入为(3 xy) ，任务是交换数组中索引x和y处的元素。

任务是打印类型 2查询的结果。

例子：

Input: N = 5, arr[] = {3, 7, 8, 1, 33}, Q = 4, Queries[][] = {{1}, {2, 8}, {3, 2, 4}, {2, 1}
Output: 2 1
Explanation: Process query wise first is 1 so reverse the list [33, 1, 8, 7, 3], Second query 2 8 so find index of element 8 which is 2, third query is 3 2 4 so swap 2nd and 4th index new array=[33, 1, 3, 7, 8] now the last query is 2 1 so find index of element 1 which is 1 so output 2 1.

Input: N = 6, arr[] = {6, 33, 9, 22, 45, 4}, Q = 5, Queries[][] = {{1}, {3, 0, 4}, {2, 33}, {1}, {2, 9}}
Output: 0 2

方法：给定的问题可以基于每个查询的以下假设来解决：

• 使用变量flag =1 并且对于类型为1的每个查询，将flag * -1相乘，这样对于负数，它表示列表的反转并以相反的顺序操作计算，而不是直接反转数组，这样可以降低时间复杂度。
• 现在对于类型3 xy的查询，使用 map 数据结构将索引和元素存储为键值对，并直接交换O(1)中的值。
• 最后对于类型2 x的查询直接获取索引。

请按照以下步骤解决问题：

• 初始化 map mp = {}以将元素及其索引作为键值对存储在数组中。
• 将变量flag初始化为1 ，以跟踪数组反转的次数。
• 使用变量i遍历范围[0, Q)并执行以下任务：
  • 首先，在将每个查询作为输入时检查查询的类型。
  • 对于类型 1查询，而不是手动反转会增加时间复杂度，更改变量标志的符号以表示数组是正常的或反转的。
  • 对于类型 2查询，从映射中找到给定值的索引，如果数组没有反转，则打印m[x]的值作为结果。否则，打印(N – m[x] – 1)的值。
  • 对于类型 3查询，首先找到给定索引处的值，然后分别交换列表和映射中的值和索引。

下面是上述方法的实现：

Python3

# Python program for the above approach
  
# Function to perform the given queries
# and print the result accordingly
def arrayManipulation(n, arr, q, qarr):
  
    # Stores the index value pair
    mp = {}
    ans = []
  
    # Flag to indicate reversal
    flg = 1
    for i in range(n):
        mp[arr[i]] = i
  
    # Processing each query
    for i in range(q):
        a = qarr[i]
  
        # Type 1 flag multiplied -1
        if(a[0] == 1):
            flg *= -1
              
        # Type 2 query taking index
        # value acc. to flag sign
        elif(a[0] == 2):
            x = a[1]
            if(flg == -1):
                ans.append(n-mp[x]-1)
            else:
                ans.append(mp[x])
                  
        # Type 3 query swaping value
        # directly in map
        else:
            x = a[1]
            y = a[2]
  
            # Stores the value to swap
            # and update the array
            x1 = a[1]
            y1 = a[2]
            if(flg == -1):
                y = n-y-1
                x = n-x-1
  
            # Value swapped and store
            # value to swap and update
            # the map
            y = arr[y]
            x = arr[x]
  
            # Index swapped
            arr[x1], arr[y1] = arr[y1], arr[x1]
            mp[x], mp[y] = mp[y], mp[x]
  
    # Print the result for queries
    print(*ans)
  
  
# Driver Code
N = 6
arr = [6, 33, 9, 22, 45, 4]
Q = 5
Queries = [[1], [3, 0, 4], [2, 33], [1], [2, 9]]
  
# Function Call
arrayManipulation(N, arr, Q, Queries)

输出：

0 2

时间复杂度： O(max(N, Q))
辅助空间： O(N)