对于给定数组中的 Q 查询，将所有出现的 X 替换为 Y

给定一个数组arr[]和一个由查询组成的二维数组query[][] 。对于每个查询q ，将arr[]中所有出现的query[i][0]替换为 query [i][1] 。

例子：

Input: arr[] = {2, 2, 5, 1} query = {{2, 4}, {5, 2}}
Output: {4, 4, 2, 1}
Explanation: Following are the operations performed in the given array according to the queries given.
For first query {2, 4}, replace all occurrences of 2 in arr[] with 4. arr[] will be updated as arr[] = {4, 4, 5, 1}. 
For second query {5, 2}, replace all occurrences of 5 with 2. arr[] will be updated as arr[] = {4, 4, 2, 1}.

Input: arr[] ={2, 2, 5}, query = {{4, 5}, {2, 5}, {1, 3}, {2, 4}}
Output: {5, 5, 5}

天真的方法：（蛮力解决方案）天真的方法是遍历 query 的所有查询，并且对于每个query[i][0] ，在arr[]中找到它的所有出现，并将其替换为query[i ][1] 。

时间复杂度： O(N*Q)，其中 N 是 arr[] 的大小，Q 是 query[][] 的大小。
辅助空间： O(1)

有效方法：更好的解决方案是使用 Hashmap，它存储数组中元素的索引。请按照以下步骤解决给定的问题。

• 初始化一个hashmap = {} ，并用数组元素作为键填充它，并列出它在数组中的位置。
• 遍历query[][]的每个查询q 。
  • 如果q[0]存在于hashmap中，
    • 如果q[1]存在于hashmap中，则将q[0]的值扩展为q[1]键的值。
    • 否则，使用 q[0] 键的值将值添加到q[1]键。
    • 从hashmap中删除 q[0] 的键值对。
• 现在，从hashmap的值创建一个新的变量map = {} 。
• 交换键值对，使map包含键值对作为索引，以及hashmap的键值。
• 使用此映射，我们现在可以通过使用映射中的值更新arr的每个位置的值来更新原始数组arr 。

下面是上述方法的实现：

C++

// C++ program for above approach
#include 
using namespace std;
 
// Function to replace all the
// occurrences of a number with
// another given number for Q queries
void update(vector& A, int N, vector >& Q)
{
   
    // Creating a hashmap
    map > hashmap;
    for (int i = 0; i < N; ++i) {
        hashmap[A[i]].push_back(i);
    }
 
    // Iterating with q in given queries
    for (auto q : Q) {
        if (hashmap.count(q[0])) {
            if (hashmap.count(q[1]))
                hashmap[q[1]].insert(hashmap[q[1]].end(),
                                     hashmap[q[0]].begin(),
                                     hashmap[q[0]].end());
            else
                hashmap[q[1]] = hashmap[q[0]];
            hashmap.erase(q[0]);
        }
    }
 
    // Creating map to store key value pairs
    map new_map;
    for (auto it = hashmap.begin(); it != hashmap.end();
         ++it) {
        for (auto index : it->second)
            new_map[index] = it->first;
    }
 
    // Updating the main array with final values
    for (auto it = new_map.begin(); it != new_map.end();
         ++it)
        A[it->first] = it->second;
}
 
// Driver Code
int main()
{
    vector arr = { 2, 2, 5, 1 };
    int N = arr.size();
    vector > query = { { 2, 4 }, { 5, 2 } };
    update(arr, N, query);
    for (int i = 0; i < N; ++i) {
        cout << arr[i] << " ";
    }
 
   return 0;
}
 
    // This code is contributed by rakeshsahni

Python3

# Python program for above approach
 
# Function to replace all the
# occurrences of a number with
# another given number for Q queries
def update(A, N, Q):
      # Creating a hashmap
    hashmap = {a:[] for a in A}
    for i in range(N):
        hashmap[A[i]].append(i)
     
    # Iterating with q in given queries
    for q in Q:
        if q[0] in hashmap:
            if q[1] in hashmap:
                hashmap[q[1]].extend(hashmap[q[0]])
            else:
                hashmap[q[1]] = hashmap[q[0]]
            del hashmap[q[0]]
 
    # Creating map to store key value pairs
    new_map = {}
    for key, value in hashmap.items():
        for index in value:
            new_map[index] = key
             
    # Updating the main array with final values
    for key in new_map.keys():
        A[key] = new_map[key]
     
# Driver Code
if __name__ == '__main__':
  arr = [2, 2, 5, 1]
  N = len(arr)
  query = [[2, 4], [5, 2]]
  update(arr, N, query)
  print(arr)

Javascript

// Javascript program for above approach
 
// Function to replace all the
// occurrences of a number with
// another given number for Q queries
function update(A, N, Q)
{
 
      // Creating a hashmap
    let hashmap = new Map();
    for(let i = 0; i < N; i++){
        if(hashmap.has(A[i])){
          let temp = hashmap.get(A[i])
          temp.push(i)
          hashmap.set(A[i], temp)
        }else{
          hashmap.set(A[i], [i])
        }
 
    }
     
    // Iterating with q in given queries
    for(q of Q){
        if(hashmap.has(q[0])){
            if (hashmap.has(q[1])){
                let temp = hashmap.get(q[1]);
                 
                temp = [...temp, ...hashmap.get(q[0])]
                hashmap.set(q[1], temp);
            }
            else{
                hashmap.set(q[1], hashmap.get(q[0]))
            }
            hashmap.delete(q[0])
        }
    }
 
    // Creating map to store key value pairs
    let new_map = new Map()
    for(x of hashmap)
        for(index of x[1])
            new_map.set(index, x[0])
             
    // Updating the main array with final values
    for(key of new_map.keys())
        A[key] = new_map.get(key)
    document.write(`[ ${A}] `)
}
     
// Driver Code
let arr = [2, 2, 5, 1]
let N = arr.length
let query = [[2, 4], [5, 2]]
update(arr, N, query)
 
// This code is contributed by gfgking.

输出：

[4, 4, 2, 1]

时间复杂度： O(max(N, Q))，其中 N 是 arr[] 的大小，Q 是 query[][] 的大小。
辅助空间： O(N)