0

I think I have some kind of TSP problem. I have matrix of distances between 15 cities:

  A B C D E F G H I J K L M N O
A 0 3 8 7 8 9 4 4 2 9 5 5 7 9 9
B 9 0 6 3 8 9 3 9 5 3 3 4 8 6 8
C 1 7 0 8 3 5 4 3 1 1 7 8 2 4 3
D 1 9 7 0 4 3 5 6 8 4 3 4 2 8 9
E 5 8 3 5 0 9 7 4 9 4 5 7 4 6 2
F 5 7 9 6 2 0 3 5 3 6 6 7 4 9 2
G 3 2 8 1 1 8 0 3 4 5 2 4 7 2 6
H 1 4 7 5 5 3 8 0 1 1 7 6 5 8 1
I 5 5 6 5 5 6 6 4 0 2 1 3 4 9 5
J 4 5 4 1 3 9 2 7 9 0 6 8 1 9 9
K 3 4 6 5 9 4 9 5 2 5 0 5 1 4 2
L 8 9 5 2 6 2 9 9 4 5 5 0 3 1 5
M 5 9 7 1 5 5 5 4 6 2 1 6 0 9 2
N 9 5 7 5 7 8 6 5 2 7 1 2 9 0 1
O 7 6 9 6 9 8 4 5 6 2 9 7 7 7 0

Distance from A to B is not the same as distance from B to A.
letter in row means city from
letter in column means city to
Example:
distance from A to F is 9
distance from F to A is 5

I have to start and end in city A. I have to travel to 9 different cities, I cant visit same city twice. Travelled distance should be minimalised. I am familiar with TSP algorithm but i am not certain how to do it only for 9 cities. It should be possible to solve this by using tsp algorithm only once. Thanks for help.

PanZemiak
  • 21
  • 4

1 Answers1

0

Eventually i figured it out:

// Dynamic Programming based Java program to find shortest path with
// exactly k edges
import java.util.*;
import java.lang.*;
import java.io.*;

class knapsack{

// Define number of vertices in the graph and inifinite value
static final int V = 15;
static final int INF = Integer.MAX_VALUE;
static int numberofedges=10;
static int[][][] S=new int[15][15][15];


// A Dynamic programming based function to find the shortest path
// from u to v with exactly k edges.
static <bolean> int shortestPath(int graph[][], int u, int v, int k)
{   for(int y=0;y<15;y++){
    for(int x=0;x<15;x++){
        for(int z=0;z<9;z++){
    S[x][y][z]=-1;
}}}
    // Table to be filled up using DP. The value sp[i][j][e] will
    // store weight of the shortest path from i to j with exactly
    // k edges
    int sp[][][] = new int[V][V][k+1];
    System.out.println(Arrays.toString(S));
    // Loop for number of edges from 0 to k
    for (int e = 0; e <= k; e++)
    {
        for (int i = 0; i < V; i++)  // for source
        {
            for (int j = 0; j < V; j++) // for destination
            {
                sp[i][j][e] = INF;

                boolean gofind=true;

                for (int x = 1; x <= e; x++) {


                    if (S[i][j][x] == j) {
                        System.out.println(S[i][j][x]);
                        System.out.println("TU");
                        gofind = false;
                        break;
                    }

            }

                if(gofind){
                // initialize value


                // from base cases
                if (e == 0 && i == j) {
                    S[i][j][0]=0;
                    sp[i][j][e] = 0;
                }
                    if (e == 1 && graph[i][j] != INF) {
                        S[i][j][e]=j;
                        sp[i][j][e] = graph[i][j];
                    }
                // go to adjacent only when number of edges is
                // more than 1
                if (e > 1)
                {int help=225;
                    for (int a = 0; a < V; a++)
                    {
                        // There should be an edge from i to a and
                        // a should not be same as either i or j
                        if (graph[i][a] != INF && i != a &&j!= a && sp[a][j][e-1] != INF)
                        {if(sp[i][j][e]>graph[i][a] + sp[a][j][e-1]){
                            help=a;


                        }
                            sp[i][j][e] = Math.min(sp[i][j][e],graph[i][a] + sp[a][j][e-1]);
                        if(help>16)
                            S[i][j][e]=j;
                            else
                            S[i][j][e]=a;
                    }}
                }
            }}
        }
    }
    return sp[u][v][k];
}

public static void main (String[] args)
{
    try {
    Scanner sc = null;
    sc = new Scanner(new BufferedReader(new FileReader("src/ADS2021_cvicenie5data.txt")));
    /* Let us create the graph shown in above diagram*/
    int[][] graph = new int[15][15];
        sc.nextLine();
    while(sc.hasNextLine()) {
            for (int i=0; i<graph.length; i++) {
                String[] line = sc.nextLine().trim().split(" ");
                for (int j=0; j<line.length; j++) {
                    graph[i][j] = Integer.parseInt(line[j]);
                }
            }
        }
    System.out.println(Arrays.deepToString(graph));

    System.out.println("Weight of the shortest path is "+ shortestPath(graph, 0, 0, numberofedges));
    System.out.println(Arrays.toString(S));
}
catch (
FileNotFoundException e) {
e.printStackTrace();
}
}
}
PanZemiak
  • 21
  • 4