Как вернуть исходные значения?

//////////////////////////////////////////////////////////////////////////////////////
//пусть мы имеем массив натуральных чисел от 1 до N, в котором числа не повторяются, 
//скажем, для N=4 это будет: a[1]=2 a[2]=3 a[3]=4 a[4]=1
//Зная этот массив, мы легко можем найти элементы массива a[a[i]], 
//в котором вместо индексов - значения элементов нашего массива:
//a[a[1]]=3 a[a[2]]=4 a[a[3]]=1 a[a[4]]=2.
//
//А как решить обратную задача? Известен массив a[a[i]], найти элементы массива a[i]?
//////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <set>
#include <vector>
//////////////////////////////////////////////////////////////////////////////////////
typedef size_t                    T_elem;
typedef std::set<T_elem>          T_elem_set;
typedef std::vector<T_elem*>      T_substitutions;
//////////////////////////////////////////////////////////////////////////////////////
void  get_substitutions_sqrt
    (
        size_t                 substitution_size,        
        const T_elem* const    substitution,
        const T_elem_set&      elem_set,        
        T_elem* const          substitution_sqrt,
        T_substitutions&       substitutions_sqrt_res
    )
{
    T_elem*  first_zero_it
        = std::find(substitution_sqrt, substitution_sqrt + substitution_size, 0);   
    
    int  first_zero_pos = std::distance(substitution_sqrt, first_zero_it); 
 
    for(T_elem_set::const_iterator  set_elem_it = elem_set.begin();
        set_elem_it != elem_set.end(); ++set_elem_it)
    {
        T_elem*     substitution_sqrt_cur = new  T_elem[substitution_size];
        std::copy(substitution_sqrt, substitution_sqrt + substitution_size, 
                  substitution_sqrt_cur);
 
        T_elem_set  elem_set_cur(elem_set);        
 
        T_elem      pos_cur   = first_zero_pos;
        T_elem      elem_cur  = *set_elem_it;
        
        for(;;)
        {
            if(substitution_sqrt_cur[pos_cur] == 0)
            {
                if(elem_set_cur.find(elem_cur) == elem_set_cur.end())
                {
                    break;
                }
                substitution_sqrt_cur[pos_cur] = elem_cur;
                elem_set_cur.erase(elem_cur);
                if(elem_set_cur.empty())
                {                    
                    substitutions_sqrt_res.push_back(substitution_sqrt_cur);
                    break;
                }
                elem_cur  = substitution[pos_cur];            
                pos_cur   = substitution_sqrt_cur[pos_cur] - 1;            
            }
            else if(substitution_sqrt_cur[pos_cur] == elem_cur)
            {
                if(elem_set_cur.empty())
                {                    
                    substitutions_sqrt_res.push_back(substitution_sqrt_cur);
                }
                else
                {
                    get_substitutions_sqrt
                        (
                            substitution_size,
                            substitution,
                            elem_set_cur,
                            substitution_sqrt_cur,
                            substitutions_sqrt_res
                        );                               
                }
                break;                
            }
            else break;
        }//for(;;)     
    }//for(T_elem_set::const_iterator  set_elem_it = elem_set.begin();    
}
//////////////////////////////////////////////////////////////////////////////////////
int main()
{
    std::locale::global(std::locale(""));
    int  n;
    do
    {
        std::cout << "Введите количество элементов в подстановке > 0: ";
        std::cin >> n;
    }while(n <= 0);
 
    std::cout << "Введите подстановку из "
              << n
              << " элементов:"
              << std::endl;
 
    T_elem_set  elem_set;    
    T_elem*     substitution = new  T_elem[n];
    bool        elem_is_good;
 
    int  subst_ind_cur = 0;
    do
    {
        std::cout << "#"
                  << elem_set.size() + 1
                  << ": ";
 
        T_elem  cur_elem;
        std::cin >> cur_elem;
        elem_is_good = (1 <= cur_elem && cur_elem <= static_cast<T_elem>(n))
                       && elem_set.find(cur_elem) == elem_set.end();
 
        if(elem_is_good)
        {
            elem_set.insert(cur_elem);            
            substitution[subst_ind_cur++] = cur_elem;
        }
    }while(!elem_is_good
           || elem_set.size() < static_cast<T_elem>(n));   
 
    T_elem*  substitution_sqrt = new  T_elem[n];   
        
    std::fill_n(substitution_sqrt, n, 0);
    T_substitutions  substitutions_sqrt;
 
    get_substitutions_sqrt
        (
            n,
            substitution, 
            elem_set,
            substitution_sqrt,
            substitutions_sqrt
        );
 
    if(substitutions_sqrt.empty())
    {
        std::cout << "Не существует подстановки, квадратом которой являлась бы заданная.";
    }
    else
    {
        std::cout << "Подстановки, квадратом которых является заданная:"
                  << std::endl;
        int counter = 0;        
        
        for(T_substitutions::iterator  
            sqrt_substitution_it = substitutions_sqrt.begin();
            sqrt_substitution_it != substitutions_sqrt.end(); ++sqrt_substitution_it)
        
        {
            std::cout << "#"
                      << ++counter
                      << ":\t";
            
            std::copy(*sqrt_substitution_it, *sqrt_substitution_it + n,
                      std::ostream_iterator<T_elem>(std::cout, " "));          
 
            std::cout << std::endl;
        }       
    }
    std::cout << std::endl;
}