Найти степень перестановки

//Степень перестановки
//(Время: 1 сек. Память: 16 Мб Сложность: 46%)
 
//Требуется вычислить степень заданной перестановки.
 
//Перестановкой из N элементов называется упорядоченный набор из N различных чисел
//от 1 до N. Количество различных перестановок порядка N равно PN = N!
 
//Пусть у нас есть упорядоченное множество из N элементов. Перестановка задает
//преобразование этого множества. А именно, она говорит, что
//на i место нужно поставить ai элемент множества, где ai - i-тый элемент перестановки.
 
//Обратной перестановкой к перестановке π называется такая перестанов   ка π^-1,
//что ππ^-1 = π^-1π = ε, где ε – тождественная перестановка.
 
//Степенью перестановки называется минимальное натуральное число k такое, что π^k = ε
 
//Входные данные
 
//В первой строке входного файла INPUT.TXT записано число 0 < N <= 100 -
//порядок перестановки. Во второй строке записана сама перестановка.
//Выходные данные
 
//В выходной файл OUTPUT.TXT выведите степень данной перестановки.
//Гарантируется, что ответ не превышает 109.
 
//Пример
//INPUT.TXT
//3
//2 3 1
//OUTPUT.TXT
//3
///////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>
///////////////////////////////////////////////////////////////////////////////
typedef std::vector     < int   >   T_permutation;
typedef unsigned long long          T_degree;
///////////////////////////////////////////////////////////////////////////////
const   int     FIRST_POSITION_IND  =   1;
///////////////////////////////////////////////////////////////////////////////
struct  T_is_not_zero
{
    //-------------------------------------------------------------------------
    bool    operator()  ( int  val )
    {
        return  val     !=  0;
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
T_permutation::iterator     it_from_elem
    (
        T_permutation   &   permutation,
        int                 element
    )
{
    return      permutation.begin()
            +   element
            -   FIRST_POSITION_IND;
}
///////////////////////////////////////////////////////////////////////////////
int     elem_from_it
    (
        T_permutation                       &   permutation,
        T_permutation::iterator     const   &   it
    )
{
    return      it
            -   permutation.begin()
            +   FIRST_POSITION_IND;
}
///////////////////////////////////////////////////////////////////////////////
void    set_last_cycle_element_and_set_it_to_zero_in_permutation
    (
        T_permutation   &   permutation,
        int             &   last_cycle_element
    )
{
    T_permutation::iterator     it  =   it_from_elem
                                            (
                                                permutation,
                                                last_cycle_element
                                            );
 
    last_cycle_element              =   *it;
    *it                             =   0;
}
///////////////////////////////////////////////////////////////////////////////
bool    successfully_set_cycle_size
    (
        T_permutation   &   permutation,
        int             &   cycle_size
    )
{
    T_permutation::iterator    it  =   std::find_if
                                            (
                                                permutation.begin   (),
                                                permutation.end     (),
                                                T_is_not_zero       ()
                                            );
 
    bool    bool_res    =   it  !=  permutation.end();
 
    if( bool_res )
    {
        cycle_size                      =   1;
 
        int     first_cycle_element     =   elem_from_it
                                                (
                                                    permutation,
                                                    it
                                                );
 
        int     last_cycle_element      =   first_cycle_element;
 
        for(;;)
        {
            set_last_cycle_element_and_set_it_to_zero_in_permutation
                (
                    permutation,
                    last_cycle_element
                );
 
            if( last_cycle_element  ==  first_cycle_element )
            {
                break;
            }
 
            ++cycle_size;
        }//for
    }//if
 
    return  bool_res;
}
///////////////////////////////////////////////////////////////////////////////
T_degree    GCD
    (
        T_degree    L,
        T_degree    R
    )
{
    if( L > R )
    {
        std::swap(L, R);
    }
 
    return  L   ==  0
                ?   R
                :   GCD( L, R % L );
}
///////////////////////////////////////////////////////////////////////////////
T_degree    LCM
    (
        T_degree    L,
        T_degree    R
    )
{
    return  L * R / GCD( L, R );
}
///////////////////////////////////////////////////////////////////////////////
T_degree    degree( T_permutation   permutation )
{
    T_degree    res         =   1;
    int         cycle_size  =   0;
 
    while   (
                successfully_set_cycle_size
                    (
                        permutation,
                        cycle_size
                    )
            )
    {
        res     =   LCM     (
                                res,
                                cycle_size
                            );
    }//while
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    int     n   =   0;
    std::cin    >>  n;
 
    T_permutation   permutation;
 
    for( int  i = 0; i < n; ++i )
    {
        int     cur_val     =   0;
        std::cin    >>  cur_val;
        permutation.push_back( cur_val );
    }//for
 
    std::cout   <<  degree( permutation )
                <<  std::endl;
}