HDOJ 4433 Locker (数位DP)

题意，给一个密码锁的初始状态和目标状态，每次可以将连续的 1 - 3 位向上或者向下挪一位，问达到目标状态最少需要多少次。

参考了网上的题解。。。

dp[i][x][y] 表示 在第 i-1 位是 x 第 i 位是 y 的情况下，把前 i 位弄好需要的步数。

想要转移的话，很有可能会把状态定义为“前 i 位 blablabla”。

于是，从后往前推，容易证明，想把第 i 位弄对，要么只正转，要么只反转。

这两种都有可能对其前两位产生影响，显然，假设第 i 位转了 k 次，那么 i-1 位转了 k1 次（k1 小于等于 k），第 i-2 位转了 k2 次（k2 小于等于 k1）

于是相当于枚举 dp[i-1][y1][y2] 中的 y1 和 y2。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 1010, inf = 0x3f3f3f3f;

char ac[maxn], bc[maxn];
int a[maxn], b[maxn];
int dp[maxn][10][10];

int main()
{
while(~scanf("%s%s", ac, bc)) {
memset(dp, 0x3f, sizeof(dp));
int len = strlen(ac);
for(int i = 0; i < len; i++) {
a[i] = ac[i]-'0';
b[i] = bc[i]-'0';
}
for(int i = 0; i < 10; i++) {
if(i == b[0])
for(int j = 0; j < 10; j++)
dp[0][j][i] = 0;
else {
for(int j = 0; j < 10; j++) {
dp[0][j][i] = (i-b[0]+10)%10;
dp[0][j][i] = min(dp[0][j][i], 10-dp[0][j][i]);
}
}
}
for(int i = 0; i < 10; i++) {
if(i == b[1]) {
for(int j = 0; j < 10; j++) {
dp[1][j][i] = dp[0][0][j];
}
}
else {
int up = (b[1] - i + 10) % 10;
int dn = 10 - up;
for(int j = 0; j < 10; j++) {
dp[1][j][i] = min(up, dn) + dp[0][0][j];
for(int k = 0; k <= up; k++)
dp[1][j][i] = min(dp[1][j][i], up+dp[0][0][(j+k)%10]);
for(int k = 0; k <= dn; k++)
dp[1][j][i] = min(dp[1][j][i], dn+dp[0][0][(j-k+10)%10]);
}
}
}
for(int i = 2; i < len; i++) {
for(int j = 0; j < 10; j++) {
if(j == b[i]) {
for(int k = 0; k < 10; k++) {
dp[i][k][j] = dp[i-1][a[i-2]][k];
}
}
else {
int up = (b[i] - j + 10) % 10;
int dn = 10 - up;
for(int k = 0; k < 10; k++) {
dp[i][k][j] = min(up, dn) + dp[i-1][a[i-2]][k];
for(int p = 0; p <= up; p++) {
for(int q = 0; q <= p; q++) {
dp[i][k][j] = min(dp[i][k][j], up+dp[i-1][(a[i-2]+q)%10][(k+p)%10]);
}
}
for(int p = 0; p <= dn; p++) {
for(int q = 0; q <= p; q++) {
dp[i][k][j] = min(dp[i][k][j], dn+dp[i-1][(a[i-2]-q+10)%10][(k-p+10)%10]);
}
}
}
}
}
}
printf("%d\n", dp[len-1][a[len-2]][a[len-1]]);
}

return 0;
}


这篇和上一篇都是赶工赶出来的。。。。。。
以后写完题立刻写题解，不要拖啊。。。。。。