// C++ implementation for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to count possible combinations
// of arrays after swapping of elements
// such that there are no duplicates
// in the arrays
int possibleCombinations(int arr1[], int arr2[], int N)
{
    // Create an unordered_map
    unordered_map<int, int> mp;

    // Traverse both the arrays and
    // store the elements of arr2[]
    // in arr1[] element index in
    // the map
    for (int i = 0; i < N; i++) {
        mp[arr1[i]] = arr2[i];
    }

    // Take a variable for count of
    // possible combinations
    int count = 1;

    // Vector to keep track of already
    // swapped elements
    vector<bool> visited(N + 1, 0);
    for (int i = 1; i <= N; i++) {

        // If the element is not visited
        if (!visited[i]) {

            // Create a set
            set<int> s;

            // Variable to store the current index
            int curr_index = i;

            // Iterate a loop till curr_index
            // is equal to i
            do {

                // Insert the element in the set
                // of current index in map
                s.insert(mp[curr_index]);

                // Assign it to curr_index
                curr_index = mp[curr_index];
            } while (curr_index != i);

            // Iterate over the set and
            // mark element as visited
            for (auto it : s) {
                visited[it] = 1;
            }
            count *= 2;
        }
    }
    return count;
}

// Driver Code
int main()
{
    int arr1[] = { 3, 6, 5, 2, 1, 4, 7 };
    int arr2[] = { 1, 7, 2, 4, 3, 5, 6 };
    int N = sizeof(arr1) / sizeof(arr1[0]);

    cout << possibleCombinations(arr1, arr2, N);

    return 0;
}

#include <iostream>
#include <vector>
#include <unordered_set>

class UnionFind {
private:
    std::vector<int> parent;
    std::vector<int> rank;

public:
    UnionFind(int size) : parent(size), rank(size, 1) {
        for (int i = 0; i < size; ++i) {
            parent[i] = i;
        }
    }

    int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]); // Path compression
        }
        return parent[x];
    }

    void unionSets(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX != rootY) {
            if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else if (rank[rootX] < rank[rootY]) {
                parent[rootX] = rootY;
            } else {
                parent[rootY] = rootX;
                rank[rootX]++;
            }
        }
    }
};

int possibleCombinations(std::vector<int>& arr1, std::vector<int>& arr2) {
    int N = arr1.size();
    UnionFind uf(N + 1);

    // Union the indices based on the values in arr1 and arr2
    for (int i = 0; i < N; ++i) {
        uf.unionSets(arr1[i], arr2[i]);
    }

    // Count the number of unique groups
    std::unordered_set<int> uniqueGroups;
    for (int i = 1; i <= N; ++i) {
        uniqueGroups.insert(uf.find(i));
    }

    // Each group can either be swapped or not, so 2^uniqueGroups.size()
    return 1 << uniqueGroups.size();
}

int main() {
    std::vector<int> arr1 = {3, 6, 5, 2, 1, 4, 7};
    std::vector<int> arr2 = {1, 7, 2, 4, 3, 5, 6};

    std::cout << possibleCombinations(arr1, arr2) << std::endl; // Output: 8

    return 0;
}


// This code is contributed by Shivam Gupta