Shatunov Evgeniy

CMakeLists.txt

@@ -4,7 +4,7 @@ project(homeworks)
 
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/lib)
 
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/sandbox)
+#add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/sandbox)
 
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/additional_tasks)
 

README.md

@@ -1,7 +1 @@
-# Домашнее задание для 2 семестра алгоритмов и структур данных
 
-### Для удобства можно пользоваться папкой lib, все файлы из этой папки будут подключаться к любой задаче
-
-### Можно получить дополнительные баллы, если добавить интересные текстовые задачи. Необходимы текст задачи, решение и тесты.
-
-### Можно получить дополнительные баллы, если добавить теорию в папку doc. Делается в отдельном ПР

additional_tasks/graph_view/CMakeLists.txt

@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 3.10)
+
+get_filename_component(PROJECT_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+string(REPLACE " " "_" PROJECT_NAME ${PROJECT_NAME})
+project(${PROJECT_NAME} C CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+file(GLOB_RECURSE source_list "src/*.cpp" "src/*.hpp")
+file(GLOB_RECURSE lib_source_list "../lib/src/*.cpp" "../lib/src/*.hpp")
+file(GLOB_RECURSE main_source_list "src/main.cpp")
+file(GLOB_RECURSE test_source_list "src/*.cpp")
+file(GLOB_RECURSE test_list "src/*test.cpp")
+
+list(REMOVE_ITEM test_source_list ${main_source_list})
+list(REMOVE_ITEM source_list ${test_list})
+
+include_directories(${PROJECT_NAME} PUBLIC src)
+include_directories(${PROJECT_NAME} PUBLIC ../lib/src)
+
+add_executable(${PROJECT_NAME} ${source_list} ${lib_source_list})
+
+# Locate GTest
+enable_testing()
+find_package(GTest REQUIRED)
+include_directories(${GTEST_INCLUDE_DIRS})
+
+# Link runTests with what we want to test and the GTest and pthread library
+add_executable(${PROJECT_NAME}_tests ${test_source_list})
+target_link_libraries(
+  ${PROJECT_NAME}_tests
+  GTest::gtest_main
+)
+
+include(GoogleTest)
+gtest_discover_tests(${PROJECT_NAME}_tests)

additional_tasks/graph_view/README.md

@@ -0,0 +1,10 @@
+# Задача на перевод одного и того же графа в его различные представления
+
+В качестве возможных вариантов хранения графа используются:
+
+1. Матрица смежности, основанная на двумерном bool векторе
+2. Лист смежности, основанный на двумерном size_t векторе
+3. Лист смежности, основанных на векторе из unordered_set<size_t> (то есть без повторения вершин)
+4. Список вершин, основанный на векторе пар <size_t, size_t>
+
+Перевод осуществляется из любого представления в любое. 

additional_tasks/graph_view/src/container_couts.hpp

@@ -0,0 +1,51 @@
+#pragma
+
+#include <vector>
+#include <algorithm>
+#include <unordered_set>
+#include <iostream>
+
+template<class K,class V>
+std::ostream& operator<< (std::ostream& ost, std::pair<K,V>& v)
+{
+    ost << '[' << v.first << "," << v.second << ']';
+    return ost;
+}
+
+template<class T>
+std::ostream& operator<< (std::ostream& ost, const std::vector<T>& v)
+{
+    ost << '[';
+    if(!v.empty())
+    {
+        auto it = v.begin();
+        ost << *it;
+        ++it;
+        while(it != v.end())
+        {
+            ost << ',' << *it;
+            ++it;
+        }
+    }
+    ost << ']';
+    return ost;
+}
+
+template<class T>
+std::ostream& operator<< (std::ostream& ost, const std::unordered_set<T>& v)
+{
+    ost << '{';
+    if(!v.empty())
+    {
+        auto it = v.begin();
+        ost << *it;
+        ++it;
+        while(it != v.end())
+        {
+            ost << ',' << *it;
+            ++it;
+        }
+    }
+    ost << '}';
+    return ost;
+}

additional_tasks/graph_view/src/graph_view.cpp

@@ -0,0 +1,183 @@
+#include "graph_view.hpp"
+#include "container_couts.hpp"
+
+AdjacencyMatrix& AdjacencyMatrix::operator= (const AdjacencyListVec& vec_list)
+{
+    data_.clear();
+    data_.resize(vec_list.size(), std::vector<bool>(vec_list.size()));
+    for (size_t vec_index = 0; vec_index < vec_list.size(); vec_index++)
+        for (size_t index = 0; index < vec_list[vec_index].size(); index++)
+            data_[vec_index][vec_list[vec_index][index]] = vec_list[vec_index][index] || vec_list[vec_index][index] == 0 ? true : false;
+    return *this;
+}
+
+AdjacencyMatrix& AdjacencyMatrix::operator= (const AdjacencyListUnorderedSet& unord_list)
+{
+    data_.clear();
+    data_.resize(unord_list.size(), std::vector<bool>(unord_list.size()));
+    for (size_t vec_index = 0; vec_index < unord_list.size(); vec_index++)
+        for (size_t elem : unord_list[vec_index])
+            data_[vec_index][elem] = elem || elem == 0 ? true : false;
+    return *this;
+}
+
+AdjacencyMatrix& AdjacencyMatrix::operator= (const EdgeList& edge_list)
+{
+    data_.clear();
+    size_t max_vertex{0};
+    for (size_t index = 0; index < edge_list.size(); index++)
+    {
+        std::pair<size_t, size_t> pair = edge_list[index];
+        size_t parent = pair.first;
+        size_t child = pair.second;
+        max_vertex = std::max(max_vertex, std::max(parent, child) + 1);
+    }
+
+    data_.resize(max_vertex, std::vector<bool>(max_vertex));
+
+    for (size_t index = 0; index < edge_list.size(); index++)
+    {
+        std::pair<size_t, size_t> pair = edge_list[index];
+        size_t parent = pair.first;
+        size_t child = pair.second;
+        size_t max_vertex = std::max(parent, child) + 1;
+        data_[parent][child] = child || child == 0 ? true : false;
+    }
+    return *this;
+}
+
+
+
+
+AdjacencyListVec& AdjacencyListVec::operator= (const AdjacencyMatrix& matrix)
+{
+    data_.clear();
+    data_.resize(matrix.size());
+    for (size_t vertex = 0; vertex < matrix.size(); vertex++)
+        for (size_t index = 0; index < matrix.size(); index++)
+            if(matrix[vertex][index]) data_[vertex].push_back(index);
+    return *this;
+}
+
+AdjacencyListVec& AdjacencyListVec::operator= (const AdjacencyListUnorderedSet& list)
+{
+    AdjacencyMatrix matrix(3);
+    matrix = list;
+    *this = matrix;
+    return *this;
+}
+
+AdjacencyListVec& AdjacencyListVec::operator= (const EdgeList& list)
+{
+    data_.clear();
+    size_t max_vertex{0};
+    for (size_t index = 0; index < list.size(); index++)
+    {
+        std::pair<size_t, size_t> pair = list[index];
+        size_t parent = pair.first;
+        size_t child = pair.second;
+        max_vertex = std::max(max_vertex, std::max(parent, child) + 1);
+    }
+    data_.resize(max_vertex);
+    for (size_t index = 0; index < list.size(); index++)
+    {
+        std::pair<size_t, size_t> pair = list[index];
+        size_t parent = pair.first;
+        size_t child = pair.second;
+        data_[parent].push_back(child);
+    }
+    return *this;
+}
+
+
+
+
+AdjacencyListUnorderedSet& AdjacencyListUnorderedSet::operator= (const AdjacencyMatrix& matrix)
+{
+    data_.clear();
+    data_.resize(matrix.size());
+    for (size_t vertex = 0; vertex < matrix.size(); vertex++)
+        for (size_t index = 0; index < matrix.size(); index++)
+            if(matrix[vertex][index]) data_[vertex].insert(index);
+    return *this;
+}
+
+AdjacencyListUnorderedSet& AdjacencyListUnorderedSet::operator= (const AdjacencyListVec& list)
+{
+    AdjacencyMatrix matrix(3);
+    matrix = list;
+    *this = matrix;
+    return *this;
+}
+
+AdjacencyListUnorderedSet& AdjacencyListUnorderedSet::operator= (const EdgeList& list)
+{
+    AdjacencyMatrix matrix(3);
+    matrix = list;
+    *this = matrix;
+    return *this;
+}
+
+
+
+
+EdgeList& EdgeList::operator= (const AdjacencyMatrix& matrix)
+{
+    data_.clear();
+    for (size_t vertex = 0; vertex < matrix.size(); vertex++)
+        for (size_t index = 0; index < matrix.size(); index++)
+            if(matrix[vertex][index]) data_.push_back(std::pair<size_t, size_t> (vertex, index));
+    return *this;
+}
+
+EdgeList& EdgeList::operator= (const AdjacencyListVec& list)
+{
+    data_.clear();
+    for(size_t parent = 0; parent < list.size(); parent++)
+    {
+        for(size_t child : list[parent])
+            data_.push_back(std::pair<size_t, size_t>(parent, child));
+    }
+    return *this;
+}
+
+EdgeList& EdgeList::operator= (const AdjacencyListUnorderedSet& list)
+{
+    AdjacencyMatrix matrix(3);
+    matrix = list;
+    *this = matrix;
+    return *this;
+}
+
+
+
+
+
+std::ostream& operator<< (std::ostream& ost, AdjacencyMatrix& matrix)
+{
+    for (auto& vec : matrix.data_)
+        std::cout << vec << std::endl;
+    return ost;
+}
+
+std::ostream& operator<< (std::ostream& ost, AdjacencyListVec& list_vec)
+{
+    size_t i = 0;
+    for (auto& vec : list_vec.data_)
+        std::cout << i++ << ":" << vec << std::endl;
+    return ost;
+}
+
+std::ostream& operator<< (std::ostream& ost, AdjacencyListUnorderedSet& list_unord_set)
+{
+    for (auto& unord_set : list_unord_set.data_)
+        std::cout << unord_set << std::endl;
+    return ost;
+}
+
+std::ostream& operator<< (std::ostream& ost, EdgeList& edge_list)
+{
+    for (auto& pair : edge_list.data_)
+        std::cout << pair << std::endl;
+    return ost;
+}