Pronin Arkadiy's Tasks

lib/src/graph.cpp

@@ -0,0 +1,197 @@
+#include "graph.hpp"
+
+#include <iostream>
+#include <stdexcept>
+
+#define UNREACHABLE (-1)
+
+using namespace algo;
+
+Graph::Graph(int v, int e) {
+  if (v <= 0)
+    throw std::invalid_argument(
+        "Number of vertices must be greater than zero.");
+
+  vertexes_num = v;
+  edges_num = e;
+  adjList.resize(v);
+}
+
+Graph::Graph(int v, int e, bool directed) {
+  if (v <= 0)
+    throw std::invalid_argument(
+        "Number of vertices must be greater than zero.");
+
+  vertexes_num = v;
+  edges_num = e;
+  is_directed = directed;
+  adjList.resize(v);
+}
+
+void Graph::AddEdge(int u, int v, int weight) {
+  if (u < 1 || u > vertexes_num || v < 1 || v > vertexes_num) {
+    throw std::out_of_range("Vertex out of bounds in addEdge.");
+  }
+
+  adjList[u - 1].emplace_back(v - 1, weight);
+  if (!is_directed) adjList[v - 1].emplace_back(u - 1, weight);
+
+  edges_num++;
+}
+
+int Graph::GetVertexesNum() {
+  if (vertexes_num <= 0)
+    throw std::runtime_error("Graph is not properly initialized.");
+  return vertexes_num;
+}
+
+int Graph::GetEdgesNum() { return edges_num; }
+
+const AdjacencyList Graph::GetAdjList() { return adjList; }
+
+void Graph::PrintGraph() const {
+  if (vertexes_num == 0) {
+    std::cerr << "Error: Graph is empty." << std::endl;
+    return;
+  }
+
+  for (int i = 0; i < vertexes_num; i++) {
+    if (adjList[i].empty()) continue;
+
+    std::cout << "Node " << i + 1 << ": ";
+
+    for (const auto& [neighbor, weight] : adjList[i]) {
+      std::cout << "(" << neighbor + 1 << ", " << weight << ") ";
+    }
+    std::cout << '\n';
+  }
+}
+
+std::vector<std::pair<int, int>> Graph::GetNeighbours(int v) {
+  if (v < 0 || v >= vertexes_num) {
+    throw std::out_of_range("Vertex index out of bounds in getNeighbours.");
+  }
+  return adjList[v];
+}
+
+void Graph::TopSort(int v, std::vector<bool>& visited, std::vector<int>& way) {
+  if (visited[v]) return;
+  visited[v] = true;
+  way.push_back(v);
+
+  for (auto [u, w] : GetNeighbours(v)) {
+    if (!visited[u]) {
+      TopSort(u, visited, way);
+    }
+  }
+}
+
+std::vector<int> Graph::TopologicalSort(int start) {
+  if (vertexes_num == 0) {
+    std::cerr
+        << "Error: Graph is empty, topological sort cannot be performed.\n";
+    return {};
+  }
+
+  std::vector<int> way;
+  std::vector<bool> visited(GetVertexesNum(), false);
+
+  TopSort(start, visited, way);
+
+  if (way.size() < vertexes_num)
+    throw std::invalid_argument("Graph is disconnected.");
+
+  return way;
+}
+
+std::vector<std::pair<int, int>> Graph::GetBridges() {
+  std::vector<int> tin(vertexes_num, -1);
+  std::vector<int> low(vertexes_num, -1);
+  std::vector<bool> visited(vertexes_num, false);
+  std::vector<std::pair<int, int>> bridges;
+  int timer = 0;
+
+  for (int i = 0; i < vertexes_num; i++) {
+    if (!visited[i]) {
+      DfsBridges(i, -1, tin, low, visited, timer, bridges);
+    }
+  }
+
+  return bridges;
+}
+
+void Graph::DfsBridges(int v, int parent, std::vector<int>& tin,
+                       std::vector<int>& low, std::vector<bool>& visited,
+                       int& timer, std::vector<std::pair<int, int>>& bridges) {
+  visited[v] = true;
+  tin[v] = low[v] = timer++;
+
+  for (auto [u, _] : adjList[v]) {
+    if (u == parent) continue;
+
+    if (!visited[u]) {
+      DfsBridges(u, v, tin, low, visited, timer, bridges);
+      low[v] = std::min(low[v], low[u]);
+
+      if (low[u] > tin[v]) {
+        bridges.emplace_back(v + 1, u + 1);  // Добавляем мост (нумерация с 1)
+      }
+    } else {
+      low[v] = std::min(low[v], tin[u]);
+    }
+  }
+}
+
+std::vector<int> Graph::GetArticulationPoints() {
+  std::vector<int> tin(vertexes_num, -1);
+  std::vector<int> low(vertexes_num, -1);
+  std::vector<bool> visited(vertexes_num, false);
+  std::vector<bool> isArticulationPoint(vertexes_num, false);
+  int timer = 0;
+
+  for (int i = 0; i < vertexes_num; i++) {
+    if (!visited[i]) {
+      DfsArticulation(i, -1, tin, low, visited, timer, isArticulationPoint);
+    }
+  }
+
+  std::vector<int> articulationPoints;
+  for (int i = 0; i < vertexes_num; i++) {
+    if (isArticulationPoint[i]) {
+      articulationPoints.push_back(i + 1);  // Нумерация с 1
+    }
+  }
+
+  return articulationPoints;
+}
+
+void Graph::DfsArticulation(int v, int parent, std::vector<int>& tin,
+                            std::vector<int>& low, std::vector<bool>& visited,
+                            int& timer,
+                            std::vector<bool>& isArticulationPoint) {
+  visited[v] = true;
+  tin[v] = low[v] = timer++;
+  int children = 0;
+
+  for (auto [u, _] : adjList[v]) {
+    if (u == parent) continue;
+
+    if (!visited[u]) {
+      children++;
+      DfsArticulation(u, v, tin, low, visited, timer, isArticulationPoint);
+      low[v] = std::min(low[v], low[u]);
+
+      // Условие для точки сочленения
+      if (parent != -1 && low[u] >= tin[v]) {
+        isArticulationPoint[v] = true;
+      }
+    } else {
+      low[v] = std::min(low[v], tin[u]);
+    }
+  }
+
+  // Отдельное условие для корня
+  if (parent == -1 && children > 1) {
+    isArticulationPoint[v] = true;
+  }
+}

lib/src/graph.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#ifndef GRAPH_HPP
+#define GRAPH_HPP
+
+#include <vector>
+
+using AdjacencyList = std::vector<std::vector<std::pair<int, int>>>;
+
+namespace algo {
+class Graph {
+ public:
+  Graph(int v, int e);
+
+  Graph(int v, int e, bool directed);
+
+  void AddEdge(int, int, int);
+
+  int GetVertexesNum();
+  int GetEdgesNum();
+  const AdjacencyList GetAdjList();
+
+  std::vector<std::pair<int, int>> GetNeighbours(int);
+
+  bool HasEdge(int, int) const;
+
+  void PrintGraph() const;
+
+  std::vector<int> TopologicalSort(int);
+
+  std::vector<std::pair<int, int>> GetBridges();
+  std::vector<int> GetArticulationPoints();
+
+ private:
+  int vertexes_num = 0;
+  int edges_num = 0;
+  bool is_directed = false;
+
+  AdjacencyList adjList;
+
+  void TopSort(int, std::vector<bool>&, std::vector<int>&);
+
+  void DfsBridges(int, int, std::vector<int>&, std::vector<int>&,
+                  std::vector<bool>&, int&, std::vector<std::pair<int, int>>&);
+
+  void DfsArticulation(int, int, std::vector<int>&, std::vector<int>&,
+                       std::vector<bool>&, int&, std::vector<bool>&);
+};
+};  // namespace algo
+
+#endif  // GRAPH_HPP

lib/src/util.cpp

@@ -1 +1,44 @@
 #include "util.hpp"
+
+#include <climits>
+#include <queue>
+#include <utility>
+#include <vector>
+
+#include "graph.hpp"
+
+using namespace std;
+
+vector<int> FindWays(algo::Graph graph, int start) {
+  vector<int> vis(graph.GetVertexesNum());
+  vector<int> dst(graph.GetVertexesNum(), INT_MAX);
+
+  dst[start - 1] = 0;
+
+  Dijkstra(start - 1, -1, vis, dst, graph.GetAdjList());
+
+  return dst;
+}
+
+void Dijkstra(int v, int from, vector<int>& vis, vector<int>& dst,
+              const AdjacencyList adj) {
+  using Pair = pair<int, int>;
+
+  priority_queue<Pair, vector<Pair>, greater<Pair>> q;
+
+  q.push({0, v});
+  while (!q.empty()) {
+    auto [cur_d, v] = q.top();
+    q.pop();
+
+    if (cur_d > dst[v]) continue;
+
+    for (auto [u, w] : adj[v]) {
+      if (dst[u] > dst[v] + w) {
+        dst[u] = dst[v] + w;
+
+        q.push({dst[u], u});
+      }
+    }
+  }
+}

lib/src/util.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <vector>
+
+#include "graph.hpp"
+
+std::vector<int> FindWays(algo::Graph, int);
+
+void Dijkstra(int, int, std::vector<int>&, std::vector<int>&,
+              const AdjacencyList);

task_01/src/main.cpp

@@ -1 +1,25 @@
-int main() { return 0; }
+#include <iostream>
+
+#include "graph.hpp"
+
+int main() {
+  int vertexes_num, edges_num;
+  std::cin >> vertexes_num >> edges_num;
+
+  algo::Graph graph(vertexes_num, edges_num);
+
+  for (int i = 0; i < edges_num; i++) {
+    int a, b, w;
+
+    std::cin >> a >> b >> w;
+
+    graph.AddEdge(a, b, w);
+  }
+
+  std::cout << "Topsort:" << std::endl;
+  for (auto i : graph.TopologicalSort(0)) {
+    std::cout << i + 1 << " ";
+  }
+
+  std::cout << std::endl;
+}