Traveling Salesman Problem added

Author: DBasu2610

src/main/java/com/thealgorithms/datastructures/graphs/DijkstraAlgorithm.java

@@ -7,7 +7,7 @@
  */
 public class DijkstraAlgorithm {
 
-    private final int vertexCount;
+    private final int vertexCount; 
 
     /**
      * Constructs a Dijkstra object with the given number of vertices.

src/main/java/com/thealgorithms/datastructures/graphs/TravelingSalesmanDP.java

@@ -0,0 +1,64 @@
+package com.thealgorithms.datastructures.graphs;
+
+/**
+ * Problem Statement:
+ * The Traveling Salesman Problem (TSP) asks for the shortest possible route 
+ * that visits a given set of cities and returns to the origin city. 
+ * Each city is connected to every other city, and the goal is to find the shortest route 
+ * that visits each city exactly once and returns to the starting point.
+ *
+ * Approach:
+ * This implementation uses dynamic programming (DP) with bitmasking 
+ * to represent visited cities. The DP state is dp[mask][i], 
+ * where 'mask' represents the set of visited cities, and 'i' is the current city.
+ * 
+ * Time Complexity: O(n^2 * 2^n), where 'n' is the number of cities.
+ * Space Complexity: O(n * 2^n), due to the DP table and bitmask representation.
+ */
+
+ import java.util.Arrays;
+
+ public class TravelingSalesmanDP {
+     private static final int INF = Integer.MAX_VALUE / 2; // Infinity value for unvisited paths
+     
+     /**
+      * Solves the TSP using dynamic programming.
+      *
+      * @param dist Matrix where dist[i][j] represents the distance between city i and city j.
+      * @return Minimum cost of traveling through all cities and returning to the start.
+      */
+     public static int tsp(int[][] dist) {
+         int n = dist.length;
+         int[][] dp = new int[n][(1 << n)]; // DP table
+         
+         // Initialize DP table with infinity
+         for (int[] row : dp) {
+             Arrays.fill(row, INF);
+         }
+         
+         // Start at city 0 with only the first city visited
+         dp[0][1] = 0;
+         
+         // Iterate over all subsets of visited cities
+         for (int mask = 1; mask < (1 << n); mask++) {
+             for (int u = 0; u < n; u++) {
+                 if ((mask & (1 << u)) == 0) continue; // If city u is not visited in this subset
+                 
+                 for (int v = 0; v < n; v++) {
+                     if ((mask & (1 << v)) != 0 || dist[u][v] == INF) continue; // If city v is already visited
+                     int newMask = mask | (1 << v); // Visit city v
+                     dp[v][newMask] = Math.min(dp[v][newMask], dp[u][mask] + dist[u][v]);
+                 }
+             }
+         }
+         
+         // Return the minimum cost of visiting all cities and returning to city 0
+         int result = INF;
+         for (int i = 1; i < n; i++) {
+             result = Math.min(result, dp[i][(1 << n) - 1] + dist[i][0]);
+         }
+         
+         return result;
+     }
+ }
+ 

src/test/java/com/thealgorithms/audiofilters/IIRFilterTest.java

@@ -80,4 +80,4 @@ void testProcessWithCoeffsSet() {
         // check if the method runs and returns a result within reasonable bounds
         assertTrue(result >= -1.0 && result <= 1.0, "Processed result should be in the range [-1, 1]");
     }
-}
+} 

src/test/java/com/thealgorithms/datastructures/graphs/DijkstraAlgorithmTest.java

@@ -5,7 +5,7 @@
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-
+ 
 public class DijkstraAlgorithmTest {
 
     private DijkstraAlgorithm dijkstraAlgorithm;

src/test/java/com/thealgorithms/datastructures/graphs/TravelingSalesmanTest.java

@@ -0,0 +1,20 @@
+package com.thealgorithms.datastructures.graphs;
+
+public class TravelingSalesmanTest {
+    public static void main(String[] args) {
+        // Test case: Distance matrix representing the cities
+        int[][] dist = {
+            { 0, 10, 15, 20 },
+            { 10, 0, 35, 25 },
+            { 15, 35, 0, 30 },
+            { 20, 25, 30, 0 }
+        };
+
+        // Calling the tsp method from the TravelingSalesmanDP class
+        int result = TravelingSalesmanDP.tsp(dist);
+
+        // Output the result
+        System.out.println("Minimum cost: " + result);
+        // Expected output: Minimum cost: 80
+    }
+}