complete find_word_chains additional_task

Author: UmbrellaLeaf5

additional_tasks/chem_experiments_chain/src/chem_experiments_chain.hpp

@@ -6,7 +6,7 @@ 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<std::string> graph;
   graph.MakeDirected();
 
   for (size_t i = 0; i < experiments_amount; i++) {

additional_tasks/find_word_chains/CMakeLists.txt

@@ -0,0 +1,39 @@
+cmake_minimum_required(VERSION 3.20)
+
+get_filename_component(PROJECT_NAME ${CMAKE_CURRENT_LIST_DIR} NAME)
+string(REPLACE " " "_" PROJECT_NAME ${PROJECT_NAME})
+project(${PROJECT_NAME} LANGUAGES 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")
+set(TEST_SOURCE_LIST ${SOURCE_LIST})
+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)
+
+find_library(Utils ../)
+
+add_executable(${PROJECT_NAME} ${SOURCE_LIST})
+target_link_libraries(${PROJECT_NAME} PUBLIC Utils)
+
+# 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
+  Utils
+)
+
+include(GoogleTest)
+gtest_discover_tests(${PROJECT_NAME}_tests)

additional_tasks/find_word_chains/README.md

@@ -0,0 +1,32 @@
+# Задача: можно ли объединить список слов в цепочку
+
+Дан набор слов. Требуется определить, можно ли расположить эти слова в таком порядке, чтобы последняя буква каждого слова совпадала с первой буквой следующего слова, образуя замкнутую цепочку.
+
+Например, слова “for”, “rig”, “geek”, “kaf” можно соединить в цепочку (for -> rig -> geek -> kaf -> for), в то время как для слов “aab”, “abb” это невозможно.
+
+## Входные данные:
+
+* Первая строка содержит целое число `N` (`N` > 0) — количество слов.
+* Следующая строка содержит `N` строковых литералов, описывающих набор **слов**.
+
+## Выходные данные:
+
+* Выходные данные представляют собой строку, содержащую `Yes`, если слова образуют цепочку и `No`, если нет.
+
+## Решение:
+
+Для решения задачи используется подход, основанный на теории графов.  Набор слов преобразуется в ориентированный граф следующим образом:
+
+1. **Построение графа:**  Каждая буква английского алфавита (a-z) представляет собой вершину графа.  Для каждого слова создаётся ориентированное ребро, соединяющее первую букву слова с его последней буквой.  Например, для слова "for" будет создано ребро от вершины 'f' к вершине 'r'.
+
+2. **Проверка на Эйлеров цикл:** Задача сводится к проверке существования Эйлерова цикла в построенном графе. Эйлеров цикл — это циклический путь, проходящий через каждое ребро графа ровно один раз.  Для существования эйлерова цикла необходимо и достаточно выполнение следующих условий:
+
+    * **Степень вершин:**  В ориентированном графе для каждой вершины количество входящих ребер должно быть равно количеству исходящих ребер.
+    * **Связность:** Граф должен быть сильно связным, то есть из любой вершины должна быть достижима любая другая вершина, двигаясь по ребрам.
+
+3. **Алгоритм проверки:** Алгоритм реализует проверку условий существования эйлерова цикла:
+
+    * **Подсчет степеней:**  Для каждой вершины подсчитываются входящая и исходящая степени. Если хотя бы для одной вершины эти степени не равны, эйлеров цикл невозможен.
+    * **Проверка на связность:** Используется алгоритм поиска в глубину (Depth-First Search, DFS). Начинается обход с произвольной вершины, имеющей исходящее ребро.  Если после DFS не все вершины с ненулевой степенью были посещены, значит граф не сильно связный, а значит, и эйлерова цикла нет.
+
+Если оба условия выполнены, алгоритм возвращает "Yes", в противном случае — "No".

additional_tasks/find_word_chains/src/euler_path.hpp

@@ -0,0 +1,148 @@
+#pragma once
+
+#include "graph.hpp"
+
+namespace {
+
+/**
+ * @brief
+ *
+ * @tparam vert_t
+ * @tparam weight_t
+ * @param v
+ * @param graph
+ * @param visited
+ */
+
+/**
+ * @brief Вспомогательная рекурсивная функция для обхода графа в глубину (DFS).
+ *
+ * @details Проверяет связность графа, начиная с вершины `v`.  Эта функция
+ * используется внутри `HasEulerPath` для проверки связности после проверки
+ * количества вершин с нечётной степенью.
+ *
+ * @tparam vert_t: тип вершин графа.
+ * @tparam weight_t: тип весов рёбер графа.
+ * @param v: начальная вершина для DFS.
+ * @param graph: граф, в котором выполняется обход.
+ * @param visited: посещенные вершины.
+ */
+template <AllowedVertType vert_t, AllowedWeightType weight_t>
+inline void HasEulerPathStep(const vert_t& v,
+                             const Graph<vert_t, weight_t>& graph,
+                             std::unordered_map<vert_t, bool>& visited) {
+  visited[v] = true;
+
+  // получаем соседнюю вершину (откуда идёт ребро), если соседняя вершина ещё не
+  // посещена, рекурсивно вызываем DFS для неё.
+
+  for (const auto& edge_tuple : graph.Edges()) {
+    if (StartVertFromTuple(edge_tuple) == v) {
+      vert_t neighbor = EndVertFromTuple(edge_tuple);
+
+      if (!visited[neighbor]) HasEulerPathStep(neighbor, graph, visited);
+    }
+
+    if (EndVertFromTuple(edge_tuple) == v && !graph.IsDirected()) {
+      vert_t neighbor = StartVertFromTuple(edge_tuple);
+
+      if (!visited[neighbor]) HasEulerPathStep(neighbor, graph, visited);
+    }
+  }
+}
+
+/**
+ * @brief Вычисляет исходящую степень вершины в графе.
+ *
+ * @tparam vert_t: тип вершин графа.
+ * @tparam weight_t: тип весов рёбер графа.
+ * @param graph: граф, в котором вычисляется исходящая степень.
+ * @param v: вершина, для которой вычисляется исходящая степень.
+ *
+ * @return size_t: исходящая степень вершины (количество исходящих ребер).
+ */
+template <AllowedVertType vert_t, AllowedWeightType weight_t>
+inline size_t OutDeg(const Graph<vert_t, weight_t>& graph, const vert_t& v) {
+  return graph.GetAdjList()[v].size();
+}
+
+/**
+ * @brief Вычисляет входящую степень вершины в графе.
+ *
+ * @tparam vert_t: тип вершин графа.
+ * @tparam weight_t: тип весов рёбер графа.
+ * @param graph: граф, в котором вычисляется входящая степень.
+ * @param v: вершина, для которой вычисляется входящая степень.
+ *
+ * @return size_t: входящая степень вершины (количество входящих ребер).
+ */
+template <AllowedVertType vert_t, AllowedWeightType weight_t>
+inline size_t InDeg(const Graph<vert_t, weight_t>& graph, const vert_t& v) {
+  // для неориентированных графов входящая степень равна исходящей
+  if (!graph.IsDirected()) return OutDeg(graph, v);
+
+  size_t res = 0;
+
+  auto adj_list = graph.GetAdjList();
+
+  for (const auto& u : graph.Verts())
+    if (Contains(adj_list[u], v)) res++;
+
+  return res;
+}
+
+}  // namespace
+
+/**
+ * @brief Проверяет, существует ли в графе эйлеров путь.
+ *
+ * @details Эйлеров путь — это путь в графе, который проходит через каждое ребро
+ * ровно один раз. Функция сначала проверяет необходимое, но недостаточное
+ * условие существования эйлерова пути: количество вершин с нечетной степенью
+ * должно быть не больше двух. Затем она проверяет связность графа с помощью
+ * DFS.
+ *
+ * @tparam vert_t: тип вершин графа.
+ * @tparam weight_t: тип весов рёбер графа.
+ * @param graph: граф, для которого проверяется наличие эйлерова пути.
+ *
+ * @return `true`, если эйлеров путь существует
+ * @return `false` в противном случае.
+ */
+template <AllowedVertType vert_t, AllowedWeightType weight_t>
+inline bool HasEulerPath(const Graph<vert_t, weight_t>& graph) {
+  // считаем количество вершин с нечетной степенью
+  size_t odd_vert_count = 0;
+
+  for (const auto& v : graph.Verts())
+    if (OutDeg(graph, v) != InDeg(graph, v))
+      odd_vert_count++;
+
+    else if (!graph.IsDirected() && OutDeg(graph, v) % 2 != 0)
+      odd_vert_count++;
+
+  // если вершин с нечетной степенью больше двух, то эйлерова пути нет
+  if (odd_vert_count > 2) return false;
+
+  std::unordered_map<vert_t, bool> visited;
+  for (const auto& vert : graph.Verts()) visited[vert] = false;
+
+  std::unordered_map<vert_t, size_t> degree;
+  for (const auto& vert : graph.Verts())
+    degree[vert] = graph.IsDirected() ? InDeg(graph, vert) + OutDeg(graph, vert)
+                                      : OutDeg(graph, vert);
+
+  // находим первую вершину с ненулевой степенью и начинаем DFS
+  for (const auto& v : graph.Verts())
+    if (degree[v] > 0) {
+      HasEulerPathStep(v, graph, visited);
+      break;
+    }
+
+  // проверяем, все ли вершины с ненулевой степенью были посещены.
+  for (const auto& v : graph.Verts())
+    if (degree[v] > 0 && !visited[v]) return false;
+
+  // все вершины с ненулевой степенью были посещены, эйлеров путь существует
+  return true;
+}

additional_tasks/find_word_chains/src/find_word_chains.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "euler_path.hpp"
+
+/**
+ * @brief Проверяет, можно ли составить цепочку из заданных слов так, чтобы
+ * последняя буква каждого слова совпадала с первой буквой следующего.
+ *
+ * @param words вектор строк (слов), которые нужно проверить.
+ *
+ * @return `true`: слова можно объединить в цепочку
+ * @return `false`: в противном случае
+ */
+bool CanBeChained(const std::vector<std::string>& words) {
+  if (words.empty()) return true;
+
+  Graph<char> chars_graph;
+
+  for (const std::string& s : words) {
+    if (s.empty()) continue;  // пропускаем пустые строки
+
+    chars_graph.AddEdge({s[0], s.back()});
+  }
+
+  // дополнительная проверка на связность:
+  if (chars_graph.VertsAmount() > 0 && chars_graph.EdgesAmount() == 0)
+    return false;  // есть изолированная вершина
+
+  // проверка на Эйлеров цикл
+  return HasEulerPath(chars_graph);
+}
+
+/// @brief Решает задачу: ""
+void Solution(std::istream& is = std::cin, std::ostream& os = std::cout) {
+  size_t words_amount;
+  is >> words_amount;
+
+  std::vector<std::string> words(words_amount);
+  for (auto& word : words) is >> word;
+
+  if (CanBeChained(words))
+    os << "Yes";
+  else
+    os << "No";
+
+  os << std::endl;
+}

additional_tasks/find_word_chains/src/main.cpp

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

additional_tasks/find_word_chains/src/test.cpp

@@ -0,0 +1,93 @@
+#include <gtest/gtest.h>
+
+#include "find_word_chains.hpp"
+
+TEST(CanBeChainedTest, EmptyInput) {
+  std::vector<std::string> words = {};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, SingleWord) {
+  std::vector<std::string> words = {"abc"};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, SimpleChain) {
+  std::vector<std::string> words = {"for", "rig", "geek", "kaf"};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, SimpleChain2) {
+  std::vector<std::string> words = {"abc", "cba"};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, NoChain2) {
+  std::vector<std::string> words = {"abc", "def"};
+  ASSERT_FALSE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, SameStartEnd) {
+  std::vector<std::string> words = {"aba", "cba", "acc"};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, MultipleSameWords) {
+  std::vector<std::string> words = {"aba", "aba", "aca"};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, WordsWithSameStartEnd) {
+  std::vector<std::string> words = {"aaa", "bbb", "ccc"};
+  ASSERT_FALSE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, MultipleWordsWithSameStartEnd) {
+  std::vector<std::string> words = {"aaa", "aba", "aca"};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, MultipleWordsWithSameStartEnd2) {
+  std::vector<std::string> words = {"aaa", "abb", "aba"};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, ComplexChain) {
+  std::vector<std::string> words = {"aba", "bab", "bba"};
+  ASSERT_FALSE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, ComplexChain2) {
+  std::vector<std::string> words = {"abc", "cde", "efg", "gba"};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, ComplexNoChain) {
+  std::vector<std::string> words = {"abc", "cde", "efg", "hbl"};
+  ASSERT_FALSE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, OneWordMultipleSameLetters) {
+  std::vector<std::string> words = {"aaaa"};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, TwoWordsSameStartEnd) {
+  std::vector<std::string> words = {"aaa", "bbb"};
+  ASSERT_FALSE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, EmptyWords) {
+  std::vector<std::string> words = {"abc", "", "def"};
+  ASSERT_FALSE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, EmptyWordsOnly) {
+  std::vector<std::string> words = {"", "", ""};
+  ASSERT_TRUE(CanBeChained(words));
+}
+
+TEST(CanBeChainedTest, LongChain) {
+  std::vector<std::string> words = {"a", "ab", "bc", "cd", "de", "ef", "fa"};
+  ASSERT_TRUE(CanBeChained(words));
+}