From ae2280e132ec951c69051f832846154f87d3d92e Mon Sep 17 00:00:00 2001 From: RajNilkar Date: Thu, 9 Jul 2026 15:55:48 -0700 Subject: [PATCH] Rename SSSP to SPSP - correctly reflects Single Pair Shortest Path problem --- .../P/{P_SSSP/P_SSSP.cs => P_SPSP/P_SPSP.cs} | 32 +++++----- .../Solvers/SPSPSolver.cs} | 8 +-- .../Verifiers/SPSPVerifier.cs} | 18 +++--- .../Visualizations/SPSPVisualization.cs} | 20 +++---- .../SSSPTests.cs => P_SPSP/SPSPTests.cs} | 60 +++++++++---------- 5 files changed, 69 insertions(+), 69 deletions(-) rename Problems/P/{P_SSSP/P_SSSP.cs => P_SPSP/P_SPSP.cs} (88%) rename Problems/P/{P_SSSP/Solvers/SSSPSolver.cs => P_SPSP/Solvers/SPSPSolver.cs} (98%) rename Problems/P/{P_SSSP/Verifiers/SSSPVerifier.cs => P_SPSP/Verifiers/SPSPVerifier.cs} (90%) rename Problems/P/{P_SSSP/Visualizations/SSSPVisualization.cs => P_SPSP/Visualizations/SPSPVisualization.cs} (87%) rename redux-tests/Problems/{P_SSSP/SSSPTests.cs => P_SPSP/SPSPTests.cs} (77%) diff --git a/Problems/P/P_SSSP/P_SSSP.cs b/Problems/P/P_SPSP/P_SPSP.cs similarity index 88% rename from Problems/P/P_SSSP/P_SSSP.cs rename to Problems/P/P_SPSP/P_SPSP.cs index 0cf40bc3..9156ccfe 100644 --- a/Problems/P/P_SSSP/P_SSSP.cs +++ b/Problems/P/P_SPSP/P_SPSP.cs @@ -1,24 +1,24 @@ using API.Interfaces; using API.Interfaces.Graphs; using API.Problems.NPComplete.NPC_TSP.Verifiers; -using API.Problems.P.P_SSSP.Solvers; -using API.Problems.P.P_SSSP.Verifiers; -using API.Problems.P.P_SSSP.Visualizations; +using API.Problems.P.P_SPSP.Solvers; +using API.Problems.P.P_SPSP.Verifiers; +using API.Problems.P.P_SPSP.Visualizations; using SPADE; using System.Collections.Generic; using System.Linq; using System.Text; -namespace API.Problems.P.P_SSSP; +namespace API.Problems.P.P_SPSP; -class SSSP : IGraphProblem +class SPSP : IGraphProblem { // --- Fields --- - public string problemName { get; } = "Single Source Shortest Path Problem"; + public string problemName { get; } = "Single Pair Shortest Path Problem"; public string problemLink { get; } = "https://en.wikipedia.org/wiki/Shortest_path_problem"; - public string formalDefinition { get; } = "For a weighted graph G= (V,E) with non-negative edge weights and source vertex s \u2208 V, find the shortest path distance from s to every other vertex v \u2208 V, where path length is defined as the sum of edge weights along the path."; - public string problemDefinition { get; } = "Single Source Shortest Path (SSSP) in a weighted graph is the problem of finding the shortest path from a given source vertex s in the graph, such that the sum of edge weights along each path is minimized."; + public string formalDefinition { get; } = "For a weighted graph G= (V,E) with non-negative edge weights, a source vertex s \u2208 V, and a target vertex t \u2208 V, find the shortest path from s to t, where path length is defined as the sum of edge weights along the path."; + public string problemDefinition { get; } = "Single Pair Shortest Path (SPSP) in a weighted graph is the problem of finding the shortest path from a given source vertex s and target vertex t in the graph, such that the sum of edge weights along the path is minimized."; public string source { get; } = "N/A"; public string sourceLink { get; } = "N/A"; private static string _defaultInstance = @@ -33,9 +33,9 @@ class SSSP : IGraphProblem _nodes = new List(); private List> _edges = new List>(); - public SSSPSolver defaultSolver { get; } = new SSSPSolver(); - public SSSPVerifier defaultVerifier { get; } = new SSSPVerifier(); - public SSSPVisualization defaultVisualization { get; } = new SSSPVisualization(); + public SPSPSolver defaultSolver { get; } = new SPSPSolver(); + public SPSPVerifier defaultVerifier { get; } = new SPSPVerifier(); + public SPSPVisualization defaultVisualization { get; } = new SPSPVisualization(); public UtilCollectionGraph graph { get; set; } public string[] contributors { get; } = { "Rajit Nilkar", "Scott Barfuss" }; @@ -52,9 +52,9 @@ public List> edges } // --- Methods Including Constructors --- - public SSSP() : this(_defaultInstance) { } + public SPSP() : this(_defaultInstance) { } - public SSSP(string GInput) + public SPSP(string GInput) { instance = GInput; @@ -136,7 +136,7 @@ private static GraphParseResult ParseGraph(string graphInput) } } - throw new InvalidOperationException("Failed to parse SSSP instance.", lastError); + throw new InvalidOperationException("Failed to parse SPSP instance.", lastError); } private static void ValidateInstance( @@ -164,7 +164,7 @@ private static void ValidateInstance( throw new InvalidOperationException($"Edge target '{edge.To}' is not in N."); if (edge.Weight < 0) - throw new InvalidOperationException("SSSP using Dijkstra's algorithm does not allow negative edge weights."); + throw new InvalidOperationException("SPSP using Dijkstra's algorithm does not allow negative edge weights."); } } @@ -189,7 +189,7 @@ private static ParsedEdge ParseEdge(UtilCollection rawEdge) int weight = int.Parse(rawEdge[1].ToString()); if (weight < 0) - throw new InvalidOperationException($"SSSP using Dijkstra's algorithm does not allow negative edge weights. Found edge weight: {weight}"); + throw new InvalidOperationException($"SPSP using Dijkstra's algorithm does not allow negative edge weights. Found edge weight: {weight}"); return new ParsedEdge(GetFrom(endpoints), GetTo(endpoints), weight); } diff --git a/Problems/P/P_SSSP/Solvers/SSSPSolver.cs b/Problems/P/P_SPSP/Solvers/SPSPSolver.cs similarity index 98% rename from Problems/P/P_SSSP/Solvers/SSSPSolver.cs rename to Problems/P/P_SPSP/Solvers/SPSPSolver.cs index bfdf00bc..d3a65ac6 100644 --- a/Problems/P/P_SSSP/Solvers/SSSPSolver.cs +++ b/Problems/P/P_SPSP/Solvers/SPSPSolver.cs @@ -4,9 +4,9 @@ using API.Interfaces.Graphs; using SPADE; -namespace API.Problems.P.P_SSSP.Solvers; +namespace API.Problems.P.P_SPSP.Solvers; -class SSSPSolver : ISolver +class SPSPSolver : ISolver { // ----- Fields ----- // public string solverName { get; } = "Dijkstra's Algorithm"; @@ -16,7 +16,7 @@ class SSSPSolver : ISolver public bool timerHasExpired { get; set; } PriorityQueue? pq; - public string solve(SSSP problem) + public string solve(SPSP problem) { UtilCollectionGraph graph = problem.graph; List nodes = graph.Nodes.ToList().Select(n => n.ToString()).ToList(); @@ -207,7 +207,7 @@ private static bool LooksLikeCollection(UtilCollection u) } // GetSteps: The steps are returned as a list of strings, where each string representing a path in the certificate format - public List GetSteps(SSSP problem) + public List GetSteps(SPSP problem) { var steps = new List(); UtilCollectionGraph graph = problem.graph; diff --git a/Problems/P/P_SSSP/Verifiers/SSSPVerifier.cs b/Problems/P/P_SPSP/Verifiers/SPSPVerifier.cs similarity index 90% rename from Problems/P/P_SSSP/Verifiers/SSSPVerifier.cs rename to Problems/P/P_SPSP/Verifiers/SPSPVerifier.cs index 8f76d624..01cbd639 100644 --- a/Problems/P/P_SSSP/Verifiers/SSSPVerifier.cs +++ b/Problems/P/P_SPSP/Verifiers/SPSPVerifier.cs @@ -3,25 +3,25 @@ using System.Linq; using API.Interfaces; using API.Interfaces.Graphs.GraphParser; -using API.Problems.P.P_SSSP.Solvers; +using API.Problems.P.P_SPSP.Solvers; -namespace API.Problems.P.P_SSSP.Verifiers; +namespace API.Problems.P.P_SPSP.Verifiers; -class SSSPVerifier : IVerifier +class SPSPVerifier : IVerifier { - public string verifierName { get; } = "Single Source Shortest Path Verifier"; - public string verifierDefinition { get; } = "Verifies the solution for the Single Source Shortest Path problem"; + public string verifierName { get; } = "Single Pair Shortest Path Verifier"; + public string verifierDefinition { get; } = "Verifies the solution for the Single Pair Shortest Path problem"; public string source { get; } = ""; public string[] contributors { get; } = { "Rajit Nilkar", "Scott Barfuss" }; private string _certificate = ""; public string certificate => _certificate; - public SSSPVerifier() { } + public SPSPVerifier() { } // verify: takes a problem instance and a solution certificate, // and returns true if the certificate is a valid solution to the problem instance, // false otherwise - public bool verify(SSSP problem, string solution) + public bool verify(SPSP problem, string solution) { _certificate = solution ?? ""; // Reset certificate before verification @@ -33,7 +33,7 @@ public bool verify(SSSP problem, string solution) string sourceNode = problem.sourceNode; string targetNode = problem.targetNode; - var adjacency = SSSPSolver.BuildAdjacencyList(problem.graph); + var adjacency = SPSPSolver.BuildAdjacencyList(problem.graph); // Compute true shortest distance using Dijkstra's algorithm int? shortest = ShortestDistance(adjacency, nodes, sourceNode, targetNode); @@ -113,7 +113,7 @@ public bool verify(SSSP problem, string solution) foreach (var (next, weight) in neighbors) { if (weight < 0) - throw new InvalidOperationException("SSSP does not allow negative edge weights."); + throw new InvalidOperationException("SPSP does not allow negative edge weights."); if (visited.Contains(next)) continue; // Skip visited neighbors diff --git a/Problems/P/P_SSSP/Visualizations/SSSPVisualization.cs b/Problems/P/P_SPSP/Visualizations/SPSPVisualization.cs similarity index 87% rename from Problems/P/P_SSSP/Visualizations/SSSPVisualization.cs rename to Problems/P/P_SPSP/Visualizations/SPSPVisualization.cs index 1d62adfe..4cb095d7 100644 --- a/Problems/P/P_SSSP/Visualizations/SSSPVisualization.cs +++ b/Problems/P/P_SPSP/Visualizations/SPSPVisualization.cs @@ -2,22 +2,22 @@ using API.Interfaces.Graphs.GraphParser; using API.Interfaces.JSON_Objects; using API.Interfaces.JSON_Objects.Graphs; -using API.Problems.P.P_SSSP.Solvers; +using API.Problems.P.P_SPSP.Solvers; -namespace API.Problems.P.P_SSSP.Visualizations; +namespace API.Problems.P.P_SPSP.Visualizations; -class SSSPVisualization : IVisualization +class SPSPVisualization : IVisualization { - public string visualizationName { get; } = "Single Source Shortest Path Visualization"; - public string visualizationDefinition { get; } = "Visualizes the Single Source Shortest Path problem for non-negative weighted directed cyclic graphs using Dijkstra's algorithm"; + public string visualizationName { get; } = "Single Pair Shortest Path Visualization"; + public string visualizationDefinition { get; } = "Visualizes the Single Pair Shortest Path problem for non-negative weighted directed cyclic graphs using Dijkstra's algorithm"; public string source { get; } = ""; public string[] contributors { get; } = { "Rajit Nilkar", "Scott Barfuss", "Tiger Sant", "Malaya Witt" }; public string visualizationType => "Graph D3"; - public ISolver solver { get; } = new SSSPSolver(); + public ISolver solver { get; } = new SPSPSolver(); - public SSSPVisualization() { } + public SPSPVisualization() { } - public API_JSON visualize(SSSP problem) + public API_JSON visualize(SPSP problem) { // For simplicity, we will just return a JSON representation of the graph // In a real implementation, this would be more complex and would include visual elements @@ -26,7 +26,7 @@ public API_JSON visualize(SSSP problem) // SolvedVisualization: takes a problem instance and a solution certificate, // and returns a visualization of the problem instance with the solution highlighted - public API_JSON SolvedVisualization(SSSP problem, string solution) + public API_JSON SolvedVisualization(SPSP problem, string solution) { if (string.IsNullOrWhiteSpace(solution) || solution.Trim() == "{}") // No path found, return graph with no highlights @@ -69,7 +69,7 @@ public API_JSON SolvedVisualization(SSSP problem, string solution) return graph; } - public List StepsVisualization(SSSP problem, List steps) + public List StepsVisualization(SPSP problem, List steps) { var result = new List(); diff --git a/redux-tests/Problems/P_SSSP/SSSPTests.cs b/redux-tests/Problems/P_SPSP/SPSPTests.cs similarity index 77% rename from redux-tests/Problems/P_SSSP/SSSPTests.cs rename to redux-tests/Problems/P_SPSP/SPSPTests.cs index 0811b741..d4df950a 100644 --- a/redux-tests/Problems/P_SSSP/SSSPTests.cs +++ b/redux-tests/Problems/P_SPSP/SPSPTests.cs @@ -2,47 +2,47 @@ using System.Linq; using Xunit; using API.Interfaces.JSON_Objects.Graphs; -using API.Problems.P.P_SSSP; -using API.Problems.P.P_SSSP.Solvers; -using API.Problems.P.P_SSSP.Verifiers; -using API.Problems.P.P_SSSP.Visualizations; +using API.Problems.P.P_SPSP; +using API.Problems.P.P_SPSP.Solvers; +using API.Problems.P.P_SPSP.Verifiers; +using API.Problems.P.P_SPSP.Visualizations; namespace redux_tests; #pragma warning disable CS1591 -public class SSSP_Tests +public class SPSP_Tests { [Fact] - public void SSSP_Default_Instantiation() + public void SPSP_Default_Instantiation() { - SSSP problem = new SSSP(); + SPSP problem = new SPSP(); Assert.Equal("({1,2,3,4,5},{((1,2),4),((1,3),2),((2,3),1),((3,5),7),((2,4),3),((4,5),9)},1,5)", problem.instance); Assert.Equal(problem.defaultInstance, problem.instance); } [Fact] - public void SSSP_Custom_Instantiation() + public void SPSP_Custom_Instantiation() { string instance = "({1,2,3,4,5,6},{((1,2),8),((1,3),4),((2,3),6),((3,5),5),((2,4),3),((4,5),9),((3,6),1),((4,6),12),((5,6),5)},1,6)"; - var problem = new SSSP(instance); + var problem = new SPSP(instance); Assert.Equal(instance, problem.instance); } [Theory] [InlineData("({1,2}, {((1,2),-1)}),1,2")] [InlineData("(({1,2}, {((1,2),-1)}),1,2")] - public void SSSP_Rejects_Negative_Edge_Weights(string instance) + public void SPSP_Rejects_Negative_Edge_Weights(string instance) { // Dijkstra's algorithm correctness depends on non-negative weights // The SSSP problem must reject problem instances with negative-weights during parse time - Assert.Throws(() => new SSSP(instance)); + Assert.Throws(() => new SPSP(instance)); } [Fact] - public void SHORTESTPATH_Rejects_Source_Outside_Node_Set() + public void SPSP_Rejects_Source_Outside_Node_Set() { string instance = "(({1,2,3},{((1,2),1),((2,3),1)}),4,3)"; - Assert.Throws(() => new SSSP(instance)); + Assert.Throws(() => new SPSP(instance)); } // ----- Solver ----- // @@ -51,10 +51,10 @@ public void SHORTESTPATH_Rejects_Source_Outside_Node_Set() [InlineData("({1,2,3,4,5},{((1,2),4),((1,3),2),((2,3),1),((3,5),7),((2,4),3),((4,5),9)},1,5)", "{1,3,5}")] [InlineData("(({A,B,C,D},{((A,B),2),((B,D),2),((A,C),1),((C,D),1)}),A,D)", "{A,C,D}")] [InlineData("(({1,2,3},((1,2))),1,3)", "{}")] - public void SSSP_Solver(string instance, string certificate) + public void SPSP_Solver(string instance, string certificate) { - SSSP problem = new SSSP(instance); - SSSPSolver solver = new SSSPSolver(); + SPSP problem = new SPSP(instance); + SPSPSolver solver = new SPSPSolver(); string solution = solver.solve(problem); Assert.Equal(certificate, solution); } @@ -64,11 +64,11 @@ public void SSSP_Solver(string instance, string certificate) [InlineData("({1,2,3,4,5,6},{((1,2),8),((1,3),4),((2,3),6),((3,5),5),((2,4),3),((4,5),9),((3,6),1),((4,6),12),((5,6),5)},1,6)", 5)] [InlineData("(({1,2,3,4},{((1,2),1),((2,3),1),((3,4),1),((1,4),10)}),2,4)", 2)] [InlineData("(({A,B,C,D},{((A,B),2),((B,D),2),((A,C),1),((C,D),1)}),A,D)", 2)] - public void SSSP_Solver_Returns_Valid_Minimum_Cost_Path(string instance, int expectedMinCost) + public void SPSP_Solver_Returns_Valid_Minimum_Cost_Path(string instance, int expectedMinCost) { - SSSP problem = new SSSP(instance); - SSSPSolver solver = new SSSPSolver(); - SSSPVerifier verifier = new SSSPVerifier(); + SPSP problem = new SPSP(instance); + SPSPSolver solver = new SPSPSolver(); + SPSPVerifier verifier = new SPSPVerifier(); string solution = solver.solve(problem); @@ -80,8 +80,8 @@ public void SSSP_Solver_Returns_Valid_Minimum_Cost_Path(string instance, int exp public void SSSP_Solver_Handles_Equal_Weights() { string instance = "(({1,2,3},{((1,2),1),((2,3),1)}),1,1)"; - SSSP problem = new SSSP(instance); - SSSPSolver solver = new SSSPSolver(); + SPSP problem = new SPSP(instance); + SPSPSolver solver = new SPSPSolver(); string solution = solver.solve(problem); @@ -101,8 +101,8 @@ public void SSSP_Solver_Handles_Equal_Weights() [InlineData("(({A,B,C,D},{((A,B),2),((B,D),2),((A,C),1),((C,D),1)}),A,D)", "{A,C,D}", true)] public void SSSP_Verifier(string instance, string certificate, bool expected) { - SSSP problem = new SSSP(instance); - SSSPVerifier verifier = new SSSPVerifier(); + SPSP problem = new SPSP(instance); + SPSPVerifier verifier = new SPSPVerifier(); bool result = verifier.verify(problem, certificate); Assert.Equal(expected, result); } @@ -111,8 +111,8 @@ public void SSSP_Verifier(string instance, string certificate, bool expected) public void SSSP_Verifier_Rejects_Empty_Certificates_When_Path_Exists() { string instance = "({1,2,3,4,5},{((1,2),4),((1,3),2),((2,3),1),((3,5),7),((2,4),3),((4,5),9)},1,5)"; - SSSP problem = new SSSP(instance); - SSSPVerifier verifier = new SSSPVerifier(); + SPSP problem = new SPSP(instance); + SPSPVerifier verifier = new SPSPVerifier(); Assert.False(verifier.verify(problem, "{}")); } @@ -121,8 +121,8 @@ public void SSSP_Verifier_Rejects_Empty_Certificates_When_Path_Exists() public void StepsVisualization_Highlights_Final_Path_Nodes_As_Solution() { string instance = "({1,2,3,4,5},{((1,2),4),((1,3),2),((2,3),1),((3,5),7),((2,4),3),((4,5),9)},1,5)"; - SSSP problem = new SSSP(instance); - SSSPVisualization visualization = new SSSPVisualization(); + SPSP problem = new SPSP(instance); + SPSPVisualization visualization = new SPSPVisualization(); var steps = new List { "{1,3,5}" }; var frames = visualization.StepsVisualization(problem, steps); @@ -134,10 +134,10 @@ public void StepsVisualization_Highlights_Final_Path_Nodes_As_Solution() // ----- Helper ----- // // The purpose of this helper function is to parse a certificate like "{1,3,5}" and sums the edge weights along the path - private static int TotalPathWeight(SSSP problem, string certificate) + private static int TotalPathWeight(SPSP problem, string certificate) { var nodes = certificate.Trim('{', '}').Split(',').ToList(); - var adjacency = SSSPSolver.BuildAdjacencyList(problem.graph); + var adjacency = SPSPSolver.BuildAdjacencyList(problem.graph); int total = 0; for (int i = 0; i < nodes.Count - 1; i++)