UVA116Unidirectional TSP（DP+逆推）

http://acm.hust.edu.cn/vjudge/problem/viewProblem.action?id=18206

题意:M*N的数阵，从左边一列到右边一列走过的数的和的最小。并输出路径和最小值，每一个数能右上，右，右下三种决策，第一行右上是第m行，第m行右下是第1行。

dp【i】【j】存i行j列到最后一列的和的最小，然后逆推，输出路径，就从第一列找最小的dp，然后减去这个数，找右上，右，右下相等的dp，同时行数还得是最小的，思路还是很好想的。做的就是有点麻烦

 #include <iostream>
 #include <cstring>
 #include <algorithm>
 #include <cstdio>
 using namespace std;
 const int INF = 0x3f3f3f3f;
 int a[][],dp[][];
 int main()
 {
     int n,m;
     while(scanf("%d%d", &m, &n) != EOF)
     {
         memset(a, INF, sizeof(a));
         for(int i = ; i <= m; i++)
         {
             for(int j = ; j <= n; j++)
             {
                 scanf("%d", &a[i][j]);
             }
         }

         memset(dp, INF, sizeof(dp));
         for(int i = ; i <= m; i++)
             dp[i][n] = a[i][n];

         for(int j = n - ; j >= ; j--)
         {
             for(int i = ; i <= m; i++)
             {
                 if(i == )
                 {
                     dp[i][j] = min(dp[i][j], a[i][j] + dp[m][j + ]);
                     dp[i][j] = min(dp[i][j], a[i][j] + dp[i][j + ]);
                     dp[i][j] = min(dp[i][j], a[i][j] + dp[i + ][j + ]);
                 }
                 else if(i == m)
                 {
                     dp[i][j] = min(dp[i][j], a[i][j] + dp[i - ][j + ]);
                     dp[i][j] = min(dp[i][j], a[i][j] + dp[i][j + ]);
                     dp[i][j] = min(dp[i][j], a[i][j] + dp[][j + ]);
                 }
                 else
                 {
                     dp[i][j] = min(dp[i][j], a[i][j] + dp[i - ][j + ]);
                     dp[i][j] = min(dp[i][j], a[i][j] + dp[i][j + ]);
                     dp[i][j] = min(dp[i][j], a[i][j] + dp[i + ][j + ]);
                 }
             }
         }

         int start;
         int ans = INF;
         for(int i = ; i <= m; i++)
         {
             if(ans > dp[i][])
             {
                 ans = dp[i][];
                 start = i;
             }
         }

         for(int j = ; j <= n; j++)
         {
             printf("%d ",start);
             int minn = INF;
             if(start == )
             {
                 if(dp[start][j - ] - a[start][j - ] == dp[m][j])
                 {
                     minn = min(m, minn);
                 }
                 if(dp[start][j - ] - a[start][j - ] == dp[start][j])
                 {
                     minn = min(start, minn);
                 }
                 if(dp[start][j - ] - a[start][j - ] == dp[start + ][j])
                 {
                     minn = min(start + , minn);
                 }
                 start = minn;
                 continue;
             }
             else if(start == m)
             {
                 if(dp[start][j - ] - a[start][j - ] == dp[start - ][j])
                     minn = min(minn, start - );
                 if(dp[start][j - ] - a[start][j - ] == dp[start][j])
                     minn = min(minn, start);
                 if(dp[start][j - ] - a[start][j - ] == dp[][j])
                     minn = min(minn, );
                 start = minn;
                 continue;
             }
             else
             {
                 if(dp[start][j - ] - a[start][j - ] == dp[start - ][j])
                     minn = min(minn, start - );
                 if(dp[start][j - ] - a[start][j - ] == dp[start][j])
                    minn = min(minn, start);
                 if(dp[start][j - ] - a[start][j - ] == dp[start + ][j])
                     minn = min(minn, start + );
                 start = minn;
                 continue;
             }
         }
         printf("%d\n%d\n",start,ans);
     }
     return ;
 }