From 79fdff5e301b4e7d71f1f4fb078ac605872ab345 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Fri, 1 Nov 2024 14:39:54 +0000 Subject: [PATCH 01/16] task_01 are done and part of task_2 ready --- lib/src/Graph.hpp | 173 ++++++++++++++++++++++++++++++ task_01/src/main.cpp | 2 + task_01/src/test.cpp | 108 ++++++++++++++++++- task_01/src/top_sort.cpp | 20 ++++ task_01/src/top_sort.hpp | 9 ++ task_02/src/bridges_and_point.cpp | 52 +++++++++ task_02/src/bridges_and_point.hpp | 7 ++ task_02/src/stack.cpp | 21 ---- task_02/src/stack.hpp | 23 ---- task_02/src/test.cpp | 45 ++------ 10 files changed, 376 insertions(+), 84 deletions(-) create mode 100644 lib/src/Graph.hpp create mode 100644 task_01/src/top_sort.cpp create mode 100644 task_01/src/top_sort.hpp create mode 100644 task_02/src/bridges_and_point.cpp create mode 100644 task_02/src/bridges_and_point.hpp delete mode 100644 task_02/src/stack.cpp delete mode 100644 task_02/src/stack.hpp diff --git a/lib/src/Graph.hpp b/lib/src/Graph.hpp new file mode 100644 index 0000000..77a293a --- /dev/null +++ b/lib/src/Graph.hpp @@ -0,0 +1,173 @@ +#include + +using namespace std; + +struct Edge { + int from, to, weight; +}; + +struct Graph { + vector> gr; + vector>> directed_graph; + vector used; + vector color; + vector parents; + vector topsort; + vector> comps; + vector dist; + int cnt = 0; + + void read_WUG(int& n, int& m, + vector>& vec) {// взвешенный неориентированный + directed_graph.resize(n + 1); + used.resize(n + 1, 0); + color.resize(n + 1, 0); + parents.resize(n + 1, -1); + comps.resize(n + 1); + for (int i = 0; i < m; i++) { + int u, v, w; + u = vec[i][0]; + v = vec[i][1]; + w = vec[i][2]; + directed_graph[u].push_back({v, w}); + directed_graph[v].push_back({u, w}); + } + } + + void read_WDG(int& n, int& m, + vector>& vec) {// взвешенный ориентированный + directed_graph.resize(n + 1); + used.resize(n + 1, 0); + color.resize(n + 1, 0); + parents.resize(n + 1, -1); + comps.resize(n + 1); + for (int i = 0; i < m; i++) { + int u, v, w; + u = vec[i][0]; + v = vec[i][1]; + w = vec[i][2]; + directed_graph[u].push_back({v, w}); + } + } + + void read_UUG(int& n, int& m, + vector>& vec) {// невзвешенный неориентированный + gr.resize(n + 1); + used.resize(n + 1, 0); + comps.resize(n + 1); + for (int i = 0; i < m; i++) { + int u, v; + u = vec[i].first; + v = vec[i].second; + gr[u].push_back(v); + gr[v].push_back(u); + } + } + + void read_UDG(int& n, int& m, + vector>& vec) {// невзвешенный ориентированный + gr.resize(n + 1); + used.resize(n + 1, 0); + color.resize(n + 1, 0); + parents.resize(n + 1, -1); + comps.resize(n + 1); + for (int i = 0; i < m; i++) { + int u, v; + u = vec[i].first; + v = vec[i].second; + gr[u].push_back(v); + } + } + + void dfs(int u, int count) { + used[u] = 1; + comps[count].push_back(u); + for (auto it: gr[u]) { + if (!used[it]) { + dfs(it, count); + } + } + topsort.push_back(u); + } + + vector> components(int& n) { + for (int i = 1; i <= n; i++) { + if (!used[i]) { + dfs(i, cnt++); + } + } + return comps; + } + + bool has_cycle_undirected(int& n) { + for (int i = 1; i <= n; i++) { + if (!used[i]) { + if (dfs_cycle_undirected(i, -1)) { + return true; + } + } + } + return false; + } + + bool dfs_cycle_undirected(int v, int p) { + used[v] = 1; + for (int to: gr[v]) { + if (!used[to]) { + if (dfs_cycle_undirected(to, v)) { + return true; + }; + } else if (to != p) { + return true; + } + } + return false; + } + + bool has_cycle_directed(int& n) { + for (int i = 1; i <= n; i++) { + if (!used[i]) { + if (dfs_cycle_directed_W(i)) { + return true; + } + } + } + return false; + } + + bool dfs_cycle_directed_W(int v) { + used[v] = 1; + color[v] = 1; + for (auto &edge: directed_graph[v]) { + int to = edge.first; + if (!used[to]) { + if (dfs_cycle_directed_W(to)) { + return true; + } + } else if (color[to] == 1) { + return true; + } + } + color[v] = 2; + return false; + } + + //Используется для нахождения Top_Sort и проверке на циклы + bool dfs_cycle_directed_U(int v) { + used[v] = 1; + color[v] = 1; + for (auto &edge: gr[v]) { + int to = edge; + if (!used[to]) { + if (dfs_cycle_directed_U(to)) { + return true; + } + } else if (color[to] == 1) { + return true; + } + } + color[v] = 2; + topsort.push_back(v); + return false; + } +}; \ No newline at end of file diff --git a/task_01/src/main.cpp b/task_01/src/main.cpp index 76e8197..0e4393b 100644 --- a/task_01/src/main.cpp +++ b/task_01/src/main.cpp @@ -1 +1,3 @@ +#include + int main() { return 0; } diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 87cef73..b961aa5 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,5 +1,107 @@ #include -TEST(Test, Simple) { - ASSERT_EQ(1, 1); // Stack [] -} \ No newline at end of file +#include "top_sort.hpp" + +TEST(SimpleGraph, Simple) { + int vertices = 3; + int edges = 2; + std::vector> edge = {{1, 2}, {2, 3}}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected = { + 1, 2, 3}; + + ASSERT_EQ(result, expected); +} + +TEST(GraphWithCycle, Simple) { + int vertices = 3; + int edges = 3; + std::vector> edge = {{1, 2}, {2, 3}, {3, 1}}; + + EXPECT_THROW(TopSort(vertices, edges, edge);, CycleGraph); +} + +TEST(DisconnectedGraph, Simple) { + int vertices = 4; + int edges = 2; + std::vector> edge = {{1, 2}, {3, 4}}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected ={3, 4, 1, 2}; + + ASSERT_EQ(result, expected); +} + +TEST(SingleVertex, Simple) { + int vertices = 1; + int edges = 0; + std::vector> edge = {}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected = {1}; + + ASSERT_EQ(result, expected); +} + +TEST(MultipleValidOrders, Simple) { + int vertices = 4; + int edges = 3; + std::vector> edge = {{1, 2}, {1, 3}, {3, 4}}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected1 = {1, 3, 4, 2}; + + ASSERT_EQ(result, expected1); +} + +TEST(AllVerticesConnected, Simple) { + int vertices = 5; + int edges = 4; + std::vector> edge = {{1, 2}, {2, 3}, {3, 4}, {4, 5}}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected = {1, 2, 3, 4, 5}; + + ASSERT_EQ(result, expected); +} + +TEST(ReverseOrder, Simple) { + int vertices = 3; + int edges = 2; + std::vector> edge = {{3, 2}, {2, 1}}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected = {3, 2, 1}; + + ASSERT_EQ(result, expected); +} + +TEST(ComplexGraph, Simple) { + int vertices = 6; + int edges = 6; + std::vector> edge = {{5, 2}, {5, 0}, {4, 0}, {4, 1}, {2, 3}, {3, 1}}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected = {6, 5, 4, 0, 2, 3, 1}; + + ASSERT_EQ(result, expected); +} + +TEST(GraphWithMultipleCyclesm, Simple) { + int vertices = 4; + int edges = 5; + std::vector> edge = {{1, 2}, {2, 3}, {3, 1}, {2, 4}, {4, 2}}; + + EXPECT_THROW(TopSort(vertices, edges, edge), CycleGraph); +} + +TEST(MediumGraph, Simple){ + int vertices = 6; + int edges = 6; + std::vector> edge = {{5, 2}, {4, 2}, {3, 4}, {6, 3}, {6, 1}, {5, 1}}; + std::vector result = TopSort(vertices, edges, edge); + std::vector expected = {6, 5, 3, 4, 2, 1}; + + ASSERT_EQ(result, expected); +} diff --git a/task_01/src/top_sort.cpp b/task_01/src/top_sort.cpp new file mode 100644 index 0000000..e8bcf4b --- /dev/null +++ b/task_01/src/top_sort.cpp @@ -0,0 +1,20 @@ +#include "top_sort.hpp" + +#include + +std::vector TopSort(int vertices, int edges, + std::vector>& edge) { + Graph graph_UDG; + graph_UDG.read_UDG(vertices, edges, edge); + bool is_cycle = false; + for (int i = 1; i <= vertices; i++) { + if (!graph_UDG.used[i]) { + is_cycle = graph_UDG.dfs_cycle_directed_U(i); + } + if (is_cycle) { + throw CycleGraph("Cycle found -> Topological sorting is not possible"); + } + } + reverse(graph_UDG.topsort.begin(), graph_UDG.topsort.end()); + return graph_UDG.topsort; +} \ No newline at end of file diff --git a/task_01/src/top_sort.hpp b/task_01/src/top_sort.hpp new file mode 100644 index 0000000..2a3e061 --- /dev/null +++ b/task_01/src/top_sort.hpp @@ -0,0 +1,9 @@ +#pragma once +#include +#define int long + +class CycleGraph : public std::logic_error { + using std::logic_error::logic_error; +}; + +std::vector TopSort(int vertices, int edges, std::vector>& edge); \ No newline at end of file diff --git a/task_02/src/bridges_and_point.cpp b/task_02/src/bridges_and_point.cpp new file mode 100644 index 0000000..34b2360 --- /dev/null +++ b/task_02/src/bridges_and_point.cpp @@ -0,0 +1,52 @@ +#include + +#include "Graph.hpp" + +using namespace std; + +vector> gr; +vector ret, h; +vector u; + +int one = 0; +set ans; + +void dfs(int v, int p) { + if (p == -1) + h[v] = 0; + else + h[v] = h[p] + 1; + ret[v] = h[v]; + u[v] = true; + for (auto& to : gr[v]) { + if (to == p) continue; + if (u[to]) { + ret[v] = min(ret[v], h[to]); + } else { + if (p == -1) one++; + dfs(to, v); + ret[v] = min(ret[v], ret[to]); + if (ret[to] >= h[v]) ans.insert(v); + } + } +} + +set cut_point(int& n, int& m, vector>& vec){ + Graph graph; + graph.read_UUG(n, m, vec); + u.resize(n + 1, 0); + ret.resize(n + 1, 1e9); + h.resize(n + 1, 1e9); + gr = graph.gr; + u = graph.used; + for (int i = 1; i <= n; i++) { + if (u[i] == 0) { + one = 0; + dfs(i, -1); + if (one <= 1) { + ans.erase(i); + } + } + } + return ans; +} diff --git a/task_02/src/bridges_and_point.hpp b/task_02/src/bridges_and_point.hpp new file mode 100644 index 0000000..80f6fd0 --- /dev/null +++ b/task_02/src/bridges_and_point.hpp @@ -0,0 +1,7 @@ +#pragma once +#include +using namespace std; + +void dfs(int v, int p); + +set cut_point(int& n, int& m, vector>& vec); \ No newline at end of file diff --git a/task_02/src/stack.cpp b/task_02/src/stack.cpp deleted file mode 100644 index 8ca8990..0000000 --- a/task_02/src/stack.cpp +++ /dev/null @@ -1,21 +0,0 @@ -#include "stack.hpp" - -#include - -void Stack::Push(int value) { data_.push(value); } - -int Stack::Pop() { - auto result = data_.top(); - data_.pop(); - return result; -} - -void MinStack::Push(int value) { data_.push_back(value); } - -int MinStack::Pop() { - auto result = data_.back(); - data_.pop_back(); - return result; -} - -int MinStack::GetMin() { return *std::min_element(data_.begin(), data_.end()); } \ No newline at end of file diff --git a/task_02/src/stack.hpp b/task_02/src/stack.hpp deleted file mode 100644 index 138ec40..0000000 --- a/task_02/src/stack.hpp +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include -#include - -class Stack { - public: - void Push(int value); - int Pop(); - - private: - std::stack data_; -}; - -class MinStack { - public: - void Push(int value); - int Pop(); - int GetMin(); - - private: - std::vector data_; -}; diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 54e7ce9..7a3d881 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -1,42 +1,13 @@ - #include -#include - -#include "stack.hpp" +#include "bridges_and_point.hpp" -TEST(StackTest, Simple) { - Stack stack; - stack.Push(1); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - stack.Push(3); // Stack [1, 3] - ASSERT_EQ(stack.Pop(), 3); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] -} +TEST(SimpleTest, Simple){ + int vertices = 6; + int edge = 7; + std::vector> edges = {{1, 2}, {2, 3}, {2, 4}, {2, 5}, {4, 5}, {1, 3}, {3, 6}}; -TEST(MinStackTest, Simple) { - MinStack stack; - stack.Push(1); // Stack [1] - ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] - ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] - stack.Push(1); // Stack [1] - stack.Push(2); // Stack [1, 2] - ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 2); // Stack [1] - stack.Push(3); // Stack [1, 3] - ASSERT_EQ(stack.GetMin(), 1); - ASSERT_EQ(stack.Pop(), 3); // Stack [1] - ASSERT_EQ(stack.Pop(), 1); // Stack [] + set result = cut_point(vertices, edge, edges); + set expected = {2, 3}; + ASSERT_EQ(result, expected); } \ No newline at end of file From e4aab975d266495f8eee3c79ca5cb561496e7e7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Fri, 8 Nov 2024 17:23:10 +0000 Subject: [PATCH 02/16] task02 and task04 done --- additional_tasks/template_task/src/utils.cpp | 1 - additional_tasks/template_task/src/utils.hpp | 1 - task_02/src/bridges_and_point.cpp | 68 ++++++++- task_02/src/bridges_and_point.hpp | 9 +- task_02/src/test.cpp | 136 ++++++++++++++++-- task_04/src/algorithm_Dijkstra.hpp | 11 ++ task_04/src/algotihm_Dijkstra.cpp | 54 +++++++ task_04/src/test.cpp | 140 ++++++++++++++++++- 8 files changed, 400 insertions(+), 20 deletions(-) delete mode 100644 additional_tasks/template_task/src/utils.cpp delete mode 100644 additional_tasks/template_task/src/utils.hpp create mode 100644 task_04/src/algorithm_Dijkstra.hpp create mode 100644 task_04/src/algotihm_Dijkstra.cpp diff --git a/additional_tasks/template_task/src/utils.cpp b/additional_tasks/template_task/src/utils.cpp deleted file mode 100644 index 0ee624c..0000000 --- a/additional_tasks/template_task/src/utils.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "utils.hpp" diff --git a/additional_tasks/template_task/src/utils.hpp b/additional_tasks/template_task/src/utils.hpp deleted file mode 100644 index 6f70f09..0000000 --- a/additional_tasks/template_task/src/utils.hpp +++ /dev/null @@ -1 +0,0 @@ -#pragma once diff --git a/task_02/src/bridges_and_point.cpp b/task_02/src/bridges_and_point.cpp index 34b2360..6a51600 100644 --- a/task_02/src/bridges_and_point.cpp +++ b/task_02/src/bridges_and_point.cpp @@ -7,11 +7,14 @@ using namespace std; vector> gr; vector ret, h; vector u; +vector used, tin, fup, used_br; +vector> answer; +int timer = 1; int one = 0; set ans; -void dfs(int v, int p) { +void Dfs_cut_point(int v, int p) { if (p == -1) h[v] = 0; else @@ -24,16 +27,14 @@ void dfs(int v, int p) { ret[v] = min(ret[v], h[to]); } else { if (p == -1) one++; - dfs(to, v); + Dfs_cut_point(to, v); ret[v] = min(ret[v], ret[to]); if (ret[to] >= h[v]) ans.insert(v); } } } -set cut_point(int& n, int& m, vector>& vec){ - Graph graph; - graph.read_UUG(n, m, vec); +set Cut_point(int n, int m, Graph graph) { u.resize(n + 1, 0); ret.resize(n + 1, 1e9); h.resize(n + 1, 1e9); @@ -42,7 +43,7 @@ set cut_point(int& n, int& m, vector>& vec){ for (int i = 1; i <= n; i++) { if (u[i] == 0) { one = 0; - dfs(i, -1); + Dfs_cut_point(i, -1); if (one <= 1) { ans.erase(i); } @@ -50,3 +51,58 @@ set cut_point(int& n, int& m, vector>& vec){ } return ans; } + +void Dfs_cut_bridges(int u, int p = -1) { + used_br[u] = 1; + tin[u] = fup[u] = timer++; + for (auto it : gr[u]) { + if (it == p) { + continue; + } + if (used_br[it]) { + fup[u] = min(fup[u], tin[it]); + } else { + Dfs_cut_bridges(it, u); + fup[u] = min(fup[u], fup[it]); + if (fup[it] > tin[u]) { + answer.push_back({u, it}); + } + } + } +} + +vector> Cut_bridges(int n, int m, Graph graph) { + tin.resize(n + 1, 0); + fup.resize(n + 1, 1e9); + used_br.resize(n + 1, 0); + gr = graph.gr; + used_br = graph.used; + for (int i = 1; i <= n; i++) { + if (!used_br[i]) { + Dfs_cut_bridges(i); + } + } + + sort(answer.begin(), answer.end(), [](pair u, pair v) { + return u.first + u.second < v.first + v.second; + }); + + return answer; +} + +pair, vector>> Answer(int n, int m, + vector> vec) { + Graph graph; + graph.read_UUG(n, m, vec); + vector> answer_bridges = Cut_bridges(n, m, graph); + set answer_point = Cut_point(n, m, graph); + u.clear(); + ret.clear(); + h.clear(); + used_br.clear(); + tin.clear(); + fup.clear(); + answer.clear(); + ans.clear(); + return {answer_point, answer_bridges}; +} \ No newline at end of file diff --git a/task_02/src/bridges_and_point.hpp b/task_02/src/bridges_and_point.hpp index 80f6fd0..29e2f0e 100644 --- a/task_02/src/bridges_and_point.hpp +++ b/task_02/src/bridges_and_point.hpp @@ -2,6 +2,11 @@ #include using namespace std; -void dfs(int v, int p); +void Dfs_cut_point(int v, int p); +void Dfs_cit_bridges(int u, int p = -1); -set cut_point(int& n, int& m, vector>& vec); \ No newline at end of file +set Cut_point(int n, int m, const vector> gr); +vector> Cut_bridges(int& n, int& m, const vector> gr); + +pair, vector>> Answer(int n, int m, + vector> vec); \ No newline at end of file diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 7a3d881..f94e386 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -2,12 +2,132 @@ #include "bridges_and_point.hpp" -TEST(SimpleTest, Simple){ - int vertices = 6; - int edge = 7; - std::vector> edges = {{1, 2}, {2, 3}, {2, 4}, {2, 5}, {4, 5}, {1, 3}, {3, 6}}; - - set result = cut_point(vertices, edge, edges); - set expected = {2, 3}; - ASSERT_EQ(result, expected); +TEST(SimpleTest, Simple) { + int vertices = 6; + int edge = 6; + std::vector> edges = {{1, 3}, {2, 3}, {3, 4}, + {3, 5}, {4, 5}, {4, 6}}; + + pair, vector>> result = Answer(vertices, edge, edges); + pair, vector>> expected = {{3, 4}, + {{1, 3}, {3, 2}, {4, 6}}}; + ASSERT_EQ(result, expected); +} + +TEST(CutPointsAndBridgesTest, BasicFunctionality) { + int vertices = 5; + int edges = 5; + std::vector> edgeList = { + {1, 2}, {2, 3}, {3, 4}, {4, 5}, {2, 5}}; + + pair, vector>> result = + Answer(vertices, edges, edgeList); + set expectedCutPoints = {2}; + vector> expectedBridges = {{1, 2}}; + + ASSERT_EQ(result.first, expectedCutPoints); + ASSERT_EQ(result.second, expectedBridges); +} + +TEST(CutPointsAndBridgesTest, NoCutPoints) { + int vertices = 4; + int edges = 4; + std::vector> edgeList = {{1, 2}, {2, 3}, {3, 4}, {4, 1}}; + + pair, vector>> result = + Answer(vertices, edges, edgeList); + set expectedCutPoints = {}; + vector> expectedBridges = {}; + + ASSERT_EQ(result.first, expectedCutPoints); + ASSERT_EQ(result.second, expectedBridges); +} + +TEST(CutPointsAndBridgesTest, ComplexGraph) { + int vertices = 7; + int edges = 7; + std::vector> edgeList = {{1, 2}, {1, 3}, {2, 3}, {3, 4}, + {4, 5}, {5, 6}, {6, 7}}; + + pair, vector>> result = + Answer(vertices, edges, edgeList); + set expectedCutPoints = {3, 4, 5, 6}; + vector> expectedBridges = {{3, 4}, {4, 5}, {5, 6}, {6, 7}}; + + ASSERT_EQ(result.first, expectedCutPoints); + ASSERT_EQ(result.second, expectedBridges); +} + +TEST(CutPointsAndBridgesTest, TwoDisconnectedComponents) { + int vertices = 6; + int edges = 4; + std::vector> edgeList = {{1, 2}, {2, 3}, {4, 5}, {5, 6}}; + + pair, vector>> result = + Answer(vertices, edges, edgeList); + set expectedCutPoints = {2, 5}; + vector> expectedBridges = {{1, 2}, {2, 3}, {4, 5}, {5, 6}}; + + ASSERT_EQ(result.first, expectedCutPoints); + ASSERT_EQ(result.second, expectedBridges); +} + +TEST(CutPointsAndBridgesTest, StarTopology) { + int vertices = 5; + int edges = 4; + std::vector> edgeList = {{1, 2}, {1, 3}, {1, 4}, {1, 5}}; + + pair, vector>> result = + Answer(vertices, edges, edgeList); + set expectedCutPoints = {1}; + vector> expectedBridges = {{1, 2}, {1, 3}, {1, 4}, {1, 5}}; + + ASSERT_EQ(result.first, expectedCutPoints); + ASSERT_EQ(result.second, expectedBridges); +} + +TEST(CutPointsAndBridgesTest, CycleGraph) { + int vertices = 5; + int edges = 5; + std::vector> edgeList = { + {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 1}}; + + pair, vector>> result = + Answer(vertices, edges, edgeList); + set expectedCutPoints = {}; + vector> expectedBridges = {}; + + ASSERT_EQ(result.first, expectedCutPoints); + ASSERT_EQ(result.second, expectedBridges); +} + +TEST(CutPointsAndBridgesTest, SingleBridgeInComplexGraph) { + int vertices = 8; + int edges = 8; + std::vector> edgeList = {{1, 2}, {2, 3}, {3, 4}, {4, 5}, + {5, 6}, {6, 7}, {7, 8}, {5, 8}}; + + pair, vector>> result = + Answer(vertices, edges, edgeList); + set expectedCutPoints = {2, 3, 4, 5}; + vector> expectedBridges = {{1, 2}, {2, 3}, {3, 4}, {4, 5}}; + + ASSERT_EQ(result.first, expectedCutPoints); + ASSERT_EQ(result.second, expectedBridges); +} + +TEST(CutPointsAndBridgesTest, LargeGraph) { + int vertices = 10; + int edges = 9; + std::vector> edgeList = { + {1, 2}, {1, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8}, {8, 9}, {9, 10}}; + + pair, vector>> result = + Answer(vertices, edges, edgeList); + set expectedCutPoints = {1, 3, 4, 5, 6, 7, 8, 9}; + vector> expectedBridges = { + {1, 2}, {1, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8}, {8, 9}, {9, 10}}; + + ASSERT_EQ(result.first, expectedCutPoints); + ASSERT_EQ(result.second, expectedBridges); } \ No newline at end of file diff --git a/task_04/src/algorithm_Dijkstra.hpp b/task_04/src/algorithm_Dijkstra.hpp new file mode 100644 index 0000000..7719a75 --- /dev/null +++ b/task_04/src/algorithm_Dijkstra.hpp @@ -0,0 +1,11 @@ +#pragma once +#include + +using namespace std; + +class Nonexistent_way : public std::logic_error { + using std::logic_error::logic_error; +}; + +pair, vector> Dijkstra(int& n, int& m, int& s, int& t, + vector>& vec); \ No newline at end of file diff --git a/task_04/src/algotihm_Dijkstra.cpp b/task_04/src/algotihm_Dijkstra.cpp new file mode 100644 index 0000000..79c8dcb --- /dev/null +++ b/task_04/src/algotihm_Dijkstra.cpp @@ -0,0 +1,54 @@ +#include + +#include +#include + +using namespace std; + +pair, vector> Dijkstra(int& n, int& m, int& s, int& t, + vector>& vec) { + Graph graph; + graph.read_WUG(n, m, vec); + vector>> gr = graph.directed_graph; + vector put(n + 1, -1); + set> dist; + vector visited(n + 1, 0); + vector ans(n + 1, 1e9); + dist.emplace(0, s); + ans[s] = 0; + while (!dist.empty()) { + auto [d, u] = *dist.begin(); + visited[u] = 1; + dist.erase(dist.find(*dist.begin())); + ans[u] = d; + if (u == t) { + break; + } + for (auto [v, d1] : gr[u]) { + if (visited[v]) { + continue; + } + int new_d = d + d1; + if (new_d < ans[v]) { + if (dist.find({ans[v], v}) != dist.end()) { + dist.erase(dist.find({ans[v], v})); + } + ans[v] = new_d; + put[v] = u; + dist.emplace(new_d, v); + } + } + } + if (ans[t] == 1e9) { + throw Nonexistent_way("There is no path from point s to point t"); + } + vector way; + int tu = t; + while (put[t] != -1) { + way.push_back(t); + t = put[t]; + } + way.push_back(s); + reverse(way.begin(), way.end()); + return make_pair(make_pair(ans[tu], way.size()), way); +} \ No newline at end of file diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 5e11617..5d62ea7 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -1,6 +1,142 @@ - #include +#include + TEST(TopologySort, Simple) { - ASSERT_EQ(1, 1); // Stack [] + int n = 5; + int m = 7; + int s = 2; + int t = 5; + std::vector> vec = {{1, 2, 1}, {1, 3, 4}, {1, 5, 5}, {2, 3, 1}, + {3, 4, 2}, {3, 5, 3}, {4, 5, 7}}; + std::pair, std::vector> expected = {{4, 3}, + {2, 3, 5}}; + std::pair, std::vector> result = + Dijkstra(n, m, s, t, vec); + ASSERT_EQ(result, expected); +} + +TEST(DijkstraTest, BasicPath) { + int n = 4; + int m = 5; + int s = 1; + int t = 4; + std::vector> vec = { + {1, 2, 1}, {1, 3, 4}, {2, 3, 2}, {2, 4, 5}, {3, 4, 1}}; + std::pair, std::vector> expected = {{4, 4}, + {1, 2, 3, 4}}; + std::pair, std::vector> result = + Dijkstra(n, m, s, t, vec); + ASSERT_EQ(result, expected); +} + +TEST(DijkstraTest, NoPath) { + int n = 3; + int m = 2; + int s = 1; + int t = 3; + std::vector> vec = {{1, 2, 2}, {2, 1, 2}}; + EXPECT_THROW(Dijkstra(n, m, s, t, vec), Nonexistent_way); +} + +TEST(DijkstraTest, MultiplePaths) { + int n = 6; + int m = 8; + int s = 1; + int t = 5; + std::vector> vec = {{1, 2, 1}, {1, 3, 2}, {2, 4, 3}, + {3, 4, 1}, {4, 5, 1}, {2, 5, 5}, + {3, 5, 3}, {1, 6, 10}}; + std::pair, std::vector> expected = {{4, 4}, + {1, 3, 4, 5}}; + std::pair, std::vector> result = + Dijkstra(n, m, s, t, vec); + ASSERT_EQ(result, expected); +} + +TEST(DijkstraTest, SingleNode) { + int n = 1; + int m = 0; + int s = 1; + int t = 1; + std::vector> vec = {}; + std::pair, std::vector> expected = {{0, 1}, {1}}; + std::pair, std::vector> result = + Dijkstra(n, m, s, t, vec); + ASSERT_EQ(result, expected); } + +TEST(DijkstraTest, CyclePath) { + int n = 4; + int m = 4; + int s = 1; + int t = 3; + std::vector> vec = { + {1, 2, 1}, {2, 3, 2}, {3, 1, 2}, {2, 4, 1}, {4, 3, 1}}; + std::pair, std::vector> expected = {{2, 2}, {1, 3}}; + std::pair, std::vector> result = + Dijkstra(n, m, s, t, vec); + ASSERT_EQ(result, expected); +} + +TEST(DijkstraTest, LargeWeights) { + int n = 3; + int m = 3; + int s = 1; + int t = 3; + std::vector> vec = { + {1, 2, 1000}, {2, 3, 2000}, {1, 3, 5000}}; + std::pair, std::vector> expected = {{3000, 3}, + {1, 2, 3}}; + std::pair, std::vector> result = + Dijkstra(n, m, s, t, vec); + ASSERT_EQ(result, expected); +} + +TEST(DijkstraTest, ManyEdges) { + int n = 5; + int m = 10; + int s = 1; + int t = 5; + std::vector> vec = { + {1, 2, 1}, {1, 3, 2}, {1, 4, 5}, {2, 3, 1}, {2, 4, 2}, + {2, 5, 4}, {3, 4, 1}, {3, 5, 3}, {4, 5, 1}, {1, 5, 10}}; + std::pair, std::vector> expected = {{4, 4}, + {1, 2, 4, 5}}; + std::pair, std::vector> result = + Dijkstra(n, m, s, t, vec); + ASSERT_EQ(result, expected); +} + +TEST(DijkstraTest, ComplexGraph) { + int n = 6; + int m = 15; + int s = 1; + int t = 6; + std::vector> vec = { + {1, 2, 1}, {1, 3, 4}, {1, 4, 2}, {2, 3, 1}, {2, 4, 5}, + {3, 5, 2}, {4, 5, 3}, {4, 6, 1}, {5, 6, 1}, {2, 6, 10}, + {3, 4, 2}, {1, 5, 7}, {2, 5, 3}, {4, 3, 1}, {5, 1, 8}}; + std::pair, std::vector> expected = {{3, 3}, + {1, 4, 6}}; + std::pair, std::vector> result = + Dijkstra(n, m, s, t, vec); + ASSERT_EQ(result, expected); +} + +TEST(DijkstraTest, DenseGraph) { + int n = 7; + int m = 21; + int s = 1; + int t = 7; + std::vector> vec = { + {1, 2, 1}, {1, 3, 2}, {1, 4, 3}, {1, 5, 4}, {1, 6, 5}, + {2, 3, 1}, {2, 4, 2}, {2, 5, 3}, {2, 6, 4}, {2, 7, 5}, + {3, 4, 1}, {3, 5, 2}, {3, 6, 3}, {3, 7, 4}, {4, 5, 1}, + {4, 6, 2}, {4, 7, 3}, {5, 6, 1}, {5, 7, 2}, {6, 7, 1}}; + std::pair, std::vector> expected = {{5, 5}, + {1, 2, 4, 7}}; + std::pair, std::vector> result = + Dijkstra(n, m, s, t, vec); + ASSERT_EQ(result, expected); +} \ No newline at end of file From fd244460862d93e08d389146c90e58aa2d92857c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Sun, 10 Nov 2024 17:06:12 +0000 Subject: [PATCH 03/16] Add Algorithm FLoid and ALgorithm Bellmana-Ford in Class Graph, all function are written with a capital letter, and part of algorithm Johnson are ready --- lib/src/Graph.hpp | 266 +++++++++++++----- task_01/src/top_sort.cpp | 4 +- task_02/src/bridges_and_point.cpp | 22 +- task_02/src/bridges_and_point.hpp | 5 +- task_03/src/algorithm_Jonsona.cpp | 16 ++ ...opology_sort.hpp => algorithm_Jonsona.hpp} | 0 task_03/src/topology_sort.cpp | 1 - ...hm_Dijkstra.cpp => algorithm_Dijkstra.cpp} | 2 +- 8 files changed, 221 insertions(+), 95 deletions(-) create mode 100644 task_03/src/algorithm_Jonsona.cpp rename task_03/src/{topology_sort.hpp => algorithm_Jonsona.hpp} (100%) delete mode 100644 task_03/src/topology_sort.cpp rename task_04/src/{algotihm_Dijkstra.cpp => algorithm_Dijkstra.cpp} (97%) diff --git a/lib/src/Graph.hpp b/lib/src/Graph.hpp index 77a293a..729aee1 100644 --- a/lib/src/Graph.hpp +++ b/lib/src/Graph.hpp @@ -2,40 +2,52 @@ using namespace std; +class NegativeCycleGraph : public std::logic_error { + using std::logic_error::logic_error; +}; + struct Edge { - int from, to, weight; + int from, to, weight; // Представляет ребро графа с начальной и конечной + // вершинами и весом. }; struct Graph { - vector> gr; - vector>> directed_graph; - vector used; - vector color; - vector parents; - vector topsort; - vector> comps; - vector dist; - int cnt = 0; - - void read_WUG(int& n, int& m, - vector>& vec) {// взвешенный неориентированный - directed_graph.resize(n + 1); - used.resize(n + 1, 0); - color.resize(n + 1, 0); - parents.resize(n + 1, -1); - comps.resize(n + 1); + vector edges; // Этот вектор нужен в реализации алгоритма Беллмана + // форда + vector> gr; // Список смежности для невзвешенного графа. + vector>> + directed_graph; // Список смежности для взвешенного ориентированного + // графа. + vector used; // Массив для отслеживания посещенных вершин. + vector color; // Массив для отслеживания состояния вершин (0 - не + // посещена, 1 - в процессе, 2 - посещена). + vector parents; // Массив для хранения родителей вершин в дереве обхода. + vector + topsort; // Массив для хранения порядка топологической сортировки. + vector> comps; // Массив для хранения компонент связности. + vector dist; // Массив для хранения расстояний от начальной вершины. + int cnt = 0; // Счетчик компонент связности. + + void ReadWUG(int& n, int& m, vector>& vec) { + // Читает взвешенный неориентированный граф из вектора vec. + directed_graph.resize(n + 1); // Инициализация списка смежности. + used.resize(n + 1, 0); // Инициализация массива посещенных вершин. + color.resize(n + 1, 0); // Инициализация массива цветов. + parents.resize(n + 1, -1); // Инициализация массива родителей. + comps.resize(n + 1); // Инициализация массива компонент. for (int i = 0; i < m; i++) { - int u, v, w; + int u, v, w; // Начальная, конечная вершины и вес ребра. u = vec[i][0]; v = vec[i][1]; w = vec[i][2]; - directed_graph[u].push_back({v, w}); - directed_graph[v].push_back({u, w}); + directed_graph[u].push_back( + {v, w}); // Добавление ребра в список смежности. + directed_graph[v].push_back({u, w}); // Добавление обратного ребра. } } - void read_WDG(int& n, int& m, - vector>& vec) {// взвешенный ориентированный + void ReadWDG(int& n, int& m, vector>& vec) { + // Читает взвешенный ориентированный граф из вектора vec. directed_graph.resize(n + 1); used.resize(n + 1, 0); color.resize(n + 1, 0); @@ -46,12 +58,13 @@ struct Graph { u = vec[i][0]; v = vec[i][1]; w = vec[i][2]; - directed_graph[u].push_back({v, w}); + directed_graph[u].push_back( + {v, w}); // Добавление ребра в список смежности. } } - void read_UUG(int& n, int& m, - vector>& vec) {// невзвешенный неориентированный + void ReadUUG(int& n, int& m, vector>& vec) { + // Читает невзвешенный неориентированный граф из вектора vec. gr.resize(n + 1); used.resize(n + 1, 0); comps.resize(n + 1); @@ -59,13 +72,13 @@ struct Graph { int u, v; u = vec[i].first; v = vec[i].second; - gr[u].push_back(v); - gr[v].push_back(u); + gr[u].push_back(v); // Добавление ребра в список смежности. + gr[v].push_back(u); // Добавление обратного ребра. } } - void read_UDG(int& n, int& m, - vector>& vec) {// невзвешенный ориентированный + void ReadUDG(int& n, int& m, vector>& vec) { + // Читает невзвешенный ориентированный граф из вектора vec. gr.resize(n + 1); used.resize(n + 1, 0); color.resize(n + 1, 0); @@ -75,99 +88,196 @@ struct Graph { int u, v; u = vec[i].first; v = vec[i].second; - gr[u].push_back(v); + gr[u].push_back(v); // Добавление ребра в список смежности. } } - void dfs(int u, int count) { - used[u] = 1; - comps[count].push_back(u); - for (auto it: gr[u]) { + void Dfs(int u, int count) { + // Выполняет обход в глубину (DFS) от вершины u и сохраняет компоненты + // связности. + used[u] = 1; // Помечаем вершину как посещенную. + comps[count].push_back(u); // Добавляем вершину в текущую компоненту. + for (auto it : gr[u]) { if (!used[it]) { - dfs(it, count); + Dfs(it, count); // Рекурсивный вызов для соседней вершины. } } - topsort.push_back(u); + topsort.push_back( + u); // Добавляем вершину в порядок топологической сортировки. } vector> components(int& n) { + // Находит все компоненты связности в графе. for (int i = 1; i <= n; i++) { if (!used[i]) { - dfs(i, cnt++); + Dfs(i, cnt++); // Запускаем DFS для каждой непосещенной вершины. } } - return comps; + return comps; // Возвращаем найденные компоненты. } - bool has_cycle_undirected(int& n) { + bool HasCycleUndirected(int& n) { + // Проверяет наличие циклов в невзвешенном неориентированном графе. for (int i = 1; i <= n; i++) { if (!used[i]) { - if (dfs_cycle_undirected(i, -1)) { - return true; + if (DfsCycleUndirected(i, -1)) { + return true; // Если цикл найден, возвращаем true. } } } - return false; + return false; // Циклов не найдено. } - - bool dfs_cycle_undirected(int v, int p) { - used[v] = 1; - for (int to: gr[v]) { + bool DfsCycleUndirected(int v, int p) { + // Выполняет DFS для проверки наличия циклов в невзвешенном графе. + used[v] = 1; // Помечаем вершину как посещенную. + for (int to : gr[v]) { if (!used[to]) { - if (dfs_cycle_undirected(to, v)) { - return true; + if (DfsCycleUndirected(to, v)) { + return true; // Если цикл найден, возвращаем true. }; } else if (to != p) { - return true; + return true; // Если соседняя вершина уже посещена и не является + // родителем, найден цикл. } } - return false; + return false; // Циклов не найдено. } - bool has_cycle_directed(int& n) { + bool HasCycleDirected(int& n) { + // Проверяет наличие циклов в взвешенном ориентированном графе. for (int i = 1; i <= n; i++) { if (!used[i]) { - if (dfs_cycle_directed_W(i)) { - return true; + if (DfsCycleDirectedW(i)) { + return true; // Если цикл найден, возвращаем true. } } } - return false; + return false; // Циклов не найдено. } - bool dfs_cycle_directed_W(int v) { - used[v] = 1; - color[v] = 1; - for (auto &edge: directed_graph[v]) { - int to = edge.first; + bool DfsCycleDirectedW(int v) { + // Выполняет DFS для проверки наличия циклов в ориентированном графе. + used[v] = 1; // Помечаем вершину как посещенную. + color[v] = 1; // Устанавливаем цвет в процессе. + for (auto& edge : directed_graph[v]) { + int to = edge.first; // Получаем соседнюю вершину. if (!used[to]) { - if (dfs_cycle_directed_W(to)) { - return true; + if (DfsCycleDirectedW(to)) { + return true; // Если цикл найден, возвращаем true. } } else if (color[to] == 1) { - return true; + return true; // Если соседняя вершина в процессе, найден цикл. } } - color[v] = 2; - return false; + color[v] = 2; // Устанавливаем цвет завершенной. + return false; // Циклов не найдено. } - //Используется для нахождения Top_Sort и проверке на циклы - bool dfs_cycle_directed_U(int v) { - used[v] = 1; - color[v] = 1; - for (auto &edge: gr[v]) { - int to = edge; + // Используется для нахождения Top_Sort и проверке на циклы + bool DfsCycleDirectedU(int v) { + // Выполняет DFS для топологической сортировки и проверки наличия циклов. + used[v] = 1; // Помечаем вершину как посещенную. + color[v] = 1; // Устанавливаем цвет в процессе. + for (auto& edge : gr[v]) { + int to = edge; // Получаем соседнюю вершину. if (!used[to]) { - if (dfs_cycle_directed_U(to)) { - return true; + if (DfsCycleDirectedU(to)) { + return true; // Если цикл найден, возвращаем true. } } else if (color[to] == 1) { - return true; + return true; // Если соседняя вершина в процессе, найден цикл. } } - color[v] = 2; - topsort.push_back(v); - return false; + color[v] = 2; // Устанавливаем цвет завершенной. + topsort.push_back( + v); // Добавляем вершину в порядок топологической сортировки. + return false; // Циклов не найдено. } -}; \ No newline at end of file + + // Реализация Алгоритма Флойда, на вход передается матрица (в виде двумерного + // массива), возвращает массив пар, в которой содержится пара вершин между + // которыми ориентированное ребро и его вес + vector, int>> AlgotihmFloida(int n, + vector>& vec) { + // Тройной цикл для перебора всех пар вершин (i, j) с промежуточной вершиной + // k + for (int k = 0; k < n; k++) { + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + // Проверяем, что i и j не совпадают + if (i != j) { + // Обновляем расстояние между вершинами i и j, если найдено более + // короткое + vec[i][j] = min(vec[i][j], vec[i][k] + vec[k][j]); + } + } + } + } + + // Вектор для хранения результатов: пар (i, j) и их расстояний + vector, int>> ans; + // Перебираем все пары вершин для формирования результата + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + // Проверяем, что расстояние не равно бесконечности и вершины i и j не + // совпадают + if (vec[i][j] != 1e9 && i != j) { + // Добавляем пару (i, j) и соответствующее расстояние в ответ + ans.push_back({{i, j}, vec[i][j]}); + } + } + } + + // Возвращаем вектор с кратчайшими путями + return ans; + } + + // Ниже реализован алгоритм Белмана Форда, который ищет кратчайшее расстояние + // между вершиной s и всеми остальными + vector AlgorithmBellmanaF(int n, int m, int s) { + edges.resize( + m); // Изменяем размер вектора рёбер на количество рёбер в графе + int k = 0; // Индекс для добавления рёбер + + // Заполнение списка рёбер + for (int i = 1; i <= n; i++) { + for (const auto& neighbor : directed_graph[i]) { + edges[k].from = i; // Устанавливаем начальную вершину + edges[k].to = neighbor.first; // Устанавливаем конечную вершину + edges[k].weight = neighbor.second; // Устанавливаем вес ребра + k++; // Переходим к следующему ребру + } + } + + vector distance( + n + 1, 1e9); // Инициализация расстояний до всех вершин бесконечностью + distance[s] = 0; // Расстояние до стартовой вершины равно 0 + + // Основной цикл алгоритма Беллмана-Форда + for (int i = 1; i <= n - 1; i++) { // Повторяем n-1 раз + for (const auto& edge : edges) { // Проходим по всем рёбрам + if (distance[edge.from] != + 1e9) { // Если до начальной вершины есть путь + distance[edge.to] = // Обновляем расстояние до конечной вершины + min(distance[edge.to], + distance[edge.from] + + edge.weight); // Сравниваем текущее расстояние и новое + } + } + } + + // Проверка на отрицательные циклы + for (const auto& edge : edges) { // Проходим по всем рёбрам еще раз + if (distance[edge.from] != 1e9 && // Если до начальной вершины есть путь + distance[edge.to] > + distance[edge.from] + + edge.weight) { // Если можно улучшить расстояние + throw NegativeCycleGraph( + "Error: Graph has negative cycle."); // Генерация исключения при + // обнаружении отрицательного + // цикла + } + } + return distance; // Возвращаем массив расстояний до всех вершин + } +}; diff --git a/task_01/src/top_sort.cpp b/task_01/src/top_sort.cpp index e8bcf4b..bdc0a2c 100644 --- a/task_01/src/top_sort.cpp +++ b/task_01/src/top_sort.cpp @@ -5,11 +5,11 @@ std::vector TopSort(int vertices, int edges, std::vector>& edge) { Graph graph_UDG; - graph_UDG.read_UDG(vertices, edges, edge); + graph_UDG.ReadUDG(vertices, edges, edge); bool is_cycle = false; for (int i = 1; i <= vertices; i++) { if (!graph_UDG.used[i]) { - is_cycle = graph_UDG.dfs_cycle_directed_U(i); + is_cycle = graph_UDG.DfsCycleDirectedU(i); } if (is_cycle) { throw CycleGraph("Cycle found -> Topological sorting is not possible"); diff --git a/task_02/src/bridges_and_point.cpp b/task_02/src/bridges_and_point.cpp index 6a51600..ffe4ac8 100644 --- a/task_02/src/bridges_and_point.cpp +++ b/task_02/src/bridges_and_point.cpp @@ -14,7 +14,7 @@ int timer = 1; int one = 0; set ans; -void Dfs_cut_point(int v, int p) { +void DfsCutPoint(int v, int p) { if (p == -1) h[v] = 0; else @@ -27,14 +27,14 @@ void Dfs_cut_point(int v, int p) { ret[v] = min(ret[v], h[to]); } else { if (p == -1) one++; - Dfs_cut_point(to, v); + DfsCutPoint(to, v); ret[v] = min(ret[v], ret[to]); if (ret[to] >= h[v]) ans.insert(v); } } } -set Cut_point(int n, int m, Graph graph) { +set CutPoint(int n, int m, Graph graph) { u.resize(n + 1, 0); ret.resize(n + 1, 1e9); h.resize(n + 1, 1e9); @@ -43,7 +43,7 @@ set Cut_point(int n, int m, Graph graph) { for (int i = 1; i <= n; i++) { if (u[i] == 0) { one = 0; - Dfs_cut_point(i, -1); + DfsCutPoint(i, -1); if (one <= 1) { ans.erase(i); } @@ -52,7 +52,7 @@ set Cut_point(int n, int m, Graph graph) { return ans; } -void Dfs_cut_bridges(int u, int p = -1) { +void DfsCutBridges(int u, int p = -1) { used_br[u] = 1; tin[u] = fup[u] = timer++; for (auto it : gr[u]) { @@ -62,7 +62,7 @@ void Dfs_cut_bridges(int u, int p = -1) { if (used_br[it]) { fup[u] = min(fup[u], tin[it]); } else { - Dfs_cut_bridges(it, u); + DfsCutBridges(it, u); fup[u] = min(fup[u], fup[it]); if (fup[it] > tin[u]) { answer.push_back({u, it}); @@ -71,7 +71,7 @@ void Dfs_cut_bridges(int u, int p = -1) { } } -vector> Cut_bridges(int n, int m, Graph graph) { +vector> CutBridges(int n, int m, Graph graph) { tin.resize(n + 1, 0); fup.resize(n + 1, 1e9); used_br.resize(n + 1, 0); @@ -79,7 +79,7 @@ vector> Cut_bridges(int n, int m, Graph graph) { used_br = graph.used; for (int i = 1; i <= n; i++) { if (!used_br[i]) { - Dfs_cut_bridges(i); + DfsCutBridges(i); } } @@ -93,9 +93,9 @@ vector> Cut_bridges(int n, int m, Graph graph) { pair, vector>> Answer(int n, int m, vector> vec) { Graph graph; - graph.read_UUG(n, m, vec); - vector> answer_bridges = Cut_bridges(n, m, graph); - set answer_point = Cut_point(n, m, graph); + graph.ReadUUG(n, m, vec); + vector> answer_bridges = CutBridges(n, m, graph); + set answer_point = CutPoint(n, m, graph); u.clear(); ret.clear(); h.clear(); diff --git a/task_02/src/bridges_and_point.hpp b/task_02/src/bridges_and_point.hpp index 29e2f0e..975d6dc 100644 --- a/task_02/src/bridges_and_point.hpp +++ b/task_02/src/bridges_and_point.hpp @@ -2,11 +2,12 @@ #include using namespace std; -void Dfs_cut_point(int v, int p); +void DfsCutPoint(int v, int p); void Dfs_cit_bridges(int u, int p = -1); set Cut_point(int n, int m, const vector> gr); -vector> Cut_bridges(int& n, int& m, const vector> gr); +vector> Cut_bridges(int& n, int& m, + const vector> gr); pair, vector>> Answer(int n, int m, vector> vec); \ No newline at end of file diff --git a/task_03/src/algorithm_Jonsona.cpp b/task_03/src/algorithm_Jonsona.cpp new file mode 100644 index 0000000..de203ac --- /dev/null +++ b/task_03/src/algorithm_Jonsona.cpp @@ -0,0 +1,16 @@ +#include + +#include + +using namespace std; + +void Jonson(int n, int m, vector>& arr_edges) { + int s = n + 1; + for (int i = 1; i <= n; i++) { + arr_edges.push_back({s, i, 0}); + } + int new_n = n + 1; + int new_m = m + n; + Graph graph; + graph.ReadWDG(new_n, new_m, arr_edges); +} diff --git a/task_03/src/topology_sort.hpp b/task_03/src/algorithm_Jonsona.hpp similarity index 100% rename from task_03/src/topology_sort.hpp rename to task_03/src/algorithm_Jonsona.hpp diff --git a/task_03/src/topology_sort.cpp b/task_03/src/topology_sort.cpp deleted file mode 100644 index e53f670..0000000 --- a/task_03/src/topology_sort.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "topology_sort.hpp" diff --git a/task_04/src/algotihm_Dijkstra.cpp b/task_04/src/algorithm_Dijkstra.cpp similarity index 97% rename from task_04/src/algotihm_Dijkstra.cpp rename to task_04/src/algorithm_Dijkstra.cpp index 79c8dcb..032c7dc 100644 --- a/task_04/src/algotihm_Dijkstra.cpp +++ b/task_04/src/algorithm_Dijkstra.cpp @@ -8,7 +8,7 @@ using namespace std; pair, vector> Dijkstra(int& n, int& m, int& s, int& t, vector>& vec) { Graph graph; - graph.read_WUG(n, m, vec); + graph.ReadWUG(n, m, vec); vector>> gr = graph.directed_graph; vector put(n + 1, -1); set> dist; From 9b1c034fe7b9b8d7e18497f714751c596c7fcdd3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Mon, 11 Nov 2024 15:59:32 +0000 Subject: [PATCH 04/16] algotihm Johnsona --- task_03/src/{algorithm_Jonsona.cpp => algorithm_Johnsona.cpp} | 0 task_03/src/{algorithm_Jonsona.hpp => algorithm_Johnsona.hpp} | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename task_03/src/{algorithm_Jonsona.cpp => algorithm_Johnsona.cpp} (100%) rename task_03/src/{algorithm_Jonsona.hpp => algorithm_Johnsona.hpp} (100%) diff --git a/task_03/src/algorithm_Jonsona.cpp b/task_03/src/algorithm_Johnsona.cpp similarity index 100% rename from task_03/src/algorithm_Jonsona.cpp rename to task_03/src/algorithm_Johnsona.cpp diff --git a/task_03/src/algorithm_Jonsona.hpp b/task_03/src/algorithm_Johnsona.hpp similarity index 100% rename from task_03/src/algorithm_Jonsona.hpp rename to task_03/src/algorithm_Johnsona.hpp From d216b95b6c377463bac29e21bc8e1046111ee737 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Mon, 11 Nov 2024 16:01:40 +0000 Subject: [PATCH 05/16] change --- lib/src/Graph.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/src/Graph.hpp b/lib/src/Graph.hpp index 729aee1..5f55a38 100644 --- a/lib/src/Graph.hpp +++ b/lib/src/Graph.hpp @@ -242,7 +242,7 @@ struct Graph { // Заполнение списка рёбер for (int i = 1; i <= n; i++) { for (const auto& neighbor : directed_graph[i]) { - edges[k].from = i; // Устанавливаем начальную вершину + edges[k].from = i; // Устанавливаем начальную вершинуу edges[k].to = neighbor.first; // Устанавливаем конечную вершину edges[k].weight = neighbor.second; // Устанавливаем вес ребра k++; // Переходим к следующему ребру From 5edfd2127a8425c95286b418077c5656d122c9ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Mon, 11 Nov 2024 17:47:19 +0000 Subject: [PATCH 06/16] return primary files --- additional_tasks/template_task/src/utils.cpp | 1 + additional_tasks/template_task/src/utils.hpp | 1 + task_03/src/test.cpp | 2 -- 3 files changed, 2 insertions(+), 2 deletions(-) create mode 100644 additional_tasks/template_task/src/utils.cpp create mode 100644 additional_tasks/template_task/src/utils.hpp diff --git a/additional_tasks/template_task/src/utils.cpp b/additional_tasks/template_task/src/utils.cpp new file mode 100644 index 0000000..0c58fd6 --- /dev/null +++ b/additional_tasks/template_task/src/utils.cpp @@ -0,0 +1 @@ +#include "utils.hpp" \ No newline at end of file diff --git a/additional_tasks/template_task/src/utils.hpp b/additional_tasks/template_task/src/utils.hpp new file mode 100644 index 0000000..7b9637e --- /dev/null +++ b/additional_tasks/template_task/src/utils.hpp @@ -0,0 +1 @@ +#pragma once \ No newline at end of file diff --git a/task_03/src/test.cpp b/task_03/src/test.cpp index ef5a86a..5e11617 100644 --- a/task_03/src/test.cpp +++ b/task_03/src/test.cpp @@ -1,8 +1,6 @@ #include -#include "topology_sort.hpp" - TEST(TopologySort, Simple) { ASSERT_EQ(1, 1); // Stack [] } From 5a9472c12bb3371d23240a8fe63b184c46c635c2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Mon, 11 Nov 2024 17:50:38 +0000 Subject: [PATCH 07/16] clang format --- task_01/src/test.cpp | 88 ++++++++++++++++++++-------------------- task_01/src/top_sort.hpp | 5 ++- 2 files changed, 48 insertions(+), 45 deletions(-) diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index b961aa5..8d8c398 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -8,8 +8,7 @@ TEST(SimpleGraph, Simple) { std::vector> edge = {{1, 2}, {2, 3}}; std::vector result = TopSort(vertices, edges, edge); - std::vector expected = { - 1, 2, 3}; + std::vector expected = {1, 2, 3}; ASSERT_EQ(result, expected); } @@ -18,7 +17,7 @@ TEST(GraphWithCycle, Simple) { int vertices = 3; int edges = 3; std::vector> edge = {{1, 2}, {2, 3}, {3, 1}}; - + EXPECT_THROW(TopSort(vertices, edges, edge);, CycleGraph); } @@ -28,7 +27,7 @@ TEST(DisconnectedGraph, Simple) { std::vector> edge = {{1, 2}, {3, 4}}; std::vector result = TopSort(vertices, edges, edge); - std::vector expected ={3, 4, 1, 2}; + std::vector expected = {3, 4, 1, 2}; ASSERT_EQ(result, expected); } @@ -45,61 +44,64 @@ TEST(SingleVertex, Simple) { } TEST(MultipleValidOrders, Simple) { - int vertices = 4; - int edges = 3; - std::vector> edge = {{1, 2}, {1, 3}, {3, 4}}; - - std::vector result = TopSort(vertices, edges, edge); - std::vector expected1 = {1, 3, 4, 2}; - - ASSERT_EQ(result, expected1); + int vertices = 4; + int edges = 3; + std::vector> edge = {{1, 2}, {1, 3}, {3, 4}}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected1 = {1, 3, 4, 2}; + + ASSERT_EQ(result, expected1); } TEST(AllVerticesConnected, Simple) { - int vertices = 5; - int edges = 4; - std::vector> edge = {{1, 2}, {2, 3}, {3, 4}, {4, 5}}; - - std::vector result = TopSort(vertices, edges, edge); - std::vector expected = {1, 2, 3, 4, 5}; - - ASSERT_EQ(result, expected); + int vertices = 5; + int edges = 4; + std::vector> edge = {{1, 2}, {2, 3}, {3, 4}, {4, 5}}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected = {1, 2, 3, 4, 5}; + + ASSERT_EQ(result, expected); } TEST(ReverseOrder, Simple) { - int vertices = 3; - int edges = 2; - std::vector> edge = {{3, 2}, {2, 1}}; - - std::vector result = TopSort(vertices, edges, edge); - std::vector expected = {3, 2, 1}; - - ASSERT_EQ(result, expected); + int vertices = 3; + int edges = 2; + std::vector> edge = {{3, 2}, {2, 1}}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected = {3, 2, 1}; + + ASSERT_EQ(result, expected); } TEST(ComplexGraph, Simple) { - int vertices = 6; - int edges = 6; - std::vector> edge = {{5, 2}, {5, 0}, {4, 0}, {4, 1}, {2, 3}, {3, 1}}; - - std::vector result = TopSort(vertices, edges, edge); - std::vector expected = {6, 5, 4, 0, 2, 3, 1}; - - ASSERT_EQ(result, expected); + int vertices = 6; + int edges = 6; + std::vector> edge = {{5, 2}, {5, 0}, {4, 0}, + {4, 1}, {2, 3}, {3, 1}}; + + std::vector result = TopSort(vertices, edges, edge); + std::vector expected = {6, 5, 4, 0, 2, 3, 1}; + + ASSERT_EQ(result, expected); } TEST(GraphWithMultipleCyclesm, Simple) { - int vertices = 4; - int edges = 5; - std::vector> edge = {{1, 2}, {2, 3}, {3, 1}, {2, 4}, {4, 2}}; - - EXPECT_THROW(TopSort(vertices, edges, edge), CycleGraph); + int vertices = 4; + int edges = 5; + std::vector> edge = { + {1, 2}, {2, 3}, {3, 1}, {2, 4}, {4, 2}}; + + EXPECT_THROW(TopSort(vertices, edges, edge), CycleGraph); } -TEST(MediumGraph, Simple){ +TEST(MediumGraph, Simple) { int vertices = 6; int edges = 6; - std::vector> edge = {{5, 2}, {4, 2}, {3, 4}, {6, 3}, {6, 1}, {5, 1}}; + std::vector> edge = {{5, 2}, {4, 2}, {3, 4}, + {6, 3}, {6, 1}, {5, 1}}; std::vector result = TopSort(vertices, edges, edge); std::vector expected = {6, 5, 3, 4, 2, 1}; diff --git a/task_01/src/top_sort.hpp b/task_01/src/top_sort.hpp index 2a3e061..6976b4b 100644 --- a/task_01/src/top_sort.hpp +++ b/task_01/src/top_sort.hpp @@ -3,7 +3,8 @@ #define int long class CycleGraph : public std::logic_error { - using std::logic_error::logic_error; + using std::logic_error::logic_error; }; -std::vector TopSort(int vertices, int edges, std::vector>& edge); \ No newline at end of file +std::vector TopSort(int vertices, int edges, + std::vector>& edge); \ No newline at end of file From b90cb571738e69377780d26ee1c8975fed775145 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Mon, 11 Nov 2024 17:55:10 +0000 Subject: [PATCH 08/16] test change --- task_04/src/test.cpp | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 5d62ea7..2f876d2 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -122,21 +122,4 @@ TEST(DijkstraTest, ComplexGraph) { std::pair, std::vector> result = Dijkstra(n, m, s, t, vec); ASSERT_EQ(result, expected); -} - -TEST(DijkstraTest, DenseGraph) { - int n = 7; - int m = 21; - int s = 1; - int t = 7; - std::vector> vec = { - {1, 2, 1}, {1, 3, 2}, {1, 4, 3}, {1, 5, 4}, {1, 6, 5}, - {2, 3, 1}, {2, 4, 2}, {2, 5, 3}, {2, 6, 4}, {2, 7, 5}, - {3, 4, 1}, {3, 5, 2}, {3, 6, 3}, {3, 7, 4}, {4, 5, 1}, - {4, 6, 2}, {4, 7, 3}, {5, 6, 1}, {5, 7, 2}, {6, 7, 1}}; - std::pair, std::vector> expected = {{5, 5}, - {1, 2, 4, 7}}; - std::pair, std::vector> result = - Dijkstra(n, m, s, t, vec); - ASSERT_EQ(result, expected); } \ No newline at end of file From f350ca628dbab90654f564d864374ca939890744 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Wed, 27 Nov 2024 14:59:07 +0000 Subject: [PATCH 09/16] Add "const" --- lib/src/Graph.hpp | 6 ++-- task_01/src/test.cpp | 68 ++++++++++++++++++++++---------------------- 2 files changed, 37 insertions(+), 37 deletions(-) diff --git a/lib/src/Graph.hpp b/lib/src/Graph.hpp index 5f55a38..0b4d9f5 100644 --- a/lib/src/Graph.hpp +++ b/lib/src/Graph.hpp @@ -174,12 +174,12 @@ struct Graph { } // Используется для нахождения Top_Sort и проверке на циклы - bool DfsCycleDirectedU(int v) { + bool DfsCycleDirectedU(const int v) { // Выполняет DFS для топологической сортировки и проверки наличия циклов. used[v] = 1; // Помечаем вершину как посещенную. color[v] = 1; // Устанавливаем цвет в процессе. for (auto& edge : gr[v]) { - int to = edge; // Получаем соседнюю вершину. + int const to = edge; // Получаем соседнюю вершину. if (!used[to]) { if (DfsCycleDirectedU(to)) { return true; // Если цикл найден, возвращаем true. @@ -235,7 +235,7 @@ struct Graph { // Ниже реализован алгоритм Белмана Форда, который ищет кратчайшее расстояние // между вершиной s и всеми остальными vector AlgorithmBellmanaF(int n, int m, int s) { - edges.resize( + edges.resize( m); // Изменяем размер вектора рёбер на количество рёбер в графе int k = 0; // Индекс для добавления рёбер diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 8d8c398..40472cc 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -3,38 +3,38 @@ #include "top_sort.hpp" TEST(SimpleGraph, Simple) { - int vertices = 3; - int edges = 2; + int const vertices = 3; + int const edges = 2; std::vector> edge = {{1, 2}, {2, 3}}; - std::vector result = TopSort(vertices, edges, edge); - std::vector expected = {1, 2, 3}; + std::vector const result = TopSort(vertices, edges, edge); + std::vector const expected = {1, 2, 3}; ASSERT_EQ(result, expected); } TEST(GraphWithCycle, Simple) { - int vertices = 3; - int edges = 3; + int const vertices = 3; + int const edges = 3; std::vector> edge = {{1, 2}, {2, 3}, {3, 1}}; EXPECT_THROW(TopSort(vertices, edges, edge);, CycleGraph); } TEST(DisconnectedGraph, Simple) { - int vertices = 4; - int edges = 2; + int const vertices = 4; + int const edges = 2; std::vector> edge = {{1, 2}, {3, 4}}; - std::vector result = TopSort(vertices, edges, edge); - std::vector expected = {3, 4, 1, 2}; + std::vector const result = TopSort(vertices, edges, edge); + std::vector const expected = {3, 4, 1, 2}; ASSERT_EQ(result, expected); } TEST(SingleVertex, Simple) { - int vertices = 1; - int edges = 0; + int const vertices = 1; + int const edges = 0; std::vector> edge = {}; std::vector result = TopSort(vertices, edges, edge); @@ -44,53 +44,53 @@ TEST(SingleVertex, Simple) { } TEST(MultipleValidOrders, Simple) { - int vertices = 4; - int edges = 3; + int const vertices = 4; + int const edges = 3; std::vector> edge = {{1, 2}, {1, 3}, {3, 4}}; - std::vector result = TopSort(vertices, edges, edge); - std::vector expected1 = {1, 3, 4, 2}; + std::vector const result = TopSort(vertices, edges, edge); + std::vector const expected1 = {1, 3, 4, 2}; ASSERT_EQ(result, expected1); } TEST(AllVerticesConnected, Simple) { - int vertices = 5; - int edges = 4; + int const vertices = 5; + int const edges = 4; std::vector> edge = {{1, 2}, {2, 3}, {3, 4}, {4, 5}}; - std::vector result = TopSort(vertices, edges, edge); - std::vector expected = {1, 2, 3, 4, 5}; + std::vector const result = TopSort(vertices, edges, edge); + std::vector const expected = {1, 2, 3, 4, 5}; ASSERT_EQ(result, expected); } TEST(ReverseOrder, Simple) { - int vertices = 3; - int edges = 2; + int const vertices = 3; + int const edges = 2; std::vector> edge = {{3, 2}, {2, 1}}; - std::vector result = TopSort(vertices, edges, edge); - std::vector expected = {3, 2, 1}; + std::vector const result = TopSort(vertices, edges, edge); + std::vector const expected = {3, 2, 1}; ASSERT_EQ(result, expected); } TEST(ComplexGraph, Simple) { - int vertices = 6; - int edges = 6; + int const vertices = 6; + int const edges = 6; std::vector> edge = {{5, 2}, {5, 0}, {4, 0}, {4, 1}, {2, 3}, {3, 1}}; - std::vector result = TopSort(vertices, edges, edge); - std::vector expected = {6, 5, 4, 0, 2, 3, 1}; + std::vector const result = TopSort(vertices, edges, edge); + std::vector const expected = {6, 5, 4, 0, 2, 3, 1}; ASSERT_EQ(result, expected); } TEST(GraphWithMultipleCyclesm, Simple) { - int vertices = 4; - int edges = 5; + int const vertices = 4; + int const edges = 5; std::vector> edge = { {1, 2}, {2, 3}, {3, 1}, {2, 4}, {4, 2}}; @@ -98,12 +98,12 @@ TEST(GraphWithMultipleCyclesm, Simple) { } TEST(MediumGraph, Simple) { - int vertices = 6; - int edges = 6; + int const vertices = 6; + int const edges = 6; std::vector> edge = {{5, 2}, {4, 2}, {3, 4}, {6, 3}, {6, 1}, {5, 1}}; - std::vector result = TopSort(vertices, edges, edge); - std::vector expected = {6, 5, 3, 4, 2, 1}; + std::vector const result = TopSort(vertices, edges, edge); + std::vector const expected = {6, 5, 3, 4, 2, 1}; ASSERT_EQ(result, expected); } From df07a214d0fa0cff9e1eb29e89cb4707a13ad1b7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Wed, 27 Nov 2024 15:05:13 +0000 Subject: [PATCH 10/16] format --- lib/src/Graph.hpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/lib/src/Graph.hpp b/lib/src/Graph.hpp index 0b4d9f5..c98f7d2 100644 --- a/lib/src/Graph.hpp +++ b/lib/src/Graph.hpp @@ -160,7 +160,7 @@ struct Graph { used[v] = 1; // Помечаем вершину как посещенную. color[v] = 1; // Устанавливаем цвет в процессе. for (auto& edge : directed_graph[v]) { - int to = edge.first; // Получаем соседнюю вершину. + int const to = edge.first; // Получаем соседнюю вершину. if (!used[to]) { if (DfsCycleDirectedW(to)) { return true; // Если цикл найден, возвращаем true. @@ -235,8 +235,7 @@ struct Graph { // Ниже реализован алгоритм Белмана Форда, который ищет кратчайшее расстояние // между вершиной s и всеми остальными vector AlgorithmBellmanaF(int n, int m, int s) { - edges.resize( - m); // Изменяем размер вектора рёбер на количество рёбер в графе + edges.resize(m); // Изменяем размер вектора рёбер на количество рёбер в графе int k = 0; // Индекс для добавления рёбер // Заполнение списка рёбер From cda618b374db3827ef7d3f98122b0d168aa34a16 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Wed, 27 Nov 2024 15:43:24 +0000 Subject: [PATCH 11/16] clang format --- lib/src/Graph.hpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/src/Graph.hpp b/lib/src/Graph.hpp index c98f7d2..05b5f4f 100644 --- a/lib/src/Graph.hpp +++ b/lib/src/Graph.hpp @@ -235,7 +235,8 @@ struct Graph { // Ниже реализован алгоритм Белмана Форда, который ищет кратчайшее расстояние // между вершиной s и всеми остальными vector AlgorithmBellmanaF(int n, int m, int s) { - edges.resize(m); // Изменяем размер вектора рёбер на количество рёбер в графе + edges.resize( + m); // Изменяем размер вектора рёбер на количество рёбер в графе int k = 0; // Индекс для добавления рёбер // Заполнение списка рёбер From cf48ddcea8de2fee5a65fe1f4aaa67f327b93c8d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Wed, 27 Nov 2024 16:13:38 +0000 Subject: [PATCH 12/16] delete bits/stdc++.h --- lib/src/Graph.hpp | 5 +- task_01/src/test.cpp | 6 +- task_01/src/top_sort.cpp | 2 +- task_01/src/top_sort.hpp | 6 +- task_02/src/bridges_and_point.cpp | 10 +-- task_02/src/bridges_and_point.hpp | 5 +- task_02/src/test.cpp | 120 +++++++++++++++-------------- task_03/src/algorithm_Johnsona.cpp | 2 - task_04/src/algorithm_Dijkstra.cpp | 2 - task_04/src/algorithm_Dijkstra.hpp | 6 +- 10 files changed, 87 insertions(+), 77 deletions(-) diff --git a/lib/src/Graph.hpp b/lib/src/Graph.hpp index 05b5f4f..c2c4833 100644 --- a/lib/src/Graph.hpp +++ b/lib/src/Graph.hpp @@ -1,4 +1,5 @@ -#include +#include +#include using namespace std; @@ -130,7 +131,7 @@ struct Graph { bool DfsCycleUndirected(int v, int p) { // Выполняет DFS для проверки наличия циклов в невзвешенном графе. used[v] = 1; // Помечаем вершину как посещенную. - for (int to : gr[v]) { + for (const int to : gr[v]) { if (!used[to]) { if (DfsCycleUndirected(to, v)) { return true; // Если цикл найден, возвращаем true. diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index 40472cc..d0adc88 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,4 +1,4 @@ -#include +#include "gtest/gtest.h" #include "top_sort.hpp" @@ -37,8 +37,8 @@ TEST(SingleVertex, Simple) { int const edges = 0; std::vector> edge = {}; - std::vector result = TopSort(vertices, edges, edge); - std::vector expected = {1}; + std::vector const result = TopSort(vertices, edges, edge); + std::vector const expected = {1}; ASSERT_EQ(result, expected); } diff --git a/task_01/src/top_sort.cpp b/task_01/src/top_sort.cpp index bdc0a2c..63b35f8 100644 --- a/task_01/src/top_sort.cpp +++ b/task_01/src/top_sort.cpp @@ -1,6 +1,6 @@ #include "top_sort.hpp" -#include +#include "Graph.hpp" std::vector TopSort(int vertices, int edges, std::vector>& edge) { diff --git a/task_01/src/top_sort.hpp b/task_01/src/top_sort.hpp index 6976b4b..54bb799 100644 --- a/task_01/src/top_sort.hpp +++ b/task_01/src/top_sort.hpp @@ -1,7 +1,7 @@ #pragma once -#include -#define int long - +#include +#include +#include class CycleGraph : public std::logic_error { using std::logic_error::logic_error; }; diff --git a/task_02/src/bridges_and_point.cpp b/task_02/src/bridges_and_point.cpp index ffe4ac8..6f0f33a 100644 --- a/task_02/src/bridges_and_point.cpp +++ b/task_02/src/bridges_and_point.cpp @@ -1,4 +1,4 @@ -#include +#include "bridges_and_point.hpp" #include "Graph.hpp" @@ -34,7 +34,7 @@ void DfsCutPoint(int v, int p) { } } -set CutPoint(int n, int m, Graph graph) { +set CutPoint(int n, Graph graph) { u.resize(n + 1, 0); ret.resize(n + 1, 1e9); h.resize(n + 1, 1e9); @@ -71,7 +71,7 @@ void DfsCutBridges(int u, int p = -1) { } } -vector> CutBridges(int n, int m, Graph graph) { +vector> CutBridges(int n, Graph graph) { tin.resize(n + 1, 0); fup.resize(n + 1, 1e9); used_br.resize(n + 1, 0); @@ -94,8 +94,8 @@ pair, vector>> Answer(int n, int m, vector> vec) { Graph graph; graph.ReadUUG(n, m, vec); - vector> answer_bridges = CutBridges(n, m, graph); - set answer_point = CutPoint(n, m, graph); + vector> answer_bridges = CutBridges(n, graph); + set answer_point = CutPoint(n, graph); u.clear(); ret.clear(); h.clear(); diff --git a/task_02/src/bridges_and_point.hpp b/task_02/src/bridges_and_point.hpp index 975d6dc..28d535f 100644 --- a/task_02/src/bridges_and_point.hpp +++ b/task_02/src/bridges_and_point.hpp @@ -1,5 +1,8 @@ #pragma once -#include +#include +#include +#include + using namespace std; void DfsCutPoint(int v, int p); diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index f94e386..06c378a 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -1,131 +1,139 @@ -#include +#include "gtest/gtest.h" #include "bridges_and_point.hpp" TEST(SimpleTest, Simple) { - int vertices = 6; - int edge = 6; - std::vector> edges = {{1, 3}, {2, 3}, {3, 4}, - {3, 5}, {4, 5}, {4, 6}}; - - pair, vector>> result = Answer(vertices, edge, edges); - pair, vector>> expected = {{3, 4}, - {{1, 3}, {3, 2}, {4, 6}}}; + int const vertices = 6; + int const edge = 6; + std::vector> const edges = {{1, 3}, {2, 3}, {3, 4}, + {3, 5}, {4, 5}, {4, 6}}; + + pair, vector>> const result = + Answer(vertices, edge, edges); + pair, vector>> const expected = { + {3, 4}, {{1, 3}, {3, 2}, {4, 6}}}; ASSERT_EQ(result, expected); } TEST(CutPointsAndBridgesTest, BasicFunctionality) { - int vertices = 5; - int edges = 5; - std::vector> edgeList = { + int const vertices = 5; + int const edges = 5; + std::vector> const edgeList = { {1, 2}, {2, 3}, {3, 4}, {4, 5}, {2, 5}}; - pair, vector>> result = + pair, vector>> const result = Answer(vertices, edges, edgeList); set expectedCutPoints = {2}; - vector> expectedBridges = {{1, 2}}; + vector> const expectedBridges = {{1, 2}}; ASSERT_EQ(result.first, expectedCutPoints); ASSERT_EQ(result.second, expectedBridges); } TEST(CutPointsAndBridgesTest, NoCutPoints) { - int vertices = 4; - int edges = 4; - std::vector> edgeList = {{1, 2}, {2, 3}, {3, 4}, {4, 1}}; + int const vertices = 4; + int const edges = 4; + std::vector> const edgeList = { + {1, 2}, {2, 3}, {3, 4}, {4, 1}}; - pair, vector>> result = + pair, vector>> const result = Answer(vertices, edges, edgeList); set expectedCutPoints = {}; - vector> expectedBridges = {}; + vector> const expectedBridges = {}; ASSERT_EQ(result.first, expectedCutPoints); ASSERT_EQ(result.second, expectedBridges); } TEST(CutPointsAndBridgesTest, ComplexGraph) { - int vertices = 7; - int edges = 7; - std::vector> edgeList = {{1, 2}, {1, 3}, {2, 3}, {3, 4}, - {4, 5}, {5, 6}, {6, 7}}; + int const vertices = 7; + int const edges = 7; + std::vector> const edgeList = { + {1, 2}, {1, 3}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}}; - pair, vector>> result = + pair, vector>> const result = Answer(vertices, edges, edgeList); set expectedCutPoints = {3, 4, 5, 6}; - vector> expectedBridges = {{3, 4}, {4, 5}, {5, 6}, {6, 7}}; + vector> const expectedBridges = { + {3, 4}, {4, 5}, {5, 6}, {6, 7}}; ASSERT_EQ(result.first, expectedCutPoints); ASSERT_EQ(result.second, expectedBridges); } TEST(CutPointsAndBridgesTest, TwoDisconnectedComponents) { - int vertices = 6; - int edges = 4; - std::vector> edgeList = {{1, 2}, {2, 3}, {4, 5}, {5, 6}}; + int const vertices = 6; + int const edges = 4; + std::vector> const edgeList = { + {1, 2}, {2, 3}, {4, 5}, {5, 6}}; - pair, vector>> result = + pair, vector>> const result = Answer(vertices, edges, edgeList); - set expectedCutPoints = {2, 5}; - vector> expectedBridges = {{1, 2}, {2, 3}, {4, 5}, {5, 6}}; + set const expectedCutPoints = {2, 5}; + vector> const expectedBridges = { + {1, 2}, {2, 3}, {4, 5}, {5, 6}}; ASSERT_EQ(result.first, expectedCutPoints); ASSERT_EQ(result.second, expectedBridges); } TEST(CutPointsAndBridgesTest, StarTopology) { - int vertices = 5; - int edges = 4; - std::vector> edgeList = {{1, 2}, {1, 3}, {1, 4}, {1, 5}}; + int const vertices = 5; + int const edges = 4; + std::vector> const edgeList = { + {1, 2}, {1, 3}, {1, 4}, {1, 5}}; - pair, vector>> result = + pair, vector>> const result = Answer(vertices, edges, edgeList); - set expectedCutPoints = {1}; - vector> expectedBridges = {{1, 2}, {1, 3}, {1, 4}, {1, 5}}; + set const expectedCutPoints = {1}; + vector> const expectedBridges = { + {1, 2}, {1, 3}, {1, 4}, {1, 5}}; ASSERT_EQ(result.first, expectedCutPoints); ASSERT_EQ(result.second, expectedBridges); } TEST(CutPointsAndBridgesTest, CycleGraph) { - int vertices = 5; - int edges = 5; - std::vector> edgeList = { + int const vertices = 5; + int const edges = 5; + std::vector> const edgeList = { {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 1}}; - pair, vector>> result = + pair, vector>> const result = Answer(vertices, edges, edgeList); - set expectedCutPoints = {}; - vector> expectedBridges = {}; + set const expectedCutPoints = {}; + vector> const expectedBridges = {}; ASSERT_EQ(result.first, expectedCutPoints); ASSERT_EQ(result.second, expectedBridges); } TEST(CutPointsAndBridgesTest, SingleBridgeInComplexGraph) { - int vertices = 8; - int edges = 8; - std::vector> edgeList = {{1, 2}, {2, 3}, {3, 4}, {4, 5}, - {5, 6}, {6, 7}, {7, 8}, {5, 8}}; + int const vertices = 8; + int const edges = 8; + std::vector> const edgeList = { + {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8}, {5, 8}}; - pair, vector>> result = + pair, vector>> const result = Answer(vertices, edges, edgeList); - set expectedCutPoints = {2, 3, 4, 5}; - vector> expectedBridges = {{1, 2}, {2, 3}, {3, 4}, {4, 5}}; + set const expectedCutPoints = {2, 3, 4, 5}; + vector> const expectedBridges = { + {1, 2}, {2, 3}, {3, 4}, {4, 5}}; ASSERT_EQ(result.first, expectedCutPoints); ASSERT_EQ(result.second, expectedBridges); } TEST(CutPointsAndBridgesTest, LargeGraph) { - int vertices = 10; - int edges = 9; - std::vector> edgeList = { + int const vertices = 10; + int const edges = 9; + std::vector> const edgeList = { {1, 2}, {1, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8}, {8, 9}, {9, 10}}; - pair, vector>> result = + pair, vector>> const result = Answer(vertices, edges, edgeList); - set expectedCutPoints = {1, 3, 4, 5, 6, 7, 8, 9}; - vector> expectedBridges = { + set const expectedCutPoints = {1, 3, 4, 5, 6, 7, 8, 9}; + vector> const expectedBridges = { {1, 2}, {1, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8}, {8, 9}, {9, 10}}; ASSERT_EQ(result.first, expectedCutPoints); diff --git a/task_03/src/algorithm_Johnsona.cpp b/task_03/src/algorithm_Johnsona.cpp index de203ac..2275644 100644 --- a/task_03/src/algorithm_Johnsona.cpp +++ b/task_03/src/algorithm_Johnsona.cpp @@ -1,5 +1,3 @@ -#include - #include using namespace std; diff --git a/task_04/src/algorithm_Dijkstra.cpp b/task_04/src/algorithm_Dijkstra.cpp index 032c7dc..78aba66 100644 --- a/task_04/src/algorithm_Dijkstra.cpp +++ b/task_04/src/algorithm_Dijkstra.cpp @@ -1,5 +1,3 @@ -#include - #include #include diff --git a/task_04/src/algorithm_Dijkstra.hpp b/task_04/src/algorithm_Dijkstra.hpp index 7719a75..aa1b7a0 100644 --- a/task_04/src/algorithm_Dijkstra.hpp +++ b/task_04/src/algorithm_Dijkstra.hpp @@ -1,6 +1,8 @@ #pragma once -#include - +#include +#include +#include +#include using namespace std; class Nonexistent_way : public std::logic_error { From 6487163492ce4acad8975d76579f64ff9f683e97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Wed, 27 Nov 2024 16:16:55 +0000 Subject: [PATCH 13/16] format --- task_01/src/test.cpp | 1 - task_02/src/test.cpp | 3 +-- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/task_01/src/test.cpp b/task_01/src/test.cpp index d0adc88..c1536a5 100644 --- a/task_01/src/test.cpp +++ b/task_01/src/test.cpp @@ -1,5 +1,4 @@ #include "gtest/gtest.h" - #include "top_sort.hpp" TEST(SimpleGraph, Simple) { diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 06c378a..88a359c 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -1,6 +1,5 @@ -#include "gtest/gtest.h" - #include "bridges_and_point.hpp" +#include "gtest/gtest.h" TEST(SimpleTest, Simple) { int const vertices = 6; From 4edc2fcc19f61ac84fa342b7e7a7c50477a7fc22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Wed, 27 Nov 2024 16:24:44 +0000 Subject: [PATCH 14/16] clang format --- task_02/src/test.cpp | 6 +++--- task_04/src/test.cpp | 46 +++++++++++++++++++++++--------------------- 2 files changed, 27 insertions(+), 25 deletions(-) diff --git a/task_02/src/test.cpp b/task_02/src/test.cpp index 88a359c..5a59e95 100644 --- a/task_02/src/test.cpp +++ b/task_02/src/test.cpp @@ -22,7 +22,7 @@ TEST(CutPointsAndBridgesTest, BasicFunctionality) { pair, vector>> const result = Answer(vertices, edges, edgeList); - set expectedCutPoints = {2}; + set const expectedCutPoints = {2}; vector> const expectedBridges = {{1, 2}}; ASSERT_EQ(result.first, expectedCutPoints); @@ -37,7 +37,7 @@ TEST(CutPointsAndBridgesTest, NoCutPoints) { pair, vector>> const result = Answer(vertices, edges, edgeList); - set expectedCutPoints = {}; + set const expectedCutPoints = {}; vector> const expectedBridges = {}; ASSERT_EQ(result.first, expectedCutPoints); @@ -52,7 +52,7 @@ TEST(CutPointsAndBridgesTest, ComplexGraph) { pair, vector>> const result = Answer(vertices, edges, edgeList); - set expectedCutPoints = {3, 4, 5, 6}; + set const expectedCutPoints = {3, 4, 5, 6}; vector> const expectedBridges = { {3, 4}, {4, 5}, {5, 6}, {6, 7}}; diff --git a/task_04/src/test.cpp b/task_04/src/test.cpp index 2f876d2..b2a990b 100644 --- a/task_04/src/test.cpp +++ b/task_04/src/test.cpp @@ -9,9 +9,9 @@ TEST(TopologySort, Simple) { int t = 5; std::vector> vec = {{1, 2, 1}, {1, 3, 4}, {1, 5, 5}, {2, 3, 1}, {3, 4, 2}, {3, 5, 3}, {4, 5, 7}}; - std::pair, std::vector> expected = {{4, 3}, - {2, 3, 5}}; - std::pair, std::vector> result = + std::pair, std::vector> const expected = {{4, 3}, + {2, 3, 5}}; + std::pair, std::vector> const result = Dijkstra(n, m, s, t, vec); ASSERT_EQ(result, expected); } @@ -23,9 +23,9 @@ TEST(DijkstraTest, BasicPath) { int t = 4; std::vector> vec = { {1, 2, 1}, {1, 3, 4}, {2, 3, 2}, {2, 4, 5}, {3, 4, 1}}; - std::pair, std::vector> expected = {{4, 4}, - {1, 2, 3, 4}}; - std::pair, std::vector> result = + std::pair, std::vector> const expected = { + {4, 4}, {1, 2, 3, 4}}; + std::pair, std::vector> const result = Dijkstra(n, m, s, t, vec); ASSERT_EQ(result, expected); } @@ -47,9 +47,9 @@ TEST(DijkstraTest, MultiplePaths) { std::vector> vec = {{1, 2, 1}, {1, 3, 2}, {2, 4, 3}, {3, 4, 1}, {4, 5, 1}, {2, 5, 5}, {3, 5, 3}, {1, 6, 10}}; - std::pair, std::vector> expected = {{4, 4}, - {1, 3, 4, 5}}; - std::pair, std::vector> result = + std::pair, std::vector> const expected = { + {4, 4}, {1, 3, 4, 5}}; + std::pair, std::vector> const result = Dijkstra(n, m, s, t, vec); ASSERT_EQ(result, expected); } @@ -60,8 +60,9 @@ TEST(DijkstraTest, SingleNode) { int s = 1; int t = 1; std::vector> vec = {}; - std::pair, std::vector> expected = {{0, 1}, {1}}; - std::pair, std::vector> result = + std::pair, std::vector> const expected = {{0, 1}, + {1}}; + std::pair, std::vector> const result = Dijkstra(n, m, s, t, vec); ASSERT_EQ(result, expected); } @@ -73,8 +74,9 @@ TEST(DijkstraTest, CyclePath) { int t = 3; std::vector> vec = { {1, 2, 1}, {2, 3, 2}, {3, 1, 2}, {2, 4, 1}, {4, 3, 1}}; - std::pair, std::vector> expected = {{2, 2}, {1, 3}}; - std::pair, std::vector> result = + std::pair, std::vector> const expected = {{2, 2}, + {1, 3}}; + std::pair, std::vector> const result = Dijkstra(n, m, s, t, vec); ASSERT_EQ(result, expected); } @@ -86,9 +88,9 @@ TEST(DijkstraTest, LargeWeights) { int t = 3; std::vector> vec = { {1, 2, 1000}, {2, 3, 2000}, {1, 3, 5000}}; - std::pair, std::vector> expected = {{3000, 3}, - {1, 2, 3}}; - std::pair, std::vector> result = + std::pair, std::vector> const expected = {{3000, 3}, + {1, 2, 3}}; + std::pair, std::vector> const result = Dijkstra(n, m, s, t, vec); ASSERT_EQ(result, expected); } @@ -101,9 +103,9 @@ TEST(DijkstraTest, ManyEdges) { std::vector> vec = { {1, 2, 1}, {1, 3, 2}, {1, 4, 5}, {2, 3, 1}, {2, 4, 2}, {2, 5, 4}, {3, 4, 1}, {3, 5, 3}, {4, 5, 1}, {1, 5, 10}}; - std::pair, std::vector> expected = {{4, 4}, - {1, 2, 4, 5}}; - std::pair, std::vector> result = + std::pair, std::vector> const expected = { + {4, 4}, {1, 2, 4, 5}}; + std::pair, std::vector> const result = Dijkstra(n, m, s, t, vec); ASSERT_EQ(result, expected); } @@ -117,9 +119,9 @@ TEST(DijkstraTest, ComplexGraph) { {1, 2, 1}, {1, 3, 4}, {1, 4, 2}, {2, 3, 1}, {2, 4, 5}, {3, 5, 2}, {4, 5, 3}, {4, 6, 1}, {5, 6, 1}, {2, 6, 10}, {3, 4, 2}, {1, 5, 7}, {2, 5, 3}, {4, 3, 1}, {5, 1, 8}}; - std::pair, std::vector> expected = {{3, 3}, - {1, 4, 6}}; - std::pair, std::vector> result = + std::pair, std::vector> const expected = {{3, 3}, + {1, 4, 6}}; + std::pair, std::vector> const result = Dijkstra(n, m, s, t, vec); ASSERT_EQ(result, expected); } \ No newline at end of file From 323070e23589bf24dcfa5962a337c0bf7f2d7ff1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Wed, 27 Nov 2024 16:30:03 +0000 Subject: [PATCH 15/16] last change from warning --- task_04/src/algorithm_Dijkstra.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/task_04/src/algorithm_Dijkstra.cpp b/task_04/src/algorithm_Dijkstra.cpp index 78aba66..9f229ec 100644 --- a/task_04/src/algorithm_Dijkstra.cpp +++ b/task_04/src/algorithm_Dijkstra.cpp @@ -1,4 +1,4 @@ -#include +#include "Graph.hpp" #include using namespace std; @@ -41,7 +41,7 @@ pair, vector> Dijkstra(int& n, int& m, int& s, int& t, throw Nonexistent_way("There is no path from point s to point t"); } vector way; - int tu = t; + int const tu = t; while (put[t] != -1) { way.push_back(t); t = put[t]; From 4131e39fb4c28a1bf5b822e47ebad4a221a38fc9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D0=BE=D0=BB=D1=8C=D1=88=D0=B0=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=9C=D0=B0=D1=82=D0=B2=D0=B5=D0=B9=20=D0=90=D0=BB=D0=B5=D0=BA?= =?UTF-8?q?=D1=81=D0=B0=D0=BD=D0=B4=D1=80=D0=BE=D0=B2=D0=B8=D1=87?= <143873323+Matvey-cmd@users.noreply.github.com> Date: Fri, 20 Dec 2024 17:19:48 +0000 Subject: [PATCH 16/16] some changes --- task_04/src/algorithm_Dijkstra.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/task_04/src/algorithm_Dijkstra.cpp b/task_04/src/algorithm_Dijkstra.cpp index 9f229ec..826f50d 100644 --- a/task_04/src/algorithm_Dijkstra.cpp +++ b/task_04/src/algorithm_Dijkstra.cpp @@ -1,4 +1,4 @@ -#include "Graph.hpp" +#include "lib\src\Graph.hpp" #include using namespace std;