Added Floyd-Warshall algorithm implementation in the graph directory. #3081

mikestsa · 2025-12-18T21:41:46Z

Computes shortest paths between all pairs of vertices
Supports negative edge weights (no negative cycles)
Includes helper functions: addEdge(), getDistance(), hasNegativeCycle()
Time complexity: O(V³)

…lementation)

Copilot

Pull request overview

This pull request adds Floyd-Warshall algorithm implementations to compute all-pairs shortest paths in weighted graphs. However, the PR introduces two nearly identical files (floyd_warshall.cpp and floyd_warshall2.cpp) which appears to be unintentional duplication.

Key Changes:

Implementation of Floyd-Warshall algorithm with O(V³) time complexity
Helper functions for adding edges, retrieving distances, and detecting negative cycles
Interactive program with predefined test cases and user input support

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 21 comments.

File	Description
graph/floyd_warshall.cpp	Floyd-Warshall implementation using `size_t` for matrix size variable
graph/floyd_warshall2.cpp	Duplicate Floyd-Warshall implementation using `int` for matrix size variable

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2025-12-18T21:53:13Z

graph/floyd_warshall2.cpp

+    // running predefined tests
+    tests();
+
+    int vertices = int(), edges = int();


Unnecessary explicit initialization with default constructor. The expression 'int()' is verbose and can simply be '0' or the variable can be left uninitialized since it's assigned before use. The same applies to the edges variable on this line.

Copilot · 2025-12-18T21:53:14Z

graph/floyd_warshall2.cpp

+    int u = int(), v = int();
+    int64_t w = int64_t();


Unnecessary explicit initialization with default constructor. The expressions 'int()' and 'int64_t()' are verbose. These variables can be declared without initialization since they are assigned values from user input before use.

Copilot · 2025-12-18T21:53:14Z

graph/floyd_warshall.cpp

+    std::vector<std::vector<int64_t>>* adj) {
+    /// n denotes the number of vertices in graph
+    size_t n = adj->size();
+
+    /// copy the adjacency matrix to dist
+    std::vector<std::vector<int64_t>> dist = *adj;


The function accepts a raw pointer to a vector, but a const reference would be more appropriate for this use case. Using a raw pointer suggests optional or ownership semantics, neither of which apply here. Since the function only reads the input matrix, consider changing the parameter to a const reference instead.

Suggested change

std::vector<std::vector<int64_t>>* adj) {

/// n denotes the number of vertices in graph

size_t n = adj->size();

/// copy the adjacency matrix to dist

std::vector<std::vector<int64_t>> dist = *adj;

const std::vector<std::vector<int64_t>>& adj) {

/// n denotes the number of vertices in graph

size_t n = adj.size();

/// copy the adjacency matrix to dist

std::vector<std::vector<int64_t>> dist = adj;

Copilot · 2025-12-18T21:53:14Z

graph/floyd_warshall2.cpp

+/** Function to test the Algorithm */
+void tests() {
+    std::cout << "Initiating Predefined Tests..." << std::endl;
+    std::cout << "Initiating Test 1..." << std::endl;
+
+    std::vector<std::vector<int64_t>> adj1(4, std::vector<int64_t>(4, INF));
+    for (int i = 0; i < 4; i++) {
+        adj1[i][i] = 0;
+    }


Duplicated matrix initialization pattern. The pattern of creating a matrix filled with INF and then setting diagonal elements to 0 appears in multiple test cases. Consider extracting this into a helper function to improve maintainability and reduce code duplication.

Suggested change

/** Function to test the Algorithm */

void tests() {

std::cout << "Initiating Predefined Tests..." << std::endl;

std::cout << "Initiating Test 1..." << std::endl;

std::vector<std::vector<int64_t>> adj1(4, std::vector<int64_t>(4, INF));

for (int i = 0; i < 4; i++) {

adj1[i][i] = 0;

}

/** Function to create an adjacency matrix with INF weights and 0 on the diagonal. */

std::vector<std::vector<int64_t>> createAdjMatrix(int n) {

std::vector<std::vector<int64_t>> adj(n, std::vector<int64_t>(n, INF));

for (int i = 0; i < n; i++) {

adj[i][i] = 0;

}

return adj;

}

/** Function to test the Algorithm */

void tests() {

std::cout << "Initiating Predefined Tests..." << std::endl;

std::cout << "Initiating Test 1..." << std::endl;

std::vector<std::vector<int64_t>> adj1 = createAdjMatrix(4);

Copilot · 2025-12-18T21:53:15Z

graph/floyd_warshall.cpp

+    for (int k = 0; k < n; k++) {
+        /// for each source vertex i
+        for (int i = 0; i < n; i++) {
+            /// for each destination vertex j
+            for (int j = 0; j < n; j++) {


Type mismatch between loop variable and container size. The variable 'i' is declared as 'int' but is being compared with 'n' which is 'size_t'. This can cause signed/unsigned comparison warnings. The loop variable should be 'size_t' to match the type of 'n'.

Suggested change

for (int k = 0; k < n; k++) {

/// for each source vertex i

for (int i = 0; i < n; i++) {

/// for each destination vertex j

for (int j = 0; j < n; j++) {

for (size_t k = 0; k < n; k++) {

/// for each source vertex i

for (size_t i = 0; i < n; i++) {

/// for each destination vertex j

for (size_t j = 0; j < n; j++) {

Copilot · 2025-12-18T21:53:20Z

graph/floyd_warshall2.cpp

+    std::vector<std::vector<int64_t>>* adj) {
+    /// n denotes the number of vertices in graph
+    int n = adj->size();
+
+    /// copy the adjacency matrix to dist
+    std::vector<std::vector<int64_t>> dist = *adj;


The function accepts a raw pointer to a vector, but a const reference would be more appropriate for this use case. Using a raw pointer suggests optional or ownership semantics, neither of which apply here. Since the function only reads the input matrix, consider changing the parameter to a const reference instead.

Suggested change

std::vector<std::vector<int64_t>>* adj) {

/// n denotes the number of vertices in graph

int n = adj->size();

/// copy the adjacency matrix to dist

std::vector<std::vector<int64_t>> dist = *adj;

const std::vector<std::vector<int64_t>>& adj) {

/// n denotes the number of vertices in graph

int n = adj.size();

/// copy the adjacency matrix to dist

std::vector<std::vector<int64_t>> dist = adj;

Copilot · 2025-12-18T21:53:21Z

graph/floyd_warshall.cpp

+    if (dist[s][t] != INF) {
+        return dist[s][t];
+    }


Missing bounds validation for vertex indices. The function should validate that 's' and 't' are within valid range (0 to n-1 where n is the matrix size) before accessing the matrix to prevent out-of-bounds access.

Suggested change

if (dist[s][t] != INF) {

return dist[s][t];

}

// Validate indices to prevent out-of-bounds access

if (s < 0 || t < 0) {

return -1;

}

const size_t n = dist.size();

if (n == 0) {

return -1;

}

const size_t rows = n;

const size_t cols = dist[0].size();

const size_t si = static_cast<size_t>(s);

const size_t ti = static_cast<size_t>(t);

if (si >= rows || ti >= cols) {

return -1;

}

if (dist[si][ti] != INF) {

return dist[si][ti];

}

Copilot · 2025-12-18T21:53:21Z

graph/floyd_warshall2.cpp

+int64_t getDistance(const std::vector<std::vector<int64_t>>& dist, int s,
+                    int t) {
+    if (dist[s][t] != INF) {
+        return dist[s][t];
+    }
+    return -1;
+}


Missing bounds validation for vertex indices. The function should validate that 's' and 't' are within valid range (0 to n-1 where n is the matrix size) before accessing the matrix to prevent out-of-bounds access.

Copilot · 2025-12-18T21:53:21Z

graph/floyd_warshall.cpp

+/** Function to test the Algorithm */
+void tests() {
+    std::cout << "Initiating Predefined Tests..." << std::endl;
+    std::cout << "Initiating Test 1..." << std::endl;
+
+    std::vector<std::vector<int64_t>> adj1(4, std::vector<int64_t>(4, INF));
+    for (int i = 0; i < 4; i++) {
+        adj1[i][i] = 0;
+    }


Duplicated matrix initialization pattern. The pattern of creating a matrix filled with INF and then setting diagonal elements to 0 appears in multiple test cases. Consider extracting this into a helper function to improve maintainability and reduce code duplication.

Suggested change

/** Function to test the Algorithm */

void tests() {

std::cout << "Initiating Predefined Tests..." << std::endl;

std::cout << "Initiating Test 1..." << std::endl;

std::vector<std::vector<int64_t>> adj1(4, std::vector<int64_t>(4, INF));

for (int i = 0; i < 4; i++) {

adj1[i][i] = 0;

}

/**

* @brief Helper function to create an n x n matrix initialized with INF

* and 0 on the diagonal.

*

* @param n number of vertices (matrix dimension)

* @return initialized adjacency matrix

*/

static std::vector<std::vector<int64_t>> createInitializedMatrix(

std::size_t n) {

std::vector<std::vector<int64_t>> matrix(

n, std::vector<int64_t>(n, INF));

for (std::size_t i = 0; i < n; i++) {

matrix[i][i] = 0;

}

return matrix;

}

/** Function to test the Algorithm */

void tests() {

std::cout << "Initiating Predefined Tests..." << std::endl;

std::cout << "Initiating Test 1..." << std::endl;

std::vector<std::vector<int64_t>> adj1 = createInitializedMatrix(4);

Copilot · 2025-12-18T21:53:22Z

graph/floyd_warshall2.cpp

+                if (dist[i][k] != INF && dist[k][j] != INF) {
+                    if (dist[i][k] + dist[k][j] < dist[i][j]) {
+                        dist[i][j] = dist[i][k] + dist[k][j];
+                    }


Potential integer overflow when adding edge weights. The expression 'dist[i][k] + dist[k][j]' can overflow before the comparison with 'dist[i][j]' is performed, leading to incorrect shortest path calculations. Consider checking if the addition would overflow before performing it, or restructure the comparison to avoid addition.

Suggested change

if (dist[i][k] != INF && dist[k][j] != INF) {

if (dist[i][k] + dist[k][j] < dist[i][j]) {

dist[i][j] = dist[i][k] + dist[k][j];

}

int64_t dik = dist[i][k];

int64_t dkj = dist[k][j];

if (dik != INF && dkj != INF) {

// Check for potential overflow/underflow before addition

bool will_overflow = false;

if (dkj > 0 && dik > std::numeric_limits<int64_t>::max() - dkj) {

will_overflow = true;

} else if (dkj < 0 && dik < std::numeric_limits<int64_t>::min() - dkj) {

will_overflow = true;

}

if (!will_overflow) {

int64_t through_k = dik + dkj;

if (through_k < dist[i][j]) {

dist[i][j] = through_k;

}

}

feat: add Floyd-Warshall all-pairs shortest path algorithm (graph imp…

298715e

…lementation)

Copilot AI review requested due to automatic review settings December 18, 2025 21:41

mikestsa requested review from Panquesito7 and realstealthninja as code owners December 18, 2025 21:41

Copilot started reviewing on behalf of mikestsa December 18, 2025 21:42 View session

Copilot AI reviewed Dec 18, 2025

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

Added Floyd-Warshall algorithm implementation in the graph directory. #3081

Added Floyd-Warshall algorithm implementation in the graph directory. #3081

Uh oh!

mikestsa commented Dec 18, 2025

Uh oh!

Copilot AI left a comment

Uh oh!

Copilot AI Dec 18, 2025

Uh oh!

Copilot AI Dec 18, 2025

Uh oh!

Copilot AI Dec 18, 2025

Uh oh!

Copilot AI Dec 18, 2025

Uh oh!

Copilot AI Dec 18, 2025

Uh oh!

Copilot AI Dec 18, 2025

Uh oh!

Copilot AI Dec 18, 2025

Uh oh!

Copilot AI Dec 18, 2025

Uh oh!

Copilot AI Dec 18, 2025

Uh oh!

Copilot AI Dec 18, 2025

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

-    if (dist[s][t] != INF) {
-        return dist[s][t];
-    }
+    // Validate indices to prevent out-of-bounds access
+    if (s < 0 || t < 0) {
+        return -1;
+    }
+    const size_t n = dist.size();
+    if (n == 0) {
+        return -1;
+    }
+    const size_t rows = n;
+    const size_t cols = dist[0].size();
+    const size_t si = static_cast<size_t>(s);
+    const size_t ti = static_cast<size_t>(t);
+    if (si >= rows || ti >= cols) {
+        return -1;
+    }
+    if (dist[si][ti] != INF) {
+        return dist[si][ti];
+    }

-/** Function to test the Algorithm */
-void tests() {
-    std::cout << "Initiating Predefined Tests..." << std::endl;
-    std::cout << "Initiating Test 1..." << std::endl;
-    std::vector<std::vector<int64_t>> adj1(4, std::vector<int64_t>(4, INF));
-    for (int i = 0; i < 4; i++) {
-        adj1[i][i] = 0;
-    }
+/**
+ * @brief Helper function to create an n x n matrix initialized with INF
+ *        and 0 on the diagonal.
+ *
+ * @param n number of vertices (matrix dimension)
+ * @return initialized adjacency matrix
+ */
+static std::vector<std::vector<int64_t>> createInitializedMatrix(
+    std::size_t n) {
+    std::vector<std::vector<int64_t>> matrix(
+        n, std::vector<int64_t>(n, INF));
+    for (std::size_t i = 0; i < n; i++) {
+        matrix[i][i] = 0;
+    }
+    return matrix;
+}
+/** Function to test the Algorithm */
+void tests() {
+    std::cout << "Initiating Predefined Tests..." << std::endl;
+    std::cout << "Initiating Test 1..." << std::endl;
+    std::vector<std::vector<int64_t>> adj1 = createInitializedMatrix(4);

-                if (dist[i][k] != INF && dist[k][j] != INF) {
-                    if (dist[i][k] + dist[k][j] < dist[i][j]) {
-                        dist[i][j] = dist[i][k] + dist[k][j];
-                    }
+                int64_t dik = dist[i][k];
+                int64_t dkj = dist[k][j];
+                if (dik != INF && dkj != INF) {
+                    // Check for potential overflow/underflow before addition
+                    bool will_overflow = false;
+                    if (dkj > 0 && dik > std::numeric_limits<int64_t>::max() - dkj) {
+                        will_overflow = true;
+                    } else if (dkj < 0 && dik < std::numeric_limits<int64_t>::min() - dkj) {
+                        will_overflow = true;
+                    }
+                    if (!will_overflow) {
+                        int64_t through_k = dik + dkj;
+                        if (through_k < dist[i][j]) {
+                            dist[i][j] = through_k;
+                        }
+                    }

Uh oh!

Added Floyd-Warshall algorithm implementation in the graph directory. #3081

Are you sure you want to change the base?

Added Floyd-Warshall algorithm implementation in the graph directory. #3081

Uh oh!

Conversation

mikestsa commented Dec 18, 2025

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Dec 18, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 18, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 18, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 18, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 18, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 18, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 18, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 18, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 18, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 18, 2025

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant