Travelling Sales Man (need to visit only subset of nodes): Bugged - algorithm

Question

I need help with my travelling sales man problem code. Its bugged... I know because its a school assignment and there are test cases. So here it goes.
Given a connected graph where I need to visit a subset of nodes. How do I compute the shortest path?
As an example, refer to above image. I need to start from 0 and visit some/all nodes then go back to zero. In the process, I need to compute the shortest path.
Suppose I need to visit all nodes, I will go from 0 -> 1 -> 2 -> 3 -> 0 = 20 + 30 + 12 + 35 = 97. Suppose now I only need to visit node 2, I will go from 0 -> 3 -> 2 -> 3 -> 0 as that gives shortest path of 94 (I can visit nodes I don't have to visit if it can give a shortest path).
Basically, I did:
Compute shortest path between any 2 pairs of required nodes and the source (0). This gives me a shortest path 2D table like (I used dijkstra's):
| 0 1 2 3
--+--------------
0 |
1 |
2 |
3 |
Now, I modify the shopping sales man algorithm (aka. Floyd Warshall’s or APSP) to use this table. Current Java source (TSP and dijkstra's) looks like:
int TSP(int source, int visited) {
if (visited == (int)(Math.pow(2, K)-1)) { // all required visited
return sssp.get(source).get(0); // return to source (0)
} else if (memo.containsKey(source) && memo.get(source).containsKey(visited)) {
return memo.get(source).get(visited);
} else {
int item;
if (!memo.containsKey(source)) {
memo.put(source, new HashMap<Integer, Integer>());
}
memo.get(source).put(visited, 1000000);
for (int v = 0; v < K; v++) {
item = shoppingList[v];
if (!hasVisited(visited, item)) {
memo.get(source).put(visited, Math.min(
memo.get(source).get(visited),
sssp.get(source).get(item) + TSP(item, visit(visited, v))
));
}
}
return memo.get(source).get(visited);
}
}
int dijkstra(int src, int dest) {
PriorityQueue<IntegerPair> PQ = new PriorityQueue<IntegerPair>();
HashMap<Integer, Integer> dist = new HashMap<Integer, Integer>(); // shortest known dist from {src} to {node}
// init shortest known distance
for (int i = 0; i < N+1; i++) {
if (i != src) {
dist.put(i, Integer.MAX_VALUE); // dist to any {i} is big(unknown) by default
} else {
dist.put(src, 0); // dist to {src} is always 0
}
}
IntegerPair node;
int nodeDist;
int nodeIndex;
PQ.offer(new IntegerPair(0, src));
while (PQ.size() > 0) {
node = PQ.poll();
nodeDist = node.first();
nodeIndex = node.second();
if (nodeDist == dist.get(nodeIndex)) {
// process out going edges
for (int v = 0; v < N+1; v++) { // since its a complete graph, process all edges
if (v != nodeIndex) { // except curr node
if (dist.get(v) > dist.get(nodeIndex) + T[nodeIndex][v]) { // relax if possible
dist.put(v, dist.get(nodeIndex) + T[nodeIndex][v]);
PQ.offer(new IntegerPair(dist.get(v), v));
}
}
}
}
}
return dist.get(dest);
}
visited is used as a bitmask to indicate if a node has been visited
sssp is a HashMap<Integer, HashMap<Integer, Integer>> where the 1st hashmap's key is the source node and the key for 2nd hashmap is the destination. So it basically represent the 2D table u see in point 1.
memo is just what I used in dynamic programming as a "cache" of previously computed shortest path from a node, given a visited bitmap.
Full source: http://pastie.org/5171509
The test case that passes:
1
3 3
1 2 3
0 20 51 35
20 0 30 34
51 30 0 12
35 34 12 0
Where 1st line is the number of test cases. 3rd line (3 3). The 1st 3 is the number of nodes, 2nd 3 is the number of required nodes. 4th line is the list of required nodes. Then the rest is the table of edge weights.
The test case that fails is:
9 9
1 2 3 4 5 6 7 8 9
0 42 360 335 188 170 725 479 359 206
42 0 402 377 146 212 767 521 401 248
360 402 0 573 548 190 392 488 490 154
335 377 573 0 293 383 422 717 683 419
188 146 548 293 0 358 715 667 539 394
170 212 190 383 358 0 582 370 300 36
725 767 392 422 715 582 0 880 704 546
479 521 488 717 667 370 880 0 323 334
359 401 490 683 539 300 704 323 0 336
206 248 154 419 394 36 546 334 336 0
I got 3995 but the answer is 2537... sorry I know this is hard to debug ... I am having the same problem, the test case is too large ... at least for humans ... so I am creating smaller test case to test but they seem to pass ...

Answer 1

Perhaps not a full answer but I think it's at least pointing in the right direction: your code seems to give the results of following the paths 0->1->2->...->N->0. No real optimization seems to happen.
I reworked your code a bit to get a small failing test case:
int[][]mat=new int[N+1][N+1];
//original
//mat[0]=new int[]{0,20,51,35};
//mat[1]=new int[]{20,0,30,34};
//mat[2]=new int[]{51,30,0,12};
//mat[3]=new int[]{35,34,12,0};
//switched order of nodes, node 2 is now node 1
mat[0]=new int[]{0,51,20,35};
mat[1]=new int[]{51,0,30,12};
mat[2]=new int[]{20,30,0,34};
mat[3]=new int[]{35,12,34,0};
This produces 146 as a best path, showing that it follows the path 0->1->2->3->0 (47+30+34+35, 47 is the shortest path 0 to 1 using node 4) (all node numbers are with my order switch).
edit: I found the culprit after another quick look. You have the line if (!hasVisited(visited, item)) to check if you already visited node item. However, visited is built up by visit(visited, v), in which v is an index into the shoppinglist. item =shoppinglist[v] but you should use the same if you're shifting your visited vector.
You should use if (!hasVisited(visited, v)) instead of if (!hasVisited(visited, item))
On an unrelated note, I'm unsure if the first step of finding the shortest paths is necessary or could influence your results. If a direct link from A to B is longer than going through other nodes (say C), then it is replaced in the distance table. If you would then use that link in your final solution to go from A to B, then you would actually be going via C, which would already be in your path (since that path is a full TSP solution). If a node can only be visited once, then this might be a problem.