Permutation Permutation::pow (int degree){
     if (degree == 0) {
        return Permutation(_size);
    } else if (degree == 1) {
        return Permutation(*this);
    } else if (degree == -1) {
        return inverse();
    }

    Permutation result(*this);
    Permutation tmp(*this);
    if(degree < 0) {
        tmp = tmp.inverse();
        degree = -degree;
    }

    --degree;


    int* cycle = new int[_size];
    bool* used = new bool[_size];

    for(size_t i = 0; i < _size; ++i)
        used[i] = false;
    int* cycleStart = tmp._array;
    int cycleSize = 0;
    while (cycleStart < tmp._array+_size) {
        bool flag = true;
        int *currentPtr = cycleStart;
        while (flag || currentPtr != cycleStart) {
            flag = false;
            cycle[cycleSize] = int(currentPtr - tmp._array);
            used[currentPtr -tmp._array] = true;
            ++cycleSize;
            currentPtr = tmp._array + *currentPtr;
        }
        int shift = degree % cycleSize;
        for (int i = 0; i < cycleSize; ++i) {
            result._array[cycle[i]] = cycle[(i + shift) % cycleSize];
        }
        cycleSize = 0;
        while (unsigned(cycleStart - tmp._array) <= _size && used[cycleStart - tmp._array]) {
            ++cycleStart;
        }
    }

    delete[] used;
    delete[] cycle;
    return result;
}