Add Dijkstra algorithm

Author: vadyushkins

.gitignore

@@ -30,3 +30,9 @@
 *.exe
 *.out
 *.app
+
+# Build
+build
+
+# VSCOde
+.vscode

CMakeLists.txt

@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.28)
+project(algorithms_in_cpp)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(FetchContent)
+FetchContent_Declare(
+    googletest
+    URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
+)
+# For Windows: Prevent overriding the parent project's compiler/linker settings
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+
+enable_testing()
+
+add_executable(${PROJECT_NAME} main.cpp)
+
+target_link_libraries(${PROJECT_NAME} GTest::gtest_main)
+
+file(GLOB SUBDIRS ${PROJECT_SOURCE_DIR}/algorithms/*)
+foreach(dir ${SUBDIRS})
+    add_subdirectory(${dir})
+endforeach()
+
+include(GoogleTest)
+gtest_discover_tests(${PROJECT_NAME})

algorithms/dijkstra/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${PROJECT_NAME} PUBLIC test_dijkstra.cpp dijkstra.cpp)

algorithms/dijkstra/dijkstra.cpp

@@ -0,0 +1,50 @@
+#include "dijkstra.hpp"
+
+std::vector<int64_t> dijkstra(
+    const std::vector<std::vector<std::pair<int64_t, int64_t>>> graph,
+    const int64_t source_node
+)
+{
+    size_t n = graph.size();
+    std::vector<int64_t> distance(n, -1);
+    std::vector<bool> relaxed(n, false);
+
+    distance[source_node] = 0;
+    for (size_t i = 0; i < n; ++i)
+    {
+        int64_t u = -1;
+        for (int64_t j = 0; j < n; ++j)
+        {
+            if (
+                relaxed[j] == false && (
+                    u == -1 || (
+                        distance[j] != -1 &&
+                        distance[j] < distance[u]
+                    )
+                )
+            )
+            {
+                u = j;
+            }
+        }
+        if (u == -1)
+        {
+            break;
+        }
+
+        for (const auto &[v, w] : graph[u])
+        {
+            if (
+                distance[v] == -1 ||
+                distance[v] > distance[u] + w
+            )
+            {
+                distance[v] = distance[u] + w;
+            }
+        }
+
+        relaxed[u] = true;
+    }
+
+    return distance;
+}

algorithms/dijkstra/dijkstra.hpp

@@ -0,0 +1,7 @@
+#include <vector>
+#include <cstdint>
+
+std::vector<int64_t> dijkstra(
+    const std::vector<std::vector<std::pair<int64_t, int64_t>>> graph,
+    const int64_t source_node
+);

algorithms/dijkstra/test_dijkstra.cpp

@@ -0,0 +1,57 @@
+#include <gtest/gtest.h>
+#include <iostream>
+
+#include "dijkstra.hpp"
+
+TEST(Dijkstra, Test0)
+{
+    std::vector<std::vector<std::pair<int64_t, int64_t>>> graph = {
+        {{1, 1}, {2, 1}},
+        {{0, 1}, {2, 1}},
+        {{0, 1}, {1, 1}},
+    };
+
+    int64_t source_node = 0;
+
+    std::vector<int64_t> distance = dijkstra(graph, source_node);
+
+    std::vector<int64_t> expected_distance = {0, 1, 1};
+
+    ASSERT_EQ(distance, expected_distance);
+}
+
+TEST(Dijkstra, Test1)
+{
+    std::vector<std::vector<std::pair<int64_t, int64_t>>> graph = {
+        {{1, 1}},
+        {{2, 1}},
+        {{3, 1}},
+        {},
+    };
+
+    int64_t source_node = 0;
+
+    std::vector<int64_t> distance = dijkstra(graph, source_node);
+
+    std::vector<int64_t> expected_distance = {0, 1, 2, 3};
+
+    ASSERT_EQ(distance, expected_distance);
+}
+
+TEST(Dijkstra, Test2)
+{
+    std::vector<std::vector<std::pair<int64_t, int64_t>>> graph = {
+        {{1, 1}, {2, 1}},
+        {{3, 1}},
+        {{3, 1}},
+        {},
+    };
+
+    int64_t source_node = 0;
+
+    std::vector<int64_t> distance = dijkstra(graph, source_node);
+
+    std::vector<int64_t> expected_distance = {0, 1, 1, 2};
+
+    ASSERT_EQ(distance, expected_distance);
+}

main.cpp

@@ -0,0 +1,7 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char **argv)
+{
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}