Construct a Graph from size of components for each node

Given an array A[] of size N, for each index i in the range [0, N) the value A[i] denotes the size of the connected component of node i. The task is to find the edges for the possible graph else print -1.

Note: There may be more than 1 possible answers for each array. Print any one of them. 

Examples:

Input: N = 5, A[] = {2, 1, 1, 2, 1}
Output: {{0, 3}}
Explanation: The size of Connected Components of nodes (0, 3) is 2, every other node is singular.

Input: N = 4, A[] = {2, 2, 2, 2}
Output: {{0, 1}, {2, 3}}
Explanation: Other possible variations are - {{0, 2}, {1, 3}}, {{0, 3}, {1, 2}}

Input: N=2, A[] = {1, 1}
Output: Graph is already connected.
Explanation: Since, each connected component size is 1, no edge is needed to connect any pair of nodes.

Approach: The idea is to observe that all the same component sizes can be connected with each other using total nodes equal to the size of the array value. So, store all the nodes with the same index value into a map. The values of nodes can be stored with a map structure map<int, vector<int>>. Check for each size of connected component that the corresponding total nodes are a multiple of the size. If for any connected component the above condition fails then there will be no valid graph. Return -1 immediately. Otherwise for all multiple stores the vertices and connect them adjacently. Store all edges in an array and output the result. Follow the steps below to solve the problem:

• Initialize a boolean variable flag as false to check if all the values are 1. If so, then there is no need to form any edge.
• Initialize a map of vector mp[] to store the indices for a particular connected component size.
• Iterate over the range [0, N) using the variable i and perform the following tasks:
  • Push the value i into the vector in the map at A[i].
  • If A[i] is not equal to 1, then set the value of flag as true.
• If flag is false, then return.
• Iterate over the map using the variable x and perform the following tasks:
  • If x.second.size() is not divisible by x.first, then print -1 and return 0.
• Initialize a vector of pair of int edges[] to store the edges.
• Iterate over the map using the variable x and perform the following tasks:
  • Initialize a vector nodes[] as the vector at the current position.
  • Iterate in a while loop till the size of nodes[] is greater than 0 and perform the following tasks:
    • Initialize the variable cnt as 0.
    • Initialize a vector component_nodes[]. 
    • Iterate in a while loop till cnt is not equal to x.first and perform the following tasks:
      • Push the last value in the vector nodes[] into the vector component_nodes[] and pop that value from nodes[] and increase the value of cnt by 1.
    • Iterate over the range [1, component_nodes.size()) using the variable i and perform the following tasks:
      • Push the pair {component_nodes[i], component_nodes[i-1]} into the vector edges[].
• After performing the above steps, print the vector edges[] as the answer.

Below is the implementation of the above approach:

[{0, 3}]

Time Complexity: O(N*log(N))
Auxiliary Space: O(N)