Подсчитать количество ситуаций, когда номер хотя бы одного вынутого шарика совпадает с порядковым номером действия

#include <iostream>
#include <vector>
using namespace std;
 
static unsigned funcUnsuitableTotalCount = 0;
static unsigned funcSuitableTotalCount = 0;
static unsigned funcRecurrentTotalCount = 0;
 
unsigned factorial(unsigned n) {
    static vector<unsigned> saved;
 
    if (saved.size() < n + 1) {
        saved.resize(n + 1, 0);
    }
 
    if (saved[n] == 0) {
        saved[n] = ((n > 1) ? n * factorial(n - 1) : 1);
    }
 
    return saved[n];
}
 
/**
 * Подсчет количества перестановок без совпадений.
 */
unsigned getUnsuitableCount(bool select[], unsigned n, unsigned step_k = 1) {
    // === Количество вызовов функции ==================
    funcUnsuitableTotalCount++;
    // =================================================
 
    unsigned count = 0;
    if (step_k <= n) {
        for (unsigned i = 1; i <= n; i++) {
            if ((i != step_k) && !select[i - 1]) {
                select[i - 1] = true;
                count += getUnsuitableCount(select, n, step_k + 1);
                select[i - 1] = false;
            }
        }
    }
    else {
        // Количество несовпадений для несуществующего k > n искусственно
        // принимается равным 1.
        count = 1;
    }
 
    return count;
}
 
/**
 * Подсчет количества перестановок с хотя бы одним совпадением.
 */
unsigned getSuitableCount(bool select[], unsigned n, unsigned step_k = 1) {
    // === Количество вызовов функции ==================
    funcSuitableTotalCount++;
    // =================================================
 
    unsigned count = 0;
    if (step_k <= n) {
        for (unsigned i = 1; i <= n; i++) {
            if (!select[i - 1]) { // Совпадение номеров шара и шага.
                if (i == step_k) { // Номер шара совпадает с номером шага.
                    // Слева совпадений быть не может.
                    // Справа, независимо от наличия там совпадений,
                    // возможно (n - k)! перестановок.
                    count += factorial(n - step_k);
                }
                else { // Нет совпадения номеров.
                    // Отмечаем текущий номер шара как извлеченный.
                    select[i - 1] = true;
 
                    // Для извлеченного на данном шаре шара № i
                    // получаем количество подходящих перестановок
                    // на следующих k < j <= n шагах.
                    count += getSuitableCount(select, n, step_k + 1);
 
                    // Возврат шара обратно.
                    select[i - 1] = false;
                }
            }
        }
    }
    else {
        // Совпадений для несуществующего k > n быть не может.
        // count = 0;
    }
 
    return count;
}
 
/**
 * Количество сочетаний из n по k.
 */
unsigned C(unsigned n, unsigned k) {
    return factorial(n) / factorial(k) / factorial(n - k);
}
 
/**
 * Вычисление количества перестановок с хотя бы одним совпадением
 * по рекурентной формуле с переходом от задачи N к задаче N - 1.
 */
void recFormula(unsigned *sc, unsigned *uc, unsigned n) {
    if (n == 0) {
        // === Количество шагов для получения результата ===
        funcRecurrentTotalCount++;
        // =================================================
 
        sc[n] = 0;
        uc[n] = 1;
    }
    else {
        recFormula(sc, uc, n - 1);
 
        sc[n] = 0;
        for (unsigned i = 1; i <= n; i++) {
            // === Количество шагов для получения результата ===
            funcRecurrentTotalCount++;
            // =================================================
 
            sc[n] += C(n, i) * uc[n - i];
        }
 
        uc[n] = factorial(n) - sc[n];
    }
}
 
int main() {
    unsigned n;
    cin >> n;
    bool *select = new bool[n];
 
    for (unsigned i = 0; i < n; i++) {
        select[i] = false;
    }
 
    cout << "n! - unsuitable = " << factorial(n) - getUnsuitableCount(select, n) << endl;
    cout << "suitable = " << getSuitableCount(select, n) << endl;
 
    unsigned *sc = new unsigned[n + 1];
    unsigned *uc = new unsigned[n + 1];
 
    recFormula(sc, uc, n);
    cout << "F(n) = " << sc[n] << endl;
 
    cout << "--------------------" << endl;
    cout << "Unsuitable Total Count: " << funcUnsuitableTotalCount << endl;
    cout << "Suitable Total Count: " << funcSuitableTotalCount << endl;
    cout << "Recurrent Total Count: " << funcRecurrentTotalCount << endl;
 
    return 0;
}