Lexicographically smallest String by pair swapping

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

class Graph {
private:
    int V;
    vector<vector<int>> adj;

public:
    // Constructor to initialize the graph with 'V' vertices
    Graph(int V) : V(V), adj(V) {}

    // Function to add a relationship (edge) between vertices 'v' and 'w'
    void addPair(int v, int w) {
        // Check if the indices are within bounds
        if (v >= 0 && v < V && w >= 0 && w < V) {
            // Adjust indices to be 0-based
            adj[v].push_back(w);
            adj[w].push_back(v);
        }
        else {
            cerr << "Invalid vertex indices: " << v << " or " << w << endl;
        }
    }

    // Utility function to perform depth-first traversal to find connected groups
    void countAll(int v, vector<int>& group, vector<bool>& visited) {
        visited[v] = true;
        // Add the vertex to the current group (adjust index)
        group.push_back(v + 1);

        // Recursively explore neighbors of the current vertex
        for (int neighbor : adj[v]) {
            if (!visited[neighbor]) {
                countAll(neighbor, group, visited);
            }
        }
    }

    // Function to find disjoint sets formed by the relations
    vector<vector<int>> disjointSets() {
        vector<bool> visited(V, false);
        vector<vector<int>> all_sets;

        for (int i = 0; i < V; ++i) {
            // If the vertex hasn't been visited, it's the start of a new group
            if (!visited[i]) {
                // Create a new group
                vector<int> group;
                // Find all vertices connected to this one
                countAll(i, group, visited);
                // Add the group to the list of all groups
                all_sets.push_back(group);
            }
        }

        return all_sets;
    }
};

// Driver Code
int main() {
    // Input string
    string Str = "zcxfbe";
    // Number of elements
    int N = 6;
    // Pairs of indices indicating relationships
    vector<vector<int>> Pairs = {{0, 1}, {0, 2}, {3, 5}};

    // Create a graph with N vertices
    Graph g(N);

    // Add relations based on pairs
    for (const auto& pair : Pairs) {
        g.addPair(pair[0], pair[1]);
    }

    // Find disjoint sets formed by the relations
    vector<vector<int>> disjoint_sets = g.disjointSets();
    vector<int> key;
    vector<char> value;

    for (size_t i = 0; i < disjoint_sets.size(); ++i) {
        // Temporary list to store characters within a group
        vector<char> semians;
        for (int j : disjoint_sets[i]) {
            // Extract characters from the input string
            semians.push_back(Str[j - 1]);
        }
        // Sort the characters lexicographically
        sort(semians.begin(), semians.end());
        // Sort the indices
        sort(disjoint_sets[i].begin(), disjoint_sets[i].end());

        // Add sorted characters to the value list
        value.insert(value.end(), semians.begin(), semians.end());
        // Add sorted indices to the key list
        key.insert(key.end(), disjoint_sets[i].begin(), disjoint_sets[i].end());
    }

    // Initialize a list to reconstruct the final string
    vector<char> ans(N, ' ');

    // Reconstruct the final string based on sorted characters and indices
    for (size_t i = 0; i < N; ++i) {
        ans[key[i] - 1] = value[i];
    }

    // Print the rearranged string
    cout << string(ans.begin(), ans.end()) << endl;

    return 0;
}