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;
}

这篇和上一篇都是赶工赶出来的。。。。。。

以后写完题立刻写题解，不要拖啊。。。。。。