Nasedkin Ivan's tasks

.gitignore

@@ -12,4 +12,8 @@ _deps
 
 .cache/*
 .vscode/*
-build/*
+build/*
+.vs
+WeightedGraph.i
+out
+CMakeSettings.json

lib/CMakeLists.txt

@@ -3,7 +3,10 @@ project(Utils)
 
 set(CMAKE_CXX_STANDARD 23)
 
-file(GLOB_RECURSE lib_source_list "src/*.cpp" "src/*.hpp")
+file(GLOB_RECURSE lib_source_list "src/*.cpp")
+
+SET(BASEPATH "${CMAKE_SOURCE_DIR}")
+INCLUDE_DIRECTORIES("${BASEPATH}")
 
 add_library(${PROJECT_NAME} ${lib_source_list})
 

lib/src/BellmanFordAlgorithm.cpp

@@ -0,0 +1,35 @@
+#include <cfloat>
+
+#include "BellmanForlAlgorithm.h"
+
+std::vector<double> BellmanFordAlgorithm(const WeightedGraph& graph,
+                                         int start_id) {
+  int n = graph.GetVerts();
+  std::vector<double> pathLength(n, DBL_MAX);
+  pathLength[start_id] = 0;
+  for (int i = 0; i < n; ++i)
+    for (int j = 0; j < n; ++j)
+      for (int k = 0; k < n; ++k)
+        if (graph[j][k] && pathLength[j] != DBL_MAX &&
+            pathLength[j] + graph[j][k] < pathLength[k]) {
+          if (i == n - 1) return std::vector<double>(0);
+          pathLength[k] = pathLength[j] + graph[j][k];
+        }
+  return pathLength;
+}
+
+std::vector<double> BellmanFordAlgorithm(
+    const OrientedWeightedGraphWithZeroWeight& graph, int start_id) {
+  int n = graph.GetVerts();
+  std::vector<double> pathLength(n, DBL_MAX);
+  pathLength[start_id] = 0;
+  for (int i = 0; i < n; ++i)
+    for (int j = 0; j < n; ++j)
+      for (int k = 0; k < n; ++k)
+        if (graph[j][k] && pathLength[j] != DBL_MAX &&
+            pathLength[j] + graph.GetWeight(j, k) < pathLength[k]) {
+          if (i == n - 1) return std::vector<double>(0);
+          pathLength[k] = pathLength[j] + graph.GetWeight(j, k);
+        }
+  return pathLength;
+}

lib/src/BellmanForlAlgorithm.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <includes.h>
+
+std::vector<double> BellmanFordAlgorithm(const WeightedGraph& graph,
+                                         int start_id);
+std::vector<double> BellmanFordAlgorithm(
+    const OrientedWeightedGraphWithZeroWeight& graph, int start_id);

lib/src/DeikstraAlgorithm.cpp

@@ -0,0 +1,131 @@
+#include "DeikstraAlgorithm.h"
+
+#include <cfloat>
+
+double DeikstraAlgorithm(const WeightedGraph& graph, int start_id, int end_id) {
+  int n = graph.GetVerts();
+  std::vector<bool> ended(n);
+  std::vector<double> pathLength(n, DBL_MAX);
+  pathLength[start_id] = 0;
+  int this_id = start_id;
+  int counter = 0;
+  for (; true;) {
+    if (counter >= n) break;
+    for (int i = 0; i < n; ++i) {
+      if (graph[this_id][i])
+        pathLength[i] =
+            std::min(pathLength[i], pathLength[this_id] + graph[this_id][i]);
+    }
+    ended[this_id] = true;
+    double min = DBL_MAX;
+    for (int j = 0; j < n; ++j) {
+      if (!ended[j])
+        if (min > pathLength[j]) {
+          min = pathLength[j];
+          this_id = j;
+        }
+    }
+    if (this_id == end_id) return pathLength[end_id];
+    ++counter;
+  }
+  return pathLength[end_id];
+}
+
+double DeikstraAlgorithm(const OrientedWeightedGraphWithZeroWeight& graph,
+                         int start_id, int end_id) {
+  int n = graph.GetVerts();
+  std::vector<bool> ended(n);
+  std::vector<double> pathLength(n, DBL_MAX);
+  pathLength[start_id] = 0;
+  int this_id = start_id;
+  int counter = 0;
+  for (; true;) {
+    if (counter >= n) break;
+    for (int i = 0; i < n; ++i) {
+      if (graph[this_id][i])
+        pathLength[i] = std::min(
+            pathLength[i], pathLength[this_id] + graph.GetWeight(this_id, i));
+    }
+    ended[this_id] = true;
+    double min = DBL_MAX;
+    for (int j = 0; j < n; ++j) {
+      if (!ended[j])
+        if (min > pathLength[j]) {
+          min = pathLength[j];
+          this_id = j;
+        }
+    }
+    if (this_id == end_id) return pathLength[end_id];
+    ++counter;
+  }
+  return pathLength[end_id];
+}
+
+DeikstraReturn DeikstraPathAlgorithm(const WeightedGraph& graph, int start_id,
+                                     int end_id) {
+  int n = graph.GetVerts();
+  std::vector<bool> ended(n);
+  std::vector<double> pathLength(n, DBL_MAX);
+  std::vector<int> prevs(n, -1);
+  pathLength[start_id] = 0;
+  int this_id = start_id;
+  for (int counter = 0; counter < n && this_id != end_id; ++counter) {
+    for (int i = 0; i < n; ++i) {
+      if (graph[this_id][i] &&
+          pathLength[i] > pathLength[this_id] + graph[this_id][i]) {
+        pathLength[i] = pathLength[this_id] + graph[this_id][i];
+        prevs[i] = this_id;
+      }
+    }
+    ended[this_id] = true;
+    double min = DBL_MAX;
+    for (int j = 0; j < n; ++j) {
+      if (!ended[j])
+        if (min > pathLength[j]) {
+          min = pathLength[j];
+          this_id = j;
+        }
+    }
+  }
+  std::vector<int> path;
+  for (int i = end_id; i != start_id; i = prevs[i]) path.push_back(prevs[i]);
+  for (int i = 0; i < path.size() / 2; ++i)
+    std::swap(path[i], path[path.size() - 1 - i]);
+  return DeikstraReturn(path, pathLength[end_id]);
+}
+
+DeikstraReturn DeikstraPathAlgorithm(
+    const OrientedWeightedGraphWithZeroWeight& graph, int start_id,
+    int end_id) {
+  if (start_id == end_id) return DeikstraReturn(std::vector<int>(), 0);
+  int n = graph.GetVerts();
+  std::vector<bool> ended(n);
+  std::vector<double> pathLength(n, DBL_MAX);
+  std::vector<int> prevs(n, -1);
+  pathLength[start_id] = 0;
+  int this_id = start_id;
+  for (int counter = 0; counter < n && this_id != end_id; ++counter) {
+    for (int i = 0; i < n; ++i) {
+      if (graph[this_id][i] &&
+          pathLength[i] > pathLength[this_id] + graph.GetWeight(this_id, i)) {
+        pathLength[i] = pathLength[this_id] + graph.GetWeight(this_id, i);
+        prevs[i] = this_id;
+      }
+    }
+    ended[this_id] = true;
+    double min = DBL_MAX;
+    for (int j = 0; j < n; ++j) {
+      if (!ended[j])
+        if (min > pathLength[j]) {
+          min = pathLength[j];
+          this_id = j;
+        }
+    }
+  }
+  std::vector<int> path;
+  path.push_back(end_id);
+  for (int i = end_id; i != start_id; i = prevs[i]) path.push_back(prevs[i]);
+  for (int i = 0; i < path.size() / 2; ++i)
+    std::swap(path[i], path[path.size() - 1 - i]);
+  return DeikstraReturn(path, pathLength[end_id]);
+}

lib/src/DeikstraAlgorithm.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <includes.h>
+
+struct DeikstraReturn {
+  std::vector<int> path;
+  double pathLength;
+};
+
+double DeikstraAlgorithm(const WeightedGraph& graph, int start_id, int end_id);
+double DeikstraAlgorithm(const OrientedWeightedGraphWithZeroWeight& graph,
+                         int start_id, int end_id);
+DeikstraReturn DeikstraPathAlgorithm(const WeightedGraph& graph, int start_id,
+                                     int end_id);
+DeikstraReturn DeikstraPathAlgorithm(
+    const OrientedWeightedGraphWithZeroWeight& graph, int start_id, int end_id);

lib/src/Graph.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <WeightedGraph.h>
+#include <util.h>
+
+#include <vector>
+
+class Graph : public WeightedGraph {
+  int GetEdges() {
+    int result = 0;
+    for (int i = 0; i < graph.size(); ++i) result += sum(graph[i]);
+    return result;
+  }
+};

lib/src/GraphDFSIterator.cpp

@@ -0,0 +1,31 @@
+#include <GraphDFSIterator.h>
+
+GraphDFSIterator::GraphDFSIterator(const WeightedGraph* const graph,
+                                   int start_id) {
+  this->start_id = start_id;
+  this->graph = graph;
+  this->is_end = false;
+  this_id = start_id;
+  visited.resize(graph->GetVerts());
+  visited[start_id] = true;
+  parent.resize(graph->GetVerts(), -1);
+}
+
+int GraphDFSIterator::Next() {
+  for (int i = 0; i < graph->GetVerts(); ++i) {
+    if ((*graph)[this_id][i] != 0 && !visited[i]) {
+      visited[i] = true;
+      parent[i] = this_id;
+      this_id = i;
+      return i;
+    }
+  }
+  if (parent[this_id] == -1) {
+    is_end = true;
+    return this_id;
+  }
+  this_id = parent[this_id];
+  return Next();
+}
+
+bool GraphDFSIterator::IsEnd() { return is_end; }

lib/src/GraphDFSIterator.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <WeightedGraph.h>
+#include <util.h>
+
+#include <vector>
+
+class WeightedGraph;
+
+class GraphDFSIterator {
+  const WeightedGraph* graph;
+  int start_id;
+  int this_id;
+  bool is_end;
+  std::vector<bool> visited;
+  std::vector<int> parent;
+
+  int Next();
+
+ public:
+  GraphDFSIterator() = delete;
+  GraphDFSIterator(const WeightedGraph* const graph, int start_id);
+
+  int operator++() { return Next(); }
+  int operator()() { return this_id; }
+  bool IsEnd();
+};

lib/src/JonsonAlgorithm.cpp

@@ -0,0 +1,27 @@
+#include "JonsonAlgorithm.h"
+
+double GetPathLength(const WeightedGraph& graph, const std::vector<int>& path) {
+  if (path.size() == 0) return 0;
+  double result = 0;
+  for (int i = 0; i < path.size() - 1; ++i)
+    result += graph[path[i]][path[i + 1]];
+  return result;
+}
+
+OrientedWeightedGraphWithZeroWeight JonsonAlgorithm(
+    const WeightedGraph& graph) {
+  int n = graph.GetVerts();
+  OrientedWeightedGraphWithZeroWeight new_graph(graph);
+  for (int i = 0; i < n; ++i) new_graph.AddEdge(n, i, 0);
+  auto h = BellmanFordAlgorithm(new_graph, n);
+  if (h.size() == 0) return WeightedGraph();
+  for (int i = 0; i < n; ++i)
+    for (int j = 0; j < n; ++j) new_graph.GetWeight(i, j) += h[i] - h[j];
+  OrientedWeightedGraphWithZeroWeight resultGraph;
+  for (int i = 0; i < n; ++i)
+    for (int j = 0; j < n; ++j)
+      resultGraph.AddEdge(
+          i, j,
+          GetPathLength(graph, DeikstraPathAlgorithm(new_graph, i, j).path));
+  return resultGraph;
+}

lib/src/JonsonAlgorithm.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <includes.h>
+
+#include "BellmanForlAlgorithm.h"
+#include "DeikstraAlgorithm.h"
+
+OrientedWeightedGraphWithZeroWeight JonsonAlgorithm(const WeightedGraph& graph);

lib/src/Lca.h

@@ -0,0 +1,19 @@
+#pragma once
+
+struct Node {
+  int data;
+  Node* left;
+  Node* right;
+  Node(int val) {
+    data = val;
+    left = nullptr;
+    right = nullptr;
+  }
+};
+
+Node* LCA(Node* root, int n1, int n2) {
+  if (root == nullptr) return nullptr;
+  if (root->data > n1 && root->data > n2) return LCA(root->left, n1, n2);
+  if (root->data < n1 && root->data < n2) return LCA(root->right, n1, n2);
+  return root;
+}