#include <iostream>
#include <vector>
#include <ctime>
#include <thread>
#include <algorithm>
#include <Windows.h>

struct SLAU
{
public:
    SLAU(int n) : Size(n) //конструктор. Задает СЛАУ
    {
        System.resize(Size);
        for (auto &i : System)
        {
            i.resize(Size);
            for (auto &j : i)
            {
                j = rand() % 10;
            }
        }
    }

    void show_system() // Вывод исходной СЛАУ
    {
        for (const auto &i : System)
        {
            for (const auto &j : i)
            {
                std::cout << j << " ";
            }
            std::cout << std::endl;
        }
    }

    void show_div() //Вывод разбиения
    {
        for (const auto i : Div)
        {
            for (const auto j : i)
            {
                std::for_each(j.begin(), j.end(), [](int x){std::cout << x << " "; });
                std::cout << std::endl;
            }
            std::cout << std::endl << std::endl;
        }
    }

    void set_div() //Разбиваем систему на блоки по кол-ву потоков
    {
        int k = 0;
        int count = threads;
        Div.resize(threads);
        for (auto &i : Div)
        {
            if (Size != 0)
            {
                i.resize(Size / count);
                Size -= (Size / count);
                count--;
            }
            else break;
            for (auto &j : i)
            {
                j.resize(System.size());
                std::copy(System[k].begin(), System[k].end(), j.begin());
                k++;
            }
        }
    }

    std::vector<std::vector<int>> get_vector(int i)
    {
        return Div[i];
    }

    int get_size()
    {
        return Size;
    }

    int get_threads()
    {
        return threads;
    }

private:
    int threads = 2;//std::thread::hardware_concurrency();
    int Size;
    std::vector<std::vector <int>> System;
    std::vector<std::vector<std::vector <int>>> Div;
};

struct ved_str
{
    //int number;
    std::vector<int> mas;
};

void main_string(std::vector<std::vector <int>> &vec, ved_str *str, int j, int eq_num) //поиск локальной ведущей строки
{
    int max_value = -1;
    int number = 0;
    for (int i = 0; i < vec.size(); i++)
    {
        if (j > eq_num)
        {
            eq_num++;
            continue;
        }
        else if (vec[i][j] > max_value)
        {
            max_value = vec[i][j];
            number = i;
        }
    }
    str->mas.push_back(max_value);
}

int main()
{
    double Time = 0;
        int size = 100;

        srand(time(NULL));
        SLAU s1(size);
        std::vector<std::thread> thrds;
        s1.set_div();
        ved_str Main_str;
//ПОТОКИ
        for (int j = 0; j < 10; j++) //
        {
            double start = clock();
            for (int i = 0; i < size; i++)
            {

                std::thread a(main_string, s1.get_vector(0), &Main_str, i, 0);
                std::thread b(main_string, s1.get_vector(1), &Main_str, i, 150);
                //std::thread c(main_string, s1.get_vector(2), &Main_str, i, 150);
                //std::thread d(main_string, s1.get_vector(3), &Main_str, i, 225);

                a.join();
                b.join();
                //c.join();
                //d.join();

                Main_str.mas.clear();

            }
            double end = clock();
            Time += (end - start) / 1000;
            std::cout << (end - start) / 1000 << std::endl;
        }

    system("pause");
    return 0;
}

int main()
{
    double Time = 0;
        int size = 100;

        srand(time(NULL));
        SLAU s1(size);
        std::vector<std::thread> thrds;
        s1.set_div();
        ved_str Main_str;
        //ПОТОКИ
        double start = clock();
        for (int i = 0; i < size; i++)
        {
            int equation_number = 0;
            for (int j = 0; j < s1.get_threads(); j++)
            {
                thrds.push_back(std::thread(&main_string, s1.get_vector(j), &Main_str, i, equation_number));
                equation_number += s1.get_vector(j).size();
            }
            for (auto &j : thrds)
            {
                if (j.std::thread::joinable()) j.join();
            }
            int st = *std::max_element(Main_str.mas.begin(), Main_str.mas.end());
            thrds.clear();
            Main_str.mas.clear();
        }
        double end = clock();
        Time += (end - start) / 1000;
        std::cout << (end - start) / 1000 << std::endl;
    system("pause");
    return 0;
}