#include <iostream>
#include <vector>
#include <string>
#include <iomanip>
#include <algorithm>
#include <math.h>

using namespace std;

vector<double> new_criterion(const vector<double>& criterion)
{
    vector <double> new_criterion(4);
    for (auto i1 = 0; i1 <= 3; i1++)
    {
        for (auto i2 = 0; i2 <= 3; i2++)
        {
            if (i1 != i2)
            {
                if (criterion[i1] > criterion[i2]) new_criterion[i1]++;
                if (criterion[i1] == criterion[i2]) new_criterion[i1] = new_criterion[i1] + 0.5;
            }
        }
    }
    return new_criterion;
}

vector<double> normalise_matrix_4x1(const vector<double>& matrix)
{
    vector <double> new_matrix;
    double sum = 0;
    for (auto i = 0; i <= 3; i++) sum += matrix[i];
    for (auto i = 0; i <= 3; i++) new_matrix.push_back(matrix[i] / sum);
    return new_matrix;
}
void Sort(vector<vector<double>>& matrix)
{
    double temp;
    for (auto i1 = 0; i1 <= 3; i1++)
    {
        for (auto i2 = 0; i2 <= 3; i2++)
        {
            for (auto j = i2; j <= 3; j++)
            {
                if (matrix[i2][i1] > matrix[j][i1])
                {
                    temp = matrix[i2][i1];
                    matrix[i2][i1] = matrix[j][i1];
                    matrix[j][i1] = temp;
                }
            }
        }
    }
}

vector<vector<double>> norm_without_criterion(const vector<vector<double>>& matrix, const int& criterion)
{
    vector<vector<double>> matrix2 = matrix;
    Sort(matrix2);
    vector <vector<double>> new_matrix(4, vector<double>(4));
    for (auto i1 = 0; i1 <= 3; i1++)
    {
        for (auto i2 = 0; i2 <= 3; i2++)
        {
            if (i1 != criterion)
            {
                new_matrix[i2][i1] = (matrix[i2][i1] - matrix2[0][i1]) / (matrix2[3][i1] - matrix2[0][i1]);
            }
            else
            {
                new_matrix[i2][i1] = matrix[i2][i1];
            }
        }
    }
    return new_matrix;
}

vector<vector<double>> normalise_matrix_4x4(const vector<vector<double>>& matrix)
{
    vector <double> sum(4);
    vector <vector<double>> new_matrix(4, vector<double>(4));
    for (auto i1 = 0; i1 <= 3; i1++)
    {
        for (auto i2 = 0; i2 <= 3; i2++)
        {
            sum[i1] += matrix[i2][i1];
        }
    }
    for (auto i1 = 0; i1 <= 3; i1++)
    {
        for (auto i2 = 0; i2 <= 3; i2++)
        {
            new_matrix[i2][i1] = matrix[i2][i1] / sum[i1];
        }
    }
    return new_matrix;
}

vector <double> operator * (const vector<vector<double>>& matrix4x4, const vector<double>& matrix1x4) //перегрузка умножить для матриц
{
    vector <double> matrix(4);
    for (auto i1 = 0; i1 <= 3; i1++)
    {
        for (auto i2 = 0; i2 <= 3; i2++)
        {
            matrix[i1] += matrix4x4[i1][i2] * matrix1x4[i2];
        }
    }
    return matrix;
}


vector <vector<double>> set_matrix_criterion(const vector<vector<double>>& matrix, const int& criterion)
{
    vector <vector<double>> new_matrix(4, vector<double>(4));
    for (auto i1 = 0; i1 <= 3; i1++)
    {
        for (auto i2 = 0; i2 <= 3; i2++)
        {
            if (matrix[i1][criterion] == matrix[i2][criterion]) new_matrix[i1][i2] = 1;
            if (matrix[i1][criterion] > matrix[i2][criterion])
            {
                if (matrix[i1][criterion] - matrix[i2][criterion] == 1) new_matrix[i1][i2] = 3;
                if (matrix[i1][criterion] - matrix[i2][criterion] == 2) new_matrix[i1][i2] = 5;
                if (matrix[i1][criterion] - matrix[i2][criterion] == 3) new_matrix[i1][i2] = 7;
                if (matrix[i1][criterion] - matrix[i2][criterion] == 4) new_matrix[i1][i2] = 9;
            }
            if (matrix[i1][criterion] < matrix[i2][criterion])
            {
                if (matrix[i2][criterion] - matrix[i1][criterion] == 1) new_matrix[i1][i2] = 1. / 3;
                if (matrix[i2][criterion] - matrix[i1][criterion] == 2) new_matrix[i1][i2] = 1. / 5;
                if (matrix[i2][criterion] - matrix[i1][criterion] == 3) new_matrix[i1][i2] = 1. / 7;
                if (matrix[i2][criterion] - matrix[i1][criterion] == 4) new_matrix[i1][i2] = 1. / 9;
            }
        }
    }
    return new_matrix;
}

vector <vector<double>> matrix_of_criterions(const vector<double>& criterion)
{
    vector <vector<double>> new_matrix(4, vector<double>(4));
    for (auto i1 = 0; i1 <= 3; i1++)
    {
        for (auto i2 = 0; i2 <= 3; i2++)
        {
            if (criterion[i1] == criterion[i2]) new_matrix[i2][i1] = 1;
            if (criterion[i1] > criterion[i2])
            {
                if (criterion[i1] - criterion[i2] == 1) new_matrix[i2][i1] = 3;
                if (criterion[i1] - criterion[i2] == 2) new_matrix[i2][i1] = 5;
                if (criterion[i1] - criterion[i2] == 3) new_matrix[i2][i1] = 7;
                if (criterion[i1] - criterion[i2] == 4) new_matrix[i2][i1] = 9;
            }
            if (criterion[i1] < criterion[i2])
            {
                if (criterion[i2] - criterion[i1] == 1) new_matrix[i2][i1] = 1. / 3;
                if (criterion[i2] - criterion[i1] == 2) new_matrix[i2][i1] = 1. / 5;
                if (criterion[i2] - criterion[i1] == 3) new_matrix[i2][i1] = 1. / 7;
                if (criterion[i2] - criterion[i1] == 4) new_matrix[i2][i1] = 1. / 8;
            }
        }
    }
    return new_matrix;
}

vector <double> sumstr(const vector <vector<double>>& matrix)
{
    vector <double> sum(4);
    for (auto i1 = 0; i1 <= 3; i1++)
    {
        for (auto i2 = 0; i2 <= 3; i2++)
        {
            sum[i1] += matrix[i1][i2];
        }
    }
    return sum;
}

double utopia_coordinate(const vector<vector<double>>& matrix, const int& criterion)
 {
 vector <double> v(4);
 for (auto i = 0; i <= 3; i++)
 {
 v[i] = matrix[i][criterion];
 }
 sort(begin(v), end(v));
 return v[3];
 }

double evklid_distance(const vector<vector<double>>& matrix, const double& utopia1, const double& utopia2, const int& criterion1, const int& criterion2, const int& alternative)
{
    double distance;
    distance = sqrt((utopia1 - matrix[alternative][criterion1]) * (utopia1 - matrix[alternative][criterion1]) + (utopia2 - matrix[alternative][criterion2]) * (utopia2 - matrix[alternative][criterion2]));
    return distance;
}

// выводы

void print_abcd(const vector<vector<double>>& matrix)
 {
 cout << "     1     2     3    4" << endl;
 cout << "A  ";
 for (auto i = 0; i <= 3; i++) cout << fixed << setprecision(2) << matrix[0][i] << "  ";
 cout << endl << "B  ";
 for (auto i = 0; i <= 3; i++) cout << matrix[1][i] << "  ";
 cout << endl << "C  ";
 for (auto i = 0; i <= 3; i++) cout << matrix[2][i] << "  ";
 cout << endl << "D  ";
 for (auto i = 0; i <= 3; i++) cout << matrix[3][i] << "  ";
 }

 void print_aabbccdd(const vector<vector<double>>& matrix, const vector<double>& sum, const vector<double>& normsum)
 {
 cout << "     A      B      C      D     sum   norm" << endl;
 cout << "A  ";
 for (auto i = 0; i <= 3; i++) cout << fixed << setprecision(2) << setw(5) << matrix[0][i] << "  ";
 cout << setw(5) << sum[0] << "  " << normsum[0];
 cout << endl << "B  ";
 for (auto i = 0; i <= 3; i++) cout << setw(5) << matrix[1][i] << "  ";
 cout << setw(5) << sum[1] << "  " << normsum[1];
 cout << endl << "C  ";
 for (auto i = 0; i <= 3; i++) cout << setw(5) << matrix[2][i] << "  ";
 cout << setw(5) << sum[2] << "  " << normsum[2];
 cout << endl << "D  ";
 for (auto i = 0; i <= 3; i++) cout << setw(5) << matrix[3][i] << "  ";
 cout << setw(5) << sum[3] << "  " << normsum[3];
 cout << endl;
 }

 void print_1234(const vector < vector<double>>& matrix, const vector<double>& sum, const vector<double>& normsum)
 {
 cout << "     1      2      3      4     sum   norm" << endl;
 cout << "1  ";
 for (auto i = 0; i <= 3; i++) cout << fixed << setprecision(2) << setw(5) << matrix[0][i] << "  ";
 cout << setw(5) << sum[0] << "  " << normsum[0];
 cout << endl << "2  ";
 for (auto i = 0; i <= 3; i++) cout << setw(5) << matrix[1][i] << "  ";
 cout << setw(5) << sum[1] << "  " << normsum[1];
 cout << endl << "3  ";
 for (auto i = 0; i <= 3; i++) cout << setw(5) << matrix[2][i] << "  ";
 cout << setw(5) << sum[2] << "  " << normsum[2];
 cout << endl << "4  ";
 for (auto i = 0; i <= 3; i++) cout << setw(5) << matrix[3][i] << "  ";
 cout << setw(5) << sum[3] << "  " << normsum[3];
 cout << endl;
 }

 void print4x1(const vector<double>& matrix)
 {
 for (auto i : matrix) cout << i << endl;
 }

int main()
{
    setlocale(LC_ALL, "Russian");
    vector <vector<double>> preferences = { {4, 7, 7, 7}, {4, 6, 7, 6}, {7, 4, 5, 5}, {5, 3, 5, 3} };
    vector <double> criterions = {8, 6, 2, 4};
   // vector <vector<double>> new_matrix_4x4;
    vector <double> new_matrix_4x1 = normalise_matrix_4x1(criterions);
    print_abcd(preferences);
    cout << endl << endl;
    print4x1(new_matrix_4x1);
    cout << endl;
    //метод змены критериев ограничения
    cout << "Метод замены критериев" << endl << endl;
    vector <vector<double>> new_matrix_4x4 = norm_without_criterion(preferences, 0);

    cout << "Нормированная матрица (кроме главного критерия: Объем памяти)" << endl;
    print_abcd(new_matrix_4x4);
    cout << endl << endl;
    //метод сужения множества Парето для критериев 1 и 3
    cout << "Формирование и сужение множества Парето" << endl << endl;
    double utopia1 = utopia_coordinate(preferences, 0);
    double utopia2 = utopia_coordinate(preferences, 3);
    cout << "координаты точки утопии для критериев 1 и 4 (" << utopia1 << ", " << utopia2 << ")" << endl << endl;
    cout << "Расстояние Евклидово:" << endl;
    cout << "Компьютер: " << evklid_distance(preferences, utopia1, utopia2, 0, 3, 0) << endl;
    cout << "Ноутбук: " << evklid_distance(preferences, utopia1, utopia2, 0, 3, 1) << endl;
    cout << "Планшет: " << evklid_distance(preferences, utopia1, utopia2, 0, 3, 2) << endl;
    cout << "Смартфон: " << evklid_distance(preferences, utopia1, utopia2, 0, 3, 3) << endl;
    cout << endl;
    cout << "Взвешивание и объединение критериев" << endl << endl;
    cout << "Нормализованная матрица рейтингов альтернатив по критериям" << endl;
    new_matrix_4x4 = normalise_matrix_4x4(preferences);
    print_abcd(new_matrix_4x4);
    cout << endl << endl;

    cout << "Вектор весов критериев" << endl;
    new_matrix_4x1 = new_criterion(criterions);
    print4x1(new_matrix_4x1);
    cout << endl;//вывод

    cout << "Нормализованный вектор весов критериев" << endl;
    new_matrix_4x1 = normalise_matrix_4x1(new_matrix_4x1);
    print4x1(new_matrix_4x1);
    cout << endl;

    cout << "Значения объединенного критерия для всех альтернатив" << endl;
    new_matrix_4x1 = new_matrix_4x4 * new_matrix_4x1;
    print4x1(new_matrix_4x1);
    cout << endl;

    cout << "Метод анализа критериев" << endl << endl;

    vector <double> matrix1(4), matrix2(4), matrix3(4), matrix4(4), matrix5(4);
    vector <double> matrix1sum(4), matrix2sum(4), matrix3sum(4), matrix4sum(4), matrix5sum(4);

    new_matrix_4x4 = set_matrix_criterion(preferences, 0);
    matrix1sum = sumstr(new_matrix_4x4);
    matrix1 = normalise_matrix_4x1(matrix1sum);
    cout << endl << "Начальная цена" << endl;

    print_aabbccdd(new_matrix_4x4, matrix1sum, matrix1);
    new_matrix_4x4 = set_matrix_criterion(preferences, 1);
    matrix2sum = sumstr(new_matrix_4x4);
    matrix2 = normalise_matrix_4x1(matrix2sum);
    cout << endl << "Стоимость обслуживания" << endl;

    print_aabbccdd(new_matrix_4x4, matrix2sum, matrix2);

    new_matrix_4x4 = set_matrix_criterion(preferences, 2);
    matrix3sum = sumstr(new_matrix_4x4);
    matrix3 = normalise_matrix_4x1(matrix3sum);
    cout << endl << "Объем памяти" << endl;

    print_aabbccdd(new_matrix_4x4, matrix3sum, matrix3);

    new_matrix_4x4 = set_matrix_criterion(preferences, 3);
    matrix4sum = sumstr(new_matrix_4x4);
    matrix4 = normalise_matrix_4x1(matrix4sum);
    cout << endl << "Размер экрана" << endl;

    print_aabbccdd(new_matrix_4x4, matrix4sum, matrix4);

    new_matrix_4x4 = matrix_of_criterions(criterions);
    matrix5sum = sumstr(new_matrix_4x4);
    matrix5 = normalise_matrix_4x1(matrix5sum);
    cout << endl << "Оценка приоритетов критериев" << endl;

    print_1234(new_matrix_4x4, matrix5sum, matrix5);
    cout << endl << endl;

    for (auto i = 0; i <= 3; i++)
    {
        new_matrix_4x4[i][0] = matrix1[i];
        new_matrix_4x4[i][1] = matrix2[i];
        new_matrix_4x4[i][2] = matrix3[i];
        new_matrix_4x4[i][3] = matrix4[i];
    }

    for (auto i1 : new_matrix_4x4)
    {
        for (auto i2 : i1) cout << i2 << " ";
        cout << endl;
    }

    cout << endl << endl;

    new_matrix_4x1 = new_matrix_4x4 * matrix5;
    print4x1(new_matrix_4x1);
}