Travelling Salesman Problem in Java

In Java, Travelling Salesman Problem is a problem in which we need to find the shortest route that covers each city exactly once and returns to the starting point. Hamiltonian Cycle is another problem in Java that is mostly similar to Travelling Salesman Problem.

The main difference between TSP and the Hamiltonian cycle is that in Hamiltonian Cycle, we are not sure whether a tour that visits each city exactly once exists or not, and we have to determine it. In the Travelling Salesman Problem, a Hamiltonian cycle is always present because the graph is complete, and the problem is to find a Hamiltonian cycle with minimum weight.

Let's take an example of the Travelling Salesman Problem to understand the problem.

In the above graph, a, b, c, d, e, f, and g are the cities and we have to find the Hamiltonian cycle having minimum weight. There are several Hamiltonian Cycle and some of them are as follows:

a -> b -> c -> d -> e -> f-> g -> a
a -> c -> b -> d -> e -> f -> g -> a
a -> g -> c -> e -> f-> d -> b -> a

The weight of each Hamiltonian cycle can be different, and now our task is to find that route having a minimum distance.

Steps to implement Travelling Salesman Problem

These are the following steps, which we use to implement the TSP program in Java:

We consider a city as the starting and ending point. We can use any city as a starting point because the route is cyclic.
In the DFS way, we start traversing from the source to its adjacent nodes.
Find the cost of each traversal and keep track of minimum cost and keep on updating the value of minimum cost stored value.
In the end, return the permutation with minimum cost.

Let's implement the Java code of TSP by using the above steps:

TSPExample.java

// import required classes and packages
import Java.util.*; 
import java.io.*; 
import java.util.Scanner;

// create TSPExample class to implement TSP code in Java
class TSPExample 
{
	// create findHamiltonianCycle() method to get minimum weighted cycle 
    static int findHamiltonianCycle(int[][] distance, boolean[] visitCity, int currPos, int cities, int count, int cost, int hamiltonianCycle) 
    {
  
        if (count == cities && distance[currPos][0] > 0) 
        {
            hamiltonianCycle = Math.min(hamiltonianCycle, cost + distance[currPos][0]);
            return hamiltonianCycle;
        }
  
        // BACKTRACKING STEP
        for (int i = 0; i < cities; i++) 
        {
            if (visitCity[i] == false && distance[currPos][i] > 0) 
            {
  
                // Mark as visited
                visitCity[i] = true;
                hamiltonianCycle = findHamiltonianCycle(distance, visitCity, i, cities, count + 1, cost + distance[currPos][i], hamiltonianCycle);
  
                // Mark ith node as unvisited
                visitCity[i] = false;
            }
        }
        return hamiltonianCycle;
    }
  
    // main() method start
    public static void main(String[] args)
    {
		int cities;
		
		//create scanner class object to get input from user
		Scanner sc = new Scanner(System.in);
		
        // get total number of cities from the user
		System.out.println("Enter total number of cities ");
		cities = sc.nextInt();
		
		
		//get distance of cities from the user
		int distance[][] = new int[cities][cities];
		for( int i = 0; i < cities; i++){
			for( int j = 0; j < cities; j++){
				System.out.println("Distance from city"+ (i+1) +" to city"+ (j+1) +": ");
				distance[i][j] = sc.nextInt();
			}
		}
  
        // create an array of type boolean to check if a node has been visited or not
        boolean[] visitCity = new boolean[cities];
  
        // by default, we make the first city visited
        visitCity[0] = true;
		
		
        int hamiltonianCycle = Integer.MAX_VALUE;
  
        // call findHamiltonianCycle() method that returns the minimum weight Hamiltonian Cycle
        hamiltonianCycle = findHamiltonianCycle(distance, visitCity, 0, cities, 1, 0, hamiltonianCycle);
  
        // print the minimum weighted Hamiltonian Cycle
        System.out.println(hamiltonianCycle);
    }
}

Output