Сделайте, чтобы двумерный вектор обогнал двумерный массив при заполнении случайными числами

//Выбор типа часов
//Системные настенные
//using clock_type = chrono::system_clock;
//Монотонные (неотстающие)
//using clock_type = chrono::steady_clock;
//С самым точным периодом в рамках STL
using clock_type = chrono::high_resolution_clock;
 
//Выбор единиц измерения времени
using seconds0 = chrono::duration<double>;
using milliseconds0 = chrono::duration<double, ratio_multiply<seconds0::period, milli>>;
using microseconds = chrono::duration<double, ratio_multiply<seconds0::period, micro>>;
 
//Где - то в main()
random_device rd;
    mt19937 g{ rd() };
    uniform_int_distribution<> uid(-10, 10);
    auto gen = [&g, &uid]()
    {
        return uid(g);
    };
 
    size_t count0 = 500u;
    size_t max_ = 5000u;
    size_t step = 500u;
 
    vector<pair<size_t, double>> durations_v;
    vector<pair<size_t, double>> durations_a;
    for (; count0 <= max_; count0 += step)
    {
        auto duration_v = test_vector(gen, count0);
        auto duration_a = test_array(gen, count0);
        durations_v.push_back(make_pair(count0, duration_v));
        durations_a.push_back(make_pair(count0, duration_a));
        cout << "count0 = " << count0 << endl;
    }
//main() закончился
 
double test_vector(function<int()> gen, const size_t &count0)
{
    auto start = clock_type::now();
    vector<vector<int>> v(count0, vector<int>());
    for (auto &str : v)
    {
        str.reserve(count0);
        generate_n(back_inserter(str), count0, gen);
    }
    auto finish = clock_type::now();
    auto duration = seconds0(finish - start);
    return duration.count();
}
 
double test_array(function<int()> gen, const size_t &count0)
{
    auto start = clock_type::now();
    int **a = new int*[count0];
    for (size_t u = 0u; u < count0; ++u)
    {
        a[u] = new int[count0];
        generate(a[u], a[u] + count0, gen);
    }
    auto finish = clock_type::now();
    auto duration = seconds0(finish - start);
    return duration.count();
}

double test_vector(function<int()> gen, const size_t &count0)
{
    auto start = clock_type::now();
    vector<vector<int>> v(count0, vector<int>(count0));
    for (auto & str : v)
    {
        generate_n(str.begin(), count0, gen);
    }
    auto finish = clock_type::now();
    auto duration = seconds0(finish - start);
    return duration.count();
}

double test_vector(const function<int()> &gen, const size_t &count0)
{
    vector<int> v(count0);
    auto start = clock_type::now();
    for (std::size_t i = 0; i < count0; ++i)
    {
        v[i] = gen();
    }
    auto finish = clock_type::now();
    auto duration = milliseconds0(finish - start);
    return duration.count();
}
 
double test_array(const function<int()> &gen, const size_t &count0)
{
    int *a = new int[count0];
    auto start = clock_type::now();
    for (std::size_t i = 0; i < count0; ++i)
    {
        a[i] = gen();
    }
    auto finish = clock_type::now();
    delete[] a;
    auto duration = milliseconds0(finish - start);
    return duration.count();
}

double test_vector(const function<int()> &gen, const size_t &count0)
{
    auto start = clock_type::now();
    vector<vector<int>> v(count0, vector<int>(count0));
    for (auto &str : v)
    {
        generate_n(str.begin(), count0, gen);
    }
    auto finish = clock_type::now();
    auto duration = milliseconds0(finish - start);
    return duration.count();
}
 
double test_array(const function<int()> &gen, const size_t &count0)
{
    auto start = clock_type::now();
    int **a = new int*[count0];
    for (size_t u = 0u; u < count0; ++u)
    {
        a[u] = new int[count0];
        generate(a[u], a[u] + count0, gen);
    }
    delete[] a;
    auto finish = clock_type::now();
    auto duration = milliseconds0(finish - start);
    return duration.count();
}