# Minimize count of unequal elements at corresponding indices between given arrays

Given two arrays A[] and B[] consisting of N positive integers and a matrix List[][] consisting of M pairs of indices, the task is to minimize the count of unequal same-indexed elements(Ai != Bi) from the two arrays by swapping between any pair of given indices in array A[].

Examples:

Input: N = 5, M = 4, A[] = {1, 5, 9, 2, 3}, B[] = {2, 4, 5, 1, 3}, List[][] = {{1, 4}, {2, 3}, {3, 5}, {2, 5}}
Output:
Explanation:
Initial array A[] = {1, 5, 9, 2, 3}
Swapping indices (1, 4) in A[] = {2, 5, 9, 1, 3}
Swapping indices (2, 3) in A[] = {2, 9, 5, 1, 3}
Therefore, on comparing the final array A[] (= {2, 9, 5, 1, 3}) with array B[] (= {2, 4, 5, 1, 3}), the only pair of unequal same-indexed elements is A[2] != B[2] (1-based indexing)

Input: N = 5, M = 4, A[] = {1, 10, 19, 6, 2}, B[] = {1, 6, 10, 2, 19}, List[][] = {{1, 4}, {2, 3}, {3, 5}, {2, 5}}
Output: 2

Approach: Since the elements of the array A[] specified in the list of pairs can be swapped any number of times, those elements can be considered as a connected set with swaps within its elements allowed. Below are the steps to implement this approach:

1. Traverse the given array A[] and create a set of connected components that can be easily done using the disjoint set.
2. For each element in B[] find if the corresponding element in A[] (A[i], B[i]) belong to the same connected component or not.
3. If Yes, make A[i]=B[i] and continue. Else, increment the count of mismatched pairs.
4. Print the count of mismatched pair after all the above steps.

Below is the implementation of the above approach :

## C++

 `// C++ program for the above approach ` `#include   ` `using` `namespace` `std;  ` ` `  `int` `find(``int` `par[],``int` `x); ` `void` `unionn(``int` `par[], ``int` `a, ``int` `b); ` ` `  `// Function that count of the mismatched ` `// pairs in bot the array ` `int` `countPairs(``int` `A[], ``int` `B[], ``int` `N, ` `               ``int` `M, ``int` `List[][2]) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// Create a parent array ` `    ``// and initialize it ` `    ``int` `par[N + 1]; ` `    ``for``(``int` `i = 0; i <= N; i++) ` `        ``par[i] = i; ` ` `  `    ``// Preprocessing of the given ` `    ``// pairs of indices ` `    ``for``(``int` `i = 0; i < M; i++) ` `    ``{ ` `         `  `        ``// 1-based indexing ` `        ``int` `index1 = find(par, List[i][0] - 1); ` `        ``int` `index2 = find(par, List[i][1] - 1); ` ` `  `        ``// If both indices doesn't belong ` `        ``// to same component ` `        ``if` `(index1 != index2) ` `        ``{ ` `             `  `            ``// Insert the indices in ` `            ``// same component ` `            ``unionn(par, index1, index2); ` `        ``} ` `    ``} ` ` `  `    ``// Map to get the indices ` `    ``// of array A ` `    ``map<``int``, ``int``> mp; ` ` `  `    ``for``(``int` `i = 0; i < N; i++) ` `    ``{ ` `        ``mp[A[i]] = i; ` `    ``} ` ` `  `    ``for``(``int` `i = 0; i < N; i++) ` `    ``{ ` `        ``if` `(A[i] != B[i]) ` `        ``{ ` ` `  `            ``// If current element is not ` `            ``// present in array B then ` `            ``// count this as mismatched ` `            ``if``(mp.find(B[i]) == mp.end()) ` `            ``{ ` `                ``count++; ` `                ``continue``; ` `            ``} ` `             `  `            ``// Get the index of the element ` `            ``// in array B ` `            ``int` `j = mp[B[i]]; ` ` `  `            ``// Check if both indices belong ` `            ``// to same connected component ` `            ``// if not increment the count ` `            ``if` `(find(par, i) != find(par, j)) ` `                ``count++; ` `        ``} ` `    ``} ` `     `  `    ``// Return answer ` `    ``return` `count; ` `} ` ` `  `// Function that gives the connected ` `// component of each index ` `int` `find(``int` `par[],``int` `x) ` `{ ` `    ``if` `(par[x] == x) ` `        ``return` `x; ` `    ``else` `        ``return` `par[x] = find(par, par[x]); ` `} ` ` `  `// Function that creates the ` `// connected componenets ` `void` `unionn(``int` `par[], ``int` `a, ``int` `b) ` `{ ` `     `  `    ``// Find parent of a and b ` `    ``// recursively ` `    ``a = find(par, a); ` `    ``b = find(par, b); ` `     `  `    ``if` `(a == b) ` `        ``return``; ` ` `  `    ``// Update the parent of a ` `    ``par[a] = b; ` `}  ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `N = 5; ` `    ``int` `M = 4; ` ` `  `    ``// Given arrays A[], B[] ` `    ``int` `A[] = { 1, 5, 9, 2, 3 }; ` `    ``int` `B[] = { 2, 4, 5, 1, 3 }; ` ` `  `    ``// List of indices ` `    ``int` `List[][2] = { { 1, 4 }, { 2, 3 }, ` `                      ``{ 3, 5 }, { 2, 5 } }; ` ` `  `    ``// Function call ` `    ``cout << countPairs(A, B, N, M, List); ` ` `  `    ``return` `0; ` `}  ` ` `  `// This code is contributed by rutvik_56 `

## Java

 `// Java program for the above approach ` `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``// Function that count of the mismatched ` `    ``// pairs in bot the array ` `    ``public` `static` `int` `countPairs(``int` `A[], ``int` `B[], ` `                                ``int` `N, ``int` `M, ` `                                ``int``[][] List) ` `    ``{ ` `        ``int` `count = ``0``; ` ` `  `        ``// Create a parent array ` `        ``// and initialize it ` `        ``int` `par[] = ``new` `int``[N + ``1``]; ` `        ``for` `(``int` `i = ``0``; i <= N; i++) ` `            ``par[i] = i; ` ` `  `        ``// Preprocessing of the given ` `        ``// pairs of indices ` `        ``for` `(``int` `i = ``0``; i < M; i++) { ` ` `  `            ``// 1-based indexing ` `            ``int` `index1 ` `                ``= find(par, List[i][``0``] - ``1``); ` `            ``int` `index2 ` `                ``= find(par, List[i][``1``] - ``1``); ` ` `  `            ``// If both indices doesn't belong ` `            ``// to same component ` `            ``if` `(index1 != index2) { ` ` `  `                ``// Insert the indices in ` `                ``// same component ` `                ``union(par, index1, index2); ` `            ``} ` `        ``} ` ` `  `        ``// HashMap to get the indices ` `        ``// of array A ` `        ``HashMap map ` `            ``= ``new` `HashMap<>(); ` ` `  `        ``for` `(``int` `i = ``0``; i < N; i++) { ` `            ``map.put(A[i], i); ` `        ``} ` ` `  `        ``for` `(``int` `i = ``0``; i < N; i++) { ` `            ``if` `(A[i] != B[i]) { ` ` `  `                ``// If current element is not ` `                ``// present in array B then ` `                ``// count this as mismatched ` `                ``if` `(!map.containsKey(B[i])) { ` `                    ``count++; ` ` `  `                    ``continue``; ` `                ``} ` ` `  `                ``// Get the index of the element ` `                ``// in array B ` `                ``int` `j = map.get(B[i]); ` ` `  `                ``// Check if both indices belong ` `                ``// to same connected component ` `                ``// if not increment the count ` `                ``if` `(find(par, i) != find(par, j)) ` `                    ``count++; ` `            ``} ` `        ``} ` ` `  `        ``// Return answer ` `        ``return` `count; ` `    ``} ` ` `  `    ``// Function that gives the connected ` `    ``// component of each index ` `    ``public` `static` `int` `find(``int` `par[], ` `                        ``int` `x) ` `    ``{ ` `        ``if` `(par[x] == x) ` `            ``return` `x; ` `        ``else` `            ``return` `par[x] ` `                ``= find(par, par[x]); ` `    ``} ` ` `  `    ``// Function that creates the ` `    ``// connected componenets ` `    ``public` `static` `void` `    ``union(``int` `par[], ``int` `a, ``int` `b) ` `    ``{ ` `        ``// Find parent of a and b ` `        ``// recursively ` `        ``a = find(par, a); ` `        ``b = find(par, b); ` `        ``if` `(a == b) ` `            ``return``; ` ` `  `        ``// Update the parent of a ` `        ``par[a] = b; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `        ``main(String[] args) ` `    ``{ ` `        ``int` `N = ``5``; ` `        ``int` `M = ``4``; ` ` `  `        ``// Given arrays A[], B[] ` `        ``int` `A[] = { ``1``, ``5``, ``9``, ``2``, ``3` `}; ` `        ``int` `B[] = { ``2``, ``4``, ``5``, ``1``, ``3` `}; ` ` `  `        ``// List of indices ` `        ``int` `List[][] ` `            ``= { { ``1``, ``4` `}, { ``2``, ``3` `},  ` `                ``{ ``3``, ``5` `}, { ``2``, ``5` `} }; ` ` `  `        ``// Function Call ` `        ``System.out.println( ` `            ``countPairs(A, B, N, M, List)); ` `    ``} ` `} `

## Python3

 `# Python3 program for the above approach  ` ` `  `# Function that count of the mismatched ` `# pairs in bot the array  ` `def` `countPairs(A, B, N, M, ``List``): ` ` `  `    ``count ``=` `0` ` `  `    ``# Create a parent array ` `    ``# and initialize it ` `    ``par ``=` `[``0``] ``*` `(N ``+` `1``) ` `    ``for` `i ``in` `range``(N ``+` `1``): ` `        ``par[i] ``=` `i ` ` `  `    ``# Preprocessing of the given ` `    ``# pairs of indices ` `    ``for` `i ``in` `range``(M): ` ` `  `        ``# 1-based indexing ` `        ``index1 ``=` `find(par, ``List``[i][``0``] ``-` `1``) ` `        ``index2 ``=` `find(par, ``List``[i][``1``] ``-` `1``) ` ` `  `        ``# If both indices doesn't belong ` `        ``# to same component ` `        ``if``(index1 !``=` `index2): ` ` `  `            ``# Insert the indices in ` `            ``# same component ` `            ``union(par, index1, index2) ` ` `  `    ``# HashMap to get the indices ` `    ``# of array A ` `    ``map` `=` `{} ` ` `  `    ``for` `i ``in` `range``(N): ` `        ``map``[A[i]] ``=` `i ` ` `  `    ``for` `i ``in` `range``(N): ` `        ``if``(A[i] !``=` `B[i]): ` ` `  `            ``# If current element is not ` `            ``# present in array B then ` `            ``# count this as mismatched ` `            ``if``(B[i] ``not` `in` `map``.keys()): ` `                ``count ``+``=` `1` `                ``continue` ` `  `            ``# Get the index of the element ` `            ``# in array B ` `            ``j ``=` `map``[B[i]] ` ` `  `            ``# Check if both indices belong ` `            ``# to same connected component ` `            ``# if not increment the count ` `            ``if``(find(par, i) !``=` `find(par, j)): ` `                ``count ``+``=` `1` ` `  `    ``# Return answer ` `    ``return` `count ` ` `  `# Function that gives the connected ` `# component of each index ` `def` `find(par, x): ` ` `  `    ``if``(par[x] ``=``=` `x): ` `        ``return` `x ` `    ``else``: ` `        ``par[x] ``=` `find(par, par[x]) ` `        ``return` `par[x] ` ` `  `# Function that creates the ` `# connected componenets ` `def` `union(par, a, b): ` ` `  `    ``# Find parent of a and b ` `    ``# recursively ` `    ``a ``=` `find(par, a) ` `    ``b ``=` `find(par, b) ` ` `  `    ``if``(a ``=``=` `b): ` `        ``return` ` `  `    ``# Update the parent of a ` `    ``par[a] ``=` `b ` ` `  `# Driver Code ` `N ``=` `5` `M ``=` `4` ` `  `# Given arrays A[], B[] ` `A ``=` `[ ``1``, ``5``, ``9``, ``2``, ``3` `] ` `B ``=` `[ ``2``, ``4``, ``5``, ``1``, ``3` `] ` ` `  `# List of indices ` `List` `=` `[ [ ``1``, ``4` `], [ ``2``, ``3` `], ` `        ``[ ``3``, ``5` `], [ ``2``, ``5` `] ] ` ` `  `# Function call ` `print``(countPairs(A, B, N, M, ``List``)) ` ` `  `# This code is contributed by Shivam Singh `

## C#

 `// C# program for the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` `class` `GFG{ ` ` `  `    ``// Function that count of the mismatched ` `    ``// pairs in bot the array ` `    ``public` `static` `int` `countPairs(``int``[] A, ``int``[] B, ``int` `N, ` `                                ``int` `M, ``int``[, ] List) ` `    ``{ ` `        ``int` `count = 0; ` ` `  `        ``// Create a parent array ` `        ``// and initialize it ` `        ``int``[] par = ``new` `int``[N + 1]; ` `        ``for` `(``int` `i = 0; i <= N; i++) ` `            ``par[i] = i; ` ` `  `        ``// Preprocessing of the given ` `        ``// pairs of indices ` `        ``for` `(``int` `i = 0; i < M; i++)  ` `        ``{ ` ` `  `            ``// 1-based indexing ` `            ``int` `index1 = find(par, List[i, 0] - 1); ` `            ``int` `index2 = find(par, List[i, 1] - 1); ` ` `  `            ``// If both indices doesn't belong ` `            ``// to same component ` `            ``if` `(index1 != index2) ` `            ``{ ` ` `  `                ``// Insert the indices in ` `                ``// same component ` `                ``union(par, index1, index2); ` `            ``} ` `        ``} ` ` `  `        ``// Dictionary to get the indices ` `        ``// of array A ` `        ``Dictionary<``int``, ``int``> map = ``new` `Dictionary<``int``, ``int``>(); ` `        ``for` `(``int` `i = 0; i < N; i++)  ` `        ``{ ` `            ``if` `(map.ContainsKey(A[i])) ` `                ``map[A[i]] = i; ` `            ``else` `                ``map.Add(A[i], i); ` `        ``} ` ` `  `        ``for` `(``int` `i = 0; i < N; i++)  ` `        ``{ ` `            ``if` `(A[i] != B[i])  ` `            ``{ ` ` `  `                ``// If current element is not ` `                ``// present in array B then ` `                ``// count this as mismatched ` `                ``if` `(!map.ContainsKey(B[i]))  ` `                ``{ ` `                    ``count++; ` `                    ``continue``; ` `                ``} ` ` `  `                ``// Get the index of the element ` `                ``// in array B ` `                ``int` `j = map[B[i]]; ` ` `  `                ``// Check if both indices belong ` `                ``// to same connected component ` `                ``// if not increment the count ` `                ``if` `(find(par, i) != find(par, j)) ` `                    ``count++; ` `            ``} ` `        ``} ` ` `  `        ``// Return answer ` `        ``return` `count; ` `    ``} ` ` `  `    ``// Function that gives the connected ` `    ``// component of each index ` `    ``public` `static` `int` `find(``int``[] par, ``int` `x) ` `    ``{ ` `        ``if` `(par[x] == x) ` `            ``return` `x; ` `        ``else` `            ``return` `par[x] = find(par, par[x]); ` `    ``} ` ` `  `    ``// Function that creates the ` `    ``// connected componenets ` `    ``public` `static` `void` `union(``int``[] par, ``int` `a, ``int` `b) ` `    ``{ ` `        ``// Find parent of a and b ` `        ``// recursively ` `        ``a = find(par, a); ` `        ``b = find(par, b); ` `        ``if` `(a == b) ` `            ``return``; ` ` `  `        ``// Update the parent of a ` `        ``par[a] = b; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``int` `N = 5; ` `        ``int` `M = 4; ` ` `  `        ``// Given arrays []A, []B ` `        ``int``[] A = {1, 5, 9, 2, 3}; ` `        ``int``[] B = {2, 4, 5, 1, 3}; ` ` `  `        ``// List of indices ` `        ``int``[, ] List = {{1, 4}, {2, 3}, {3, 5}, {2, 5}}; ` ` `  `        ``// Function Call ` `        ``Console.WriteLine(countPairs(A, B, N, M, List)); ` `    ``} ` `} ` ` `  `// This code is contributed by shikhasingrajput `

Output:

```1
```

Time Complexity: O(N + M)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.