uva116 unidirectional TSP

Background

Problems that require minimum paths through some domain appear in many
different areas of computer science. For example, one of the
constraints in VLSI routing problems is minimizing wire length. The
Traveling Salesperson Problem (TSP) – finding whether all the cities
in a salesperson’s route can be visited exactly once with a specified
limit on travel time – is one of the canonical examples of an
NP-complete problem; solutions appear to require an inordinate amount
of time to generate, but are simple to check.

This problem deals with finding a minimal path through a grid of
points while traveling only from left to right.

The Problem

Given an tex2html_wrap_inline352 matrix of integers, you are to write
a program that computes a path of minimal weight. A path starts
anywhere in column 1 (the first column) and consists of a sequence of
steps terminating in column n (the last column). A step consists of
traveling from column i to column i+1 in an adjacent (horizontal or
diagonal) row. The first and last rows (rows 1 and m) of a matrix are
considered adjacent, i.e., the matrix “wraps” so that it represents
a horizontal cylinder. Legal steps are illustrated below.

picture25

The weight of a path is the sum of the integers in each of the n cells
of the matrix that are visited.

For example, two slightly different tex2html_wrap_inline366 matrices
are shown below (the only difference is the numbers in the bottom
row).

picture37

The minimal path is illustrated for each matrix. Note that the path
for the matrix on the right takes advantage of the adjacency property
of the first and last rows.

The Input

The input consists of a sequence of matrix specifications. Each matrix
specification consists of the row and column dimensions in that order
on a line followed by tex2html_wrap_inline376 integers where m is the
row dimension and n is the column dimension. The integers appear in
the input in row major order, i.e., the first n integers constitute
the first row of the matrix, the second n integers constitute the
second row and so on. The integers on a line will be separated from
other integers by one or more spaces. Note: integers are not
restricted to being positive. There will be one or more matrix
specifications in an input file. Input is terminated by end-of-file.

For each specification the number of rows will be between 1 and 10
inclusive; the number of columns will be between 1 and 100 inclusive.
No path’s weight will exceed integer values representable using 30
bits.

The Output

Two lines should be output for each matrix specification in the input
file, the first line represents a minimal-weight path, and the second
line is the cost of a minimal path. The path consists of a sequence of
n integers (separated by one or more spaces) representing the rows
that constitute the minimal path. If there is more than one path of
minimal weight the path that is lexicographically smallest should be
output.

dp[i][j]表示第i列第j行到终点的最小距离。
dp[i][j]=min(dp[i+1][j],dp[i+1][j-1 (or n)],dp[i+1][j+1 (or 1)])+a[i][j]。
因为要输出路径，所以更新的时候用nxt记录“下一列的位置”。
因为要字典序，所以只能写逆推。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[110][15],dp[110][15],nxt[110][15],sta[110];
int main()
{
    int i,j,k,l,m,n,p,q,x,y,z,temp[3],top,ans;
    while (scanf("%d%d",&n,&m)==2)
    {
        memset(dp,0x42,sizeof(dp));
        memset(nxt,0,sizeof(nxt));
        for (i=1;i<=n;i++)
          for (j=1;j<=m;j++)
            scanf("%d",&a[j][i]);
        for (i=1;i<=n;i++)
          dp[m][i]=a[m][i];
        for (i=m-1;i>=1;i--)
          for (j=1;j<=n;j++)
          {
            temp[0]=j;
            temp[1]=j>1?j-1:n;
            temp[2]=j<n?j+1:1;
            sort(temp,temp+3);
            for (k=0;k<3;k++)
              if (dp[i+1][temp[k]]<dp[i][j])
              {
                dp[i][j]=dp[i+1][temp[k]];
                nxt[i][j]=temp[k];
              }
            dp[i][j]+=a[i][j];
          }
        p=1;
        ans=dp[1][1];
        for (i=2;i<=n;i++)
          if (dp[1][i]<dp[1][p])
            p=i,ans=dp[1][i];
        printf("%d",p);
        for (i=1;i<m;i++)
        {
            p=nxt[i][p];
            printf(" %d",p);
        }
        printf("\n%d\n",ans);
    }
}