additional tasks by Krivoruchko Dmitry

CMakeLists.txt

@@ -1,21 +1,23 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.20)
 
-project(homeworks)
+project(homeworks LANGUAGES CXX)
 
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/lib)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_FLAGS "-Wall -Wextra -pedantic -std=c++20 -O2")
 
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/lib)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/sandbox)
-
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/additional_tasks)
 
 file(GLOB_RECURSE tasks_dirs LIST_DIRECTORIES true ".")
 
 foreach(dir ${tasks_dirs})
-    IF(IS_DIRECTORY ${dir})
-        IF(${dir} MATCHES "task_0[0-9]$" AND NOT ${dir} MATCHES "build")
-            add_subdirectory(${dir})
-        ENDIF()
-    ELSE()
-        CONTINUE()
+  IF(IS_DIRECTORY ${dir})
+    IF(${dir} MATCHES "task_0[0-9]$" AND NOT ${dir} MATCHES "build")
+      add_subdirectory(${dir})
     ENDIF()
+  ELSE()
+    CONTINUE()
+  ENDIF()
 endforeach()

README.md

@@ -1,9 +1,10 @@
 # Домашнее задание для 2 семестра алгоритмов и структур данных
+## (Homework for second semester algorithms and data structures on MIPT DAFE/RSE)
 
 ### Для удобства можно пользоваться папкой lib, все файлы из этой папки будут подключаться к любой задаче
 
-### Можно получить дополнительные баллы, если добавить интересные текстовые задачи. Необходимы текст задачи, решение и тесты. Каждая задача отдельный ПР, полчуть дополнительные баллы можно только если пулл реквест замержен в основную ветку.
+Можно получить дополнительные баллы, если добавить интересные текстовые задачи. Необходимы текст задачи, решение и тесты. Каждая задача отдельный - Pull Request, получить дополнительные баллы можно только если PR замерджен в основную ветку.
 
-### Можно получить дополнительные баллы, если добавить теорию в папку doc. Делается в отдельном ПР, полчуть дополнительные баллы можно только если пулл реквест замержен в основную ветку.
+Можно получить дополнительные баллы, если добавить теорию в папку doc. Делается в отдельном PR, только если PR замерджен в основную ветку.
 
-### Код должен быть отформатирован clang-format'ом со стилем Google
+Код должен быть отформатирован clang-format'ом со стилем Google.

additional_tasks/CMakeLists.txt

@@ -5,11 +5,11 @@ project(additional_tasks)
 file(GLOB_RECURSE tasks_dirs LIST_DIRECTORIES true ".")
 
 foreach(dir ${tasks_dirs})
-    IF(IS_DIRECTORY ${dir})
-        IF(NOT ${dir} MATCHES ".*src.*")
-            add_subdirectory(${dir})
-        ENDIF()
-    ELSE()
-        CONTINUE()
+  IF(IS_DIRECTORY ${dir})
+    IF(NOT ${dir} MATCHES ".*src.*")
+      add_subdirectory(${dir})
     ENDIF()
+  ELSE()
+    CONTINUE()
+  ENDIF()
 endforeach()

additional_tasks/chem_experiments_chain/CMakeLists.txt

@@ -0,0 +1,39 @@
+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 23)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+file(GLOB_RECURSE source_list "src/*.cpp" "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)
+
+add_executable(${PROJECT_NAME} ${source_list})
+
+# Locate GTest
+enable_testing()
+find_package(GTest REQUIRED)
+include_directories(${GTEST_INCLUDE_DIRS})
+
+find_library(Utils ../)
+target_link_libraries(${PROJECT_NAME} PUBLIC Utils)
+
+# 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
+  Utils
+)
+
+include(GoogleTest)
+gtest_discover_tests(${PROJECT_NAME}_tests)

additional_tasks/chem_experiments_chain/README.md

@@ -0,0 +1,73 @@
+# Задача: обратимые состояния в цепочке химических экспериментов
+
+В прогрессивной Московской химической лаборатории используют новые методы описания цепочки экспериментов: лаборанты изображают их в виде графов, вершинами которого являются состояния вещества, а эксперименты - ребрами.
+
+Таким образом компании, разрабатывающей программное обеспечение, используя методы хемоинформатики, очень удобно использовать эксперименты этой лаборатории в своих наработках. В одном из проектов им потребовалось найти исключительно полезные состояния, обладающие свойством обратимости в цепочке. 
+
+К обратимым экспериментам относят те, результирующее состояние вещества которых можно вернуть к исходному, через другие процессы в той же цепочке; в таком случае результирующее состояния вещества также называют обратимым.
+
+Найдите по известной цепочке экспериментов, оформленной в виде графа, эти обратимые состояния.
+
+## Входные данные:
+
+* Первая строка содержит целое число `N` (`N` > 0) — количество экспериментов в графе.
+* Следующие `N` строк содержат по два поля, разделенных пробелом: `A` `B`, где `A` и `B` — это строковые имена вершин (состояния веществ). Ребро идет от вершины `A` к вершине `B`. Имена вершин могут содержать любые символы, кроме пробела, переноса строки и пр.
+
+## Выходные данные:
+
+* Выходные данные представляют собой строку, содержащую через пробел имена всех обратимых состояний (порядок вывода обратимых состояний не важен, состояния выводятся без повторений)
+* Если обратимых состояний нет, то вывод должен быть пустым.
+
+# Используемый алгоритм: нахождение компонент сильной связности алгоритмом Тарьяна
+
+## Как работает алгоритм Тарьяна:
+
+Алгоритм Тарьяна - это подход к решению задачи поиска компонент сильной связности (СС) в ориентированном графе. Он работает за линейное время (`O(|V|+|E|)`, где `V` - количество вершин, а `E` - количество ребер) и использует рекурсию для эффективного обхода графа.
+
+Алгоритм Тарьяна основывается на том, что вершина `v` является корнем СС тогда и только тогда, когда ее “низкая связь” (`low_links`) равна ее “времени входа” (`indexes`). “Низкая связь” - это минимальное “время входа” всех вершин, которые можно достичь из `v` по пути рекурсии.
+
+Иначе говоря, вершины рассматриваются в обратном топологическом порядке, поэтому в конце рекурсивной функции для исходной вершины не будет встречено ни одной вершины из той же компоненты сильной связности, так как все вершины, достижимые из исходной, уже обработаны, и обратные связи в дереве дают второй путь из одной вершины в другую и связывают компоненты сильной связности в одну.
+
+## Объяснение кода:
+
+```C++
+template <typename vert_t>
+static void StronglyConnectedComponentsStep(
+    const vert_t& v, size_t& curr_index, std::stack<vert_t>& verts_stack,
+    std::unordered_map<vert_t, size_t>& indexes,
+    std::unordered_map<vert_t, size_t>& low_links,
+    std::unordered_map<vert_t, bool>& is_on_stack,
+    std::unordered_map<vert_t, std::vector<vert_t>>& adj_list,
+    std::vector<std::vector<vert_t>>& strongly_connected_components);
+```
+
+С помощью функции выше выполняется рекурсивный обход.
+
+Для каждой вершины `v`, которая еще не была посещена, выполняется рекурсивный обход. При первом посещении вершины `v`, `indexes[v]` устанавливается равным `curr_index`, `low_links[v]` также устанавливается равным `curr_index`. `curr_index` увеличивается на 1. Вершина `v` помещается в стек `verts_stack`.
+
+Для каждой смежной вершины `w` вершине `v` выполняется следующее:
+1. Если w не была посещена (```indexes[w] == 0```): выполняется рекурсивный вызов StronglyConnectedComponentsStep для вершины `w`, `low_links[v]` обновляется минимальным значением между текущим значением и `low_links[w]`.
+2. Если w уже находится в стеке (`is_on_stack[w]`):
+`low_links[v]` обновляется минимальным значением между текущим значением и `low_links[w]`.
+
+После обработки всех смежных вершин, если ```low_links[v] == indexes[v]```, это означает, что `v` является корнем СС.
+В этом случае все вершины, которые находятся в стеке от v до вершины, которая была обработана ранее, также принадлежат этой СС.
+Вершины удаляются из стека, пока v не будет удален. Эти удаленные вершины образуют СС, которая добавляется в список СС.
+
+```C++
+/**
+ * @brief Поиск компонент сильной связности в ориентированного графа по
+ * алгоритму Тарьяна
+ * @tparam vert_t: тип вершин
+ * @tparam weight_t: тип весов
+ * @param graph: исходный граф
+ * @throw std::invalid_argument("StronglyConnectedComponents: graph is not
+ * directed.");
+ * @return std::vector<std::vector<vert_t>>: компоненты сильной связности
+ */
+template <AllowedVertType vert_t, AllowedWeightType weight_t>
+std::vector<std::vector<vert_t>> StronglyConnectedComponents(
+    Graph<vert_t, weight_t> graph);
+```
+
+Основная функция выше вызывает ```StronglyConnectedComponentsStep(...)``` для каждой вершины графа и возвращает список компонент.

additional_tasks/chem_experiments_chain/src/chem_experiments_chain.hpp

@@ -0,0 +1,26 @@
+#include "tarjan_algorithm.hpp"
+
+/// @brief Решает задачу: "обратимые состояния в цепочке химических
+/// экспериментов"
+void Solution(std::istream& is = std::cin, std::ostream& os = std::cout) {
+  size_t experiments_amount;
+  is >> experiments_amount;
+
+  Graph<std::string, long> graph;
+  graph.MakeDirected();
+
+  for (size_t i = 0; i < experiments_amount; i++) {
+    std::string u, v;
+    is >> u >> v;
+
+    graph.AddEdge(u, v);
+    graph.AddVert(u);
+    graph.AddVert(v);
+  }
+
+  for (const auto& component : StronglyConnectedComponents(graph))
+    if (component.size() != 1 && !component.empty())
+      for (const auto& elem : component) os << elem << " ";
+
+  os << std::endl;
+}

additional_tasks/chem_experiments_chain/src/main.cpp

@@ -0,0 +1,6 @@
+#include "chem_experiments_chain.hpp"
+
+int main() {
+  Solution();
+  return 0;
+}

additional_tasks/chem_experiments_chain/src/tarjan_algorithm.hpp

@@ -0,0 +1,108 @@
+#pragma once
+
+#include <algorithm>
+#include <stack>
+#include <stdexcept>
+
+#include "graph/graph.hpp"
+
+namespace {
+
+template <AllowedVertType vert_t>
+inline void StronglyConnectedComponentsStep(
+    const vert_t& vert, size_t& curr_index, std::stack<vert_t>& verts_stack,
+    std::unordered_map<vert_t, size_t>& indexes,
+    std::unordered_map<vert_t, size_t>& low_links,
+    std::unordered_map<vert_t, bool>& is_on_stack,
+    std::unordered_map<vert_t, std::vector<vert_t>>& adj_list,
+    std::vector<std::vector<vert_t>>& strongly_connected_components) {
+  // в curr_index храним количество ранее обработанных вершин,
+  // indexes[vert] - это "время входа" в вершину vert
+  indexes[vert] = low_links[vert] = curr_index++;
+
+  verts_stack.push(vert);
+
+  // is_on_stack нужно, чтобы проверять принадлежность вершины стеку за O(1)
+  is_on_stack[vert] = true;
+
+  // перебираем рёбра, исходящие из vert
+  for (auto& u_vert : adj_list[vert]) {
+    if (indexes[u_vert] == 0) {
+      // вершина u_vert ранее не посещалась; запускаемся из неё рекурсивно
+      StronglyConnectedComponentsStep(u_vert, curr_index, verts_stack, indexes,
+                                      low_links, is_on_stack, adj_list,
+                                      strongly_connected_components);
+
+      low_links[vert] = std::min(low_links[vert], low_links[u_vert]);
+    } else if (is_on_stack[u_vert])
+      // вершина u_vert находится в стеке, значит, принадлежит той же компоненте
+      // сильной связности, что и vert
+
+      // если u_vert не в стеке, значит, ребро (vert, u_vert) ведёт в ранее
+      // обработанную компоненту сильной связности и должна быть проигнорирована
+      low_links[vert] = std::min(low_links[vert], low_links[u_vert]);
+  }
+
+  // вершина vert - корень текущей компоненты сильной связности,
+  // все вершины в стеке от vert и выше образуют эту компоненту
+  if (low_links[vert] == indexes[vert]) {
+    vert_t u_vert;
+    std::vector<vert_t> strongly_connected_component;
+
+    do {
+      u_vert = verts_stack.top();
+      verts_stack.pop();
+
+      is_on_stack[u_vert] = false;
+      strongly_connected_component.push_back(u_vert);
+    } while (u_vert != vert);
+
+    strongly_connected_components.push_back(strongly_connected_component);
+  }
+}
+
+}  // namespace
+
+/**
+ * @brief Поиск компонент сильной связности в ориентированного графа по
+ * алгоритму Тарьяна.
+ * @tparam vert_t: тип вершин
+ * @tparam weight_t: тип весов
+ * @param graph: исходный граф
+ * @throw `std::invalid_argument("StronglyConnectedComponents: graph is not
+ * directed.")`.
+ * @return `std::vector<std::vector<vert_t>>`: компоненты сильной связности
+ */
+template <AllowedVertType vert_t, AllowedWeightType weight_t>
+std::vector<std::vector<vert_t>> StronglyConnectedComponents(
+    const Graph<vert_t, weight_t>& graph) {
+  if (!graph.IsDirected())
+    throw std::invalid_argument(
+        "StronglyConnectedComponents: graph is not directed.");
+
+  if (graph.Verts().empty()) return {};
+
+  std::vector<std::vector<vert_t>> strongly_connected_component;
+
+  std::stack<vert_t> verts_stack;
+  size_t curr_index = 0;
+
+  std::unordered_map<vert_t, std::vector<vert_t>> adj_list = graph.GetAdjList();
+
+  std::unordered_map<vert_t, size_t> indexes;
+  std::unordered_map<vert_t, size_t> low_links;
+  std::unordered_map<vert_t, bool> is_on_stack;
+
+  for (const auto& vert : graph.Verts()) {
+    indexes[vert] = low_links[vert] = 0;
+    is_on_stack[vert] = false;
+  }
+
+  for (const auto& vert : graph.Verts())
+    if (indexes[vert] == 0)
+      StronglyConnectedComponentsStep(vert, curr_index, verts_stack, indexes,
+                                      low_links, is_on_stack, adj_list,
+                                      strongly_connected_component);
+
+  return strongly_connected_component;
+}