HDU-1619 Unidirectional TSP dp

大致题意：

从左到右寻找最短路径，按字典序输出路径以及路径长。

思路：

从右往左每两列一看，计算局部最优解，记录在数组dp中；

例：

5行6列的Map

3 4 1 2 8 6

6 1 8 2 7 4

5 9 3 9 9 5

8 4 1 3 2 6

3 7 2 8 6 4

对应dp

一：

0 0 0 0 0 6

0 0 0 0 0 4

0 0 0 0 0 5

0 0 0 0 0 6

0 0 0 0 0 4

二：

0 0 0 0 12 6

0 0 0 0 11 4

0 0 0 0 13 5

0 0 0 0 6 6

0 0 0 0 10 4

这里的12是4 6 4三者最小(4)加上Map对应位置元素值(8)

这里的11是6 4 5三者最小(4)加上Map对应位置元素值(7)

…

这里的10是6 4 6三者最小(4)加上Map对应位置元素值(6)

不难看出，dp中存储每两列的局部最优解，然后我们可以把这两列看成一列，同样地做法往前递推，即可得到整个Map的最优解，也就是dp第一列中最小的元素

写出状态转移方程：

dp[i][j] = mm + map[i][j]

mm为dp[i][j]向右所指的三个子元素的最小值

一般情况为dp[i-1][j+1], dp[i][j+1], dp[i+1][j+1]

特别考虑i = 1和i = m的情况

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
#define MAX 102
using namespace std;

int map[MAX][MAX];
int dp[MAX][MAX];

int main()
{
#ifndef ONLINE_JUDGE
freopen("in.txt","r",stdin);
#endif

int m, n;
int i, j;
int mm, ans, route;
//mm记录dp向右所指三个子元素的最小值
//ans记录最短路径长
//route标记路径

while(~scanf("%d%d", &m, &n))
{
memset(map, 0, sizeof(map));
memset(dp, 0, sizeof(dp));

//输入map
for(i = 1; i <= m; i++)
for(j = 1; j <= n; j++)
scanf("%d", &map[i][j]);

//计算mm, dp, 从右往左按列递推
for(j = n; j >= 1; j--)
for(i = 1; i <= m; i++)
{
if(i == 1)
mm = min( min(dp[m][j+1], dp[1][j+1]), dp[2][j+1] );

else if(i == m)
mm = min( min(dp[m-1][j+1], dp[m][j+1]), dp[1][j+1] );

else
mm = min( min(dp[i-1][j+1], dp[i][j+1]), dp[i+1][j+1] );

//状态转移方程
dp[i][j] = mm + map[i][j];
}

//1<<30意思是开了一个很大的数
ans = 1<<30;

//找dp第一列最小元素，即最短路径长，并标记位置route
for(i = 1; i <= m; i++)
if(dp[i][1] < ans)
{
ans = dp[i][1];
route = i;
}

printf("%d", route);

//寻找子route(从左往右根据dp三个子元素的最小确定)
for(j = 2; j <= n; j++)
{

if(route == 1)
{
if(dp[1][j] <= dp[m][j] && dp[1][j] <= dp[2][j])
{
route = 1;
printf(" %d", route);
}
else if(dp[2][j] <= dp[m][j] && dp[2][j] <= dp[1][j])
{
route = 2;
printf(" %d", route);
}
else
{
route = m;
printf(" %d", route);
}
}

else if(route == m)
{
if(dp[1][j] <= dp[m][j] && dp[1][j] <= dp[m-1][j])
{
route = 1;
printf(" %d", route);
}
else if(dp[m-1][j] <= dp[m][j] && dp[m-1][j] <= dp[1][j])
{
route = m-1;
printf(" %d", route);
}
else
{
route = m;
printf(" %d", route);
}
}

else
if(dp[route-1][j] <= dp[route][j] && dp[route-1][j] <= dp[route+1][j])
{
route = route-1;
printf(" %d", route);
}
else if(dp[route][j] <= dp[route-1][j] && dp[route][j] <= dp[route+1][j])
printf(" %d", route);
else
{
route = route+1;
printf(" %d", route);
}
}
printf("\n%d\n", ans);

}

return 0;
}

缺点及改进：

代码段过于冗长，最好把各个重复的功能段独立成功能函数，简化代码。

最后输出路径的方法不太好，可以在计算dp的时候直接计算路径。

例：http://blog.csdn.net/z309241990/article/details/8617785

不过我感觉效率上面不差太多，我这样写还更好懂一些。

小结：

dp算法，关键代码就一两行，然而要弄懂整个流程并不容易，这题还算一道简单dp，希望能再熟练学习，更好运用。