这道题目其实就是一个裸的 Dijkstra D i j k s t r a ,但我在这里讲一下DP怎么求解
dp[i][j]
d
p
[
i
]
[
j
]
表示第
i
i
行第列的最小值
dp[i][j]=min(dp[i−1][j],dp[i][j±1])
d
p
[
i
]
[
j
]
=
m
i
n
(
d
p
[
i
−
1
]
[
j
]
,
d
p
[
i
]
[
j
±
1
]
)
这个转移出现环,不可行
改进:
我们发现对于
dp[i][j]
d
p
[
i
]
[
j
]
,在一次循环中,他只有可能被一个方向的dp更新(另一个方向只会比他大)
例如:当j从2枚举到
n
n
时 只会被
dp[i−1][j]
d
p
[
i
−
1
]
[
j
]
和
dp[i][j−1]
d
p
[
i
]
[
j
−
1
]
更新
当j从
n−1
n
−
1
枚举到1时
dp[i][j]
d
p
[
i
]
[
j
]
只会被
dp[i−1][j]
d
p
[
i
−
1
]
[
j
]
和
dp[i][j+1]
d
p
[
i
]
[
j
+
1
]
更新
提炼出
dp[i−1][j]
d
p
[
i
−
1
]
[
j
]
,即可得到转移方法:
dp[i][j]=
d
p
[
i
]
[
j
]
=
{
dp[i−1][j];
d
p
[
i
−
1
]
[
j
]
;
for(j=2−>n)min(dp[i][j−1])
f
o
r
(
j
=
2
−
>
n
)
m
i
n
(
d
p
[
i
]
[
j
−
1
]
)
for(j=n−1−>1)min(dp[i][j−1])
f
o
r
(
j
=
n
−
1
−
>
1
)
m
i
n
(
d
p
[
i
]
[
j
−
1
]
)
}
这个转移不会出现环,可行,时间复杂度
O(n2)
O
(
n
2
)
code:
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int M, N, cost[105][505];
long long dp[105][505];
int path[105*505];
int DP() {
for (int i = 1; i <= N; ++i) {
dp[1][i] = cost[1][i];
path[N+i] = 0;
}
for (int i = 2; i <= M; ++i) {
for (int j = 1; j <= N; ++j) {
dp[i][j] = dp[i-1][j] + cost[i][j];
path[i*N+j] = (i-1)*N+j;
}
for (int j = 2; j <= N; ++j) {
if (dp[i][j] > dp[i][j-1] + cost[i][j]) {
dp[i][j] = dp[i][j-1] + cost[i][j];
path[i*N+j] = i*N+j-1;
}
}
for (int j = N-1; j >= 1; --j) {
if (dp[i][j] > dp[i][j+1] + cost[i][j]) {
dp[i][j] = dp[i][j+1] + cost[i][j];
path[i*N+j] = i*N+j+1;
}
}
}
int Min = dp[M][1], end = 1;
for (int i = 2; i <= N; ++i) {
if (Min > dp[M][i]) {
Min = dp[M][i];
end = i;
}
}
return M*N+end;
}
void output(int x) {
if (path[x]) {
output(path[x]);
}
if (x % N != 0) {
printf("%d ", x-N*(x/N)); //如果是提交POJ或Open_Bailian的请把' '->\n
}
else {
printf("%d ", N); //如果是提交POJ或Open_Bailian的请把' '->\n
}
}
int main() {
int pos;
while (scanf("%d %d", &M, &N) == 2) {
for (int i = 1; i <= M; ++i) {
for (int j = 1; j <= N; ++j) {
scanf("%d", &cost[i][j]);
}
}
pos = DP();
output(pos);
}
return 0;
}