Polynomial-time algorithm for travelling salesman in a grid

Question

I have read that the classic travelling salesman problem (TSP) is NP-Hard. And there are some approximation algorithms and also a specific algorithm running in O(N^2 * 2^N) time. But AFAIK, these are for TSP in a general graph.

So my question, is there a better (preferable polynomial time) algorithm for solving the TSP in a M x N grid?

For example, say there's a grid of 3x4 and there are different costs of travelling from one cell to each of the 2 adjacent (bottom and right) cells. So I want to find the minimum cost to visit all the cells, starting from cell (0, 0) and returning to cell (0, 0).

EDIT: Just to clear things up, I'm pretty sure this not an Euclidean TSP. For simplicity, think of the below example. A rectangle is divided in to M rows and N columns. The salesman is at cell 0, 0 (the top-left cell). He has to visit all the cells and still come back to his starting cell (0, 0). But he can only travel from one cell to each of its 4 adjacent cells (top, left, bottom, right). And the cost from one cell to any one of its adjacent cells may not be the same.

Thanks.

Answer 1

With unit grid weights and no holes, there is no known polynomial-time algorithm but no known NP-hardness proof either.

With holes, it's NP-hard. ("Hamilton paths in grid graphs"; Itai, Papadimitriou, and Szwarcfiter; 1982.)

With no holes but arbitrary grid weights, there is a trivial reduction from the previous case, where we take an arbitrary grid and fill in the holes with edges so heavy that each one weighs more than the original edges combined, so this case is NP-hard as well. Since this is a special case of planar graph TSP, there's a linear-time approximation scheme due to my advisor, Philip Klein, but it's rather complicated. One of the pieces is a O(poly(m, n) exp(min(m, n)))-time dynamic program for solving TSP exactly in a graph of branchwidth min(m, n) (i.e., an m x n grid).

Answer 2

It is a very old post, but it seems that all answers are not accurate, so I will try to clear things up (mainly for future readers).

It is true (AFAIK) that there is no known polynomial solution to TSP when input is restricted to be a grid.

From here, to say the problem in NP-Hard - this jump is not justify and might be incorrect.

The fact that the degrees of nodes is greater than 2, makes the naive algorithm indeed to run in an exponential time complexity. As @Eyal Schneider mentioned, this doesn't prove it is NP-Hard.

Proving TSP in NP-Hard (from the method I know), is done using the fact that Hamiltonian-Path is NP-Hard. On grids graphs, Hamiltonian-Path is in P, hence the same method to prove it is NP-Hard won't work.

I provide here as well an example why the degree of each node is not necessarily a good indication if the problem is hard.

Take the TSP on the 2 layers grid graphs, all grid graphs of size 2 * n for some n. In this problem (which is easier the the general case of TSP on grids) the degree of all nodes (except for corner) is 3, which by most answers here means the naive algorithm time complexity will still be exponential with n (because there are O(n) nodes with degree greater than 2).

In fact, for 2 * n grids there are exactly 2 Hamiltonian paths (same circle in the opposite direction). Hence there exists a polynomial algorithm to solve TSP on 2 * n grids - check the 2 circles and return True if the minimum of them is lower than k (Given input of graph G and maximum value k).

For summary - there is no proof that TSP on grids is NP-Hard (AFAIK). There is also no any known polynomial algorithm to solve TSP on grids (AFAIK). As I see it, TSP on grids might be in NP-intermediate, but this class is a bit tricky, and it is quiet impossible to prove something is in NP-intermediate (it will be equivalent to prove P is not equal to NP).

Best,

Shahar

Answer 3

The complexity of TSP is due the number of possible routes between two nodes which is exponential.

A grid has a fixed node degree (every node has e.g. 4 neighbors), but the number of possible routes between two traveled nodes is still O(4^(M*N)) for an M*N grid with 4-neighbourship.

Algorithms may run faster on a grid, but the problem is still NP-hard.

EDIT: You could omit the paths where a vertex is visited and then the path goes right back to the last vertex since these paths are unnecessarily long. This means that there are always 3 possible neighbors to choose from (instead of 4). Thus the complexity can be expressed as O(3^(M*N)). This also corresponds to the brute force approach described in Vikrams answer.

Answer 4

The problem you are solving is still np hard as it gets reduced to TSP if you convert grid into graph and forget the you were ever solving it for the grid but you can solve this one using simple brute force in exponential time of O(3^(m*n)*(m*n)) which is preferable than the complex DP solution

Brute force solution to your problem in O(3^(m*n)*(m*n)) :

int mindist = infinity;

void GridTSP(int x,int y,int visited[][],int dist,int total,int n,int m) {

    if(total==n*m) {

          if(dist<mindist)
              mindist = dist;
    }

    else if(visited[x][y]) {

         return;
   }

   visited[x][y] = true;

   for each neighbour (a,b) of (x,y)  :
          GridTSP(a,b,visited,dist+cost(x,y,a,b),total+1,n,m);


   visited[x][y] = false;
}


GridTSP(0,0,new int[3][4],0,0,3,4);