Graph

#include"gtest/gtest.h"
#include <vector>
#include <iostream>
#include <string>

#define MAX_NUM 0xFFFFFFD


struct Edge {
    int top1;
    int top2;
    size_t weight;

    Edge(int top1, int top2, size_t weight) : top1(top1), top2(top2), weight(weight) {}
};


class Graph {

    friend Edge;

    int **matrix;

    int count_of_tops;

public:
    Graph(int countOfTops) : count_of_tops(countOfTops) {


        int **matr = new int *[countOfTops];

        for (int i = 0; i < count_of_tops; ++i) {
            matr[i] = new int[count_of_tops];
            for (int k = 0; k < countOfTops; ++k) {
                matr[i][k] = MAX_NUM;
            }
        }
        matrix = matr;

    }


    void addEdge(Edge ed) const {
        matrix[ed.top1][ed.top2] = ed.weight;

        matrix[ed.top2][ed.top1] = ed.weight;

    }

    void addEdge(int top1, int top2, int weight) {
        matrix[top1][top2] = weight;

        matrix[top2][top1] = weight;


    }

    void Print() {


        for (int i = 1; i < count_of_tops; i++) {
            for (int j = 1; j < count_of_tops; j++) {
                std::cout << matrix[i][j] << "\t";
            }
            std::cout << std::endl;
        }

    }

    void deleteElement(int top1, int top2) {
        matrix[top1][top2] = 0;
        matrix[top2][top1] = 0;
    }

    int getCountOfTops() const {
        return count_of_tops;
    }

    int *&operator[](int num_of_row) {
        return matrix[num_of_row];
    }

};

std::vector<int> Dejksty(Graph gr, int start) {
    std::vector<int> result{MAX_NUM, 0, MAX_NUM, MAX_NUM, MAX_NUM, MAX_NUM, MAX_NUM};


    for (int j = 0; j < 2; ++j) {
        for (int i = 1; i < gr.getCountOfTops(); ++i) {
            for (int n = 1; n < gr.getCountOfTops(); ++n) {
                int k = gr[i][n];
                if (result[i] != MAX_NUM) {
                    k += result[i];
                }
                if (result[n] > k) {
                    result[n] = k;
                }
            }

        }
    }


    std::swap(result[1], result[start]);
    return result;
}

TEST(test1,test){
    Graph gr(7);
    gr.addEdge(1,2,7);
    gr.addEdge(1,3,9);
    gr.addEdge(1,6,14);
    gr.addEdge(2,3,10);
    gr.addEdge(2,4,15);
    //std::cout<<gr[1][4];
    gr.addEdge(3,4,11);
    gr.addEdge(3,6,2);
    gr.addEdge(4,5,6);
    gr.addEdge(5,6,9);
    std::vector<int> res = Dejksty(gr,1);
    EXPECT_EQ(res[5],20);
    EXPECT_EQ(res[2],7);
    EXPECT_EQ(res[3],9);
    EXPECT_EQ(res[4],20);
    EXPECT_EQ(res[6],11);
}

TEST(test2,test){
    Graph gr(7);
    gr.addEdge(1, 2, 4);
    gr.addEdge(1, 3, 2);
    gr.addEdge(2, 3, 1);
    gr.addEdge(3, 5, 10);
    gr.addEdge(3, 4, 8);
    gr.addEdge(2, 4, 5);
    gr.addEdge(4, 6, 6);
    gr.addEdge(4, 5, 2);
    gr.addEdge(5, 6, 3);
    std::vector<int> res=Dejksty(gr, 1);
    EXPECT_EQ(res[2],3);
    EXPECT_EQ(res[3],2);
    EXPECT_EQ(res[4],8);
    EXPECT_EQ(res[5],10);
    EXPECT_EQ(res[6],13);
}