Программа поиска гамильтонова цикла в графе, нужно убрать параллельность

#include <iostream>
#include <vector>
#include <omp.h>
 
using namespace std;
 
// Функция для проверки, можно ли добавить вершину v в путь path
bool isSafe(int v, const vector<vector<int>>& graph, const vector<int>& path, int pos) {
    // Проверяем, смежна ли вершина v с предыдущей вершиной в пути
    if (graph[path[pos - 1]][v] == 0)
        return false;
 
    // Проверяем, была ли вершина v уже посещена в пути
    for (int i = 0; i < pos; ++i)
        if (path[i] == v)
            return false;
 
    return true;
}
 
// Рекурсивная функция для нахождения гамильтонова цикла в графе
bool hamiltonianCycleUtil(const vector<vector<int>>& graph, vector<int>& path, int pos, int numVertices) {
    // Базовый случай: если все вершины посещены, и последняя вершина
    // является смежной с начальной вершиной, то есть гамильтонов цикл
    if (pos == numVertices) {
        if (graph[path[pos - 1]][path[0]] == 1)
            return true;
        else
            return false;
    }
 
    // Рекурсивно перебираем все вершины, чтобы найти гамильтонов цикл
    for (int v = 1; v < numVertices; ++v) {
        if (isSafe(v, graph, path, pos)) {
            path[pos] = v;
 
            // Рекурсивный вызов для следующей вершины
            if (hamiltonianCycleUtil(graph, path, pos + 1, numVertices))
                return true;
 
            // Если гамильтонов цикл не найден, сбрасываем вершину
            path[pos] = -1;
        }
    }
 
    return false;
}
 
// Функция для нахождения гамильтонова цикла в графе
vector<int> findHamiltonianCycle(const vector<vector<int>>& graph) {
    int numVertices = graph.size();
    vector<int> path(numVertices, -1);
    vector<int> optimalPath(numVertices, -1);
 
    // Начинаем с вершины 0
    path[0] = 0;
 
    // Параллельная секция для перебора вершин
#pragma omp parallel
    {
        int numThreads = omp_get_num_threads();
        int threadNum = omp_get_thread_num();
 
        // Разделяем работу между потоками
        for (int v = threadNum; v < numVertices; v += numThreads) {
            // Копируем текущий путь в каждый поток
            vector<int> newPath(path);
 
            // Рекурсивный вызов для следующей вершины
            newPath[1] = v;
            bool foundCycle = hamiltonianCycleUtil(graph, newPath, 2, numVertices);
 
            // Если гамильтонов цикл найден в одном из потоков, обновляем главный путь
#pragma omp critical
            {
                if (foundCycle && (optimalPath[0] == -1 || newPath.size() < optimalPath.size())) {
                    optimalPath = newPath;
                }
            }
        }
    }
 
    return optimalPath;
}
 
int main() {
    // Пример графа смежности
    vector<vector<int>> graph = {
        {0, 1, 0, 1, 0},
        {1, 0, 1, 1, 1},
        {0, 1, 0, 0, 1},
        {1, 1, 0, 0, 1},
        {0, 1, 1, 1, 0}
    };
 
    vector<int> hamiltonianCycle = findHamiltonianCycle(graph);
 
    if (hamiltonianCycle[0] != -1) {
        cout << "Гамильтонов цикл: ";
        for (int vertex : hamiltonianCycle)
            cout << vertex << " ";
        cout << hamiltonianCycle[0] << endl;
    }
    else {
        cout << "Гамильтонов цикл не найден." << endl;
    }
 
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
#include <utility>
#include <cassert>
 
int main()
{
    // веса рёбер. INT_MAX - нет ребра. На главной диагонали - нули и граф симметричен относительно г.д. 
    std::vector<std::vector<int>> g
    {
        {0, 2, 1, 2, 1 },
        {2, 0, 2, 1, INT_MAX },
        {1, 2, 0, 2, INT_MAX },
        {2, 1, 2, 0, 1 },
        {1, INT_MAX, INT_MAX, 1, 0 },
    };
    for (int i = 0; i < g.size(); ++i)
    {
        assert(g[i][i] == 0);
        for (int j = 0; j < g[i].size(); ++j)
        {
            assert(g[i][j] == g[j][i]);
        }
    }
    std::vector<std::vector<std::pair<int, int>>> dp{ (unsigned)(1 << g.size()), std::vector<std::pair<int, int>>(g.size(), {INT_MAX, -1}) };
    for (int i = 0; i < dp[0].size(); ++i)
    {
        dp[0][i] = { 0, i };
    }
 
    // находит стартовую вершину для текущей маски и текущей вершины (т.в. включена в т.м.)
    auto startVertex = [&dp](int tm, int tv)
        {
            while (tm)
            {
                tm ^= (1 << tv);
                tv = dp[tm][tv].second;
            }
            return tv;
        };
 
    for (int mask = 0; mask < dp.size(); ++mask)
    {
        for (int u = 0; u < dp[mask].size(); ++u)
        {
            if (dp[mask][u].first == INT_MAX)
                continue;
            int newmask = mask | (1 << u);
            for (int v = 0; v < g[u].size(); ++v)
            {
                if (g[u][v] == INT_MAX || u == v)
                    continue;
                if ((mask & (1 << v)) == 0)
                {
                    if (dp[mask][u].first + g[u][v] < dp[newmask][v].first)
                    {
                        dp[newmask][v].first = dp[mask][u].first + g[u][v];
                        dp[newmask][v].second = u;
                    }
                }
                if (newmask == dp.size() - 1
                    && dp[mask][u].first + g[u][v] < dp[newmask][v].first
                    && v == startVertex(newmask, u))
                {
                    dp[newmask][v].first = dp[mask][u].first + g[u][v];
                    dp[newmask][v].second = u;
                }
            }
        }
    }
 
    auto imin = std::min_element(dp.back().begin(), dp.back().end());
    std::cout << "min len: " << imin->first << "\n";
 
    int tm = dp.size() - 1, tv = imin->second;
    while (tv != -1 && tm)
    {
        std::cout << tv << " ";
        tm ^= (1 << tv);
        tv = dp[tm][tv].second;
    }
}