UVa 1631 Locker （密码锁）

题目地址

Virtual Judge
UVa

题目做法

dp[i][j][k] 表示使得 i 及其之前的所有锁归位，i + 1 位置上向上转动 j 个单位，i + 2 位置上向上转动 k 个单位的最小步数
那么我们可以通过刷表法来完成 dp
首先我们枚举第 i 层 j 和 k，然后可以算出 i + 1 位还需要多少次操作才能归位。
然后枚举 i + 2 位的向上旋转次数，由于可以 1~3 位一起转动，所以 i + 2 和 i + 3 转动到比 i + 1 位少的步数的话是可以和 i + 1 共享部分步数的
我们可以计算出新的 i + 2 位的相对向上的移动量，然后刷表
这里向下旋转的步数要注意用 10- 来转化为向上旋转的步数，但在转移步数的时候还是应加上原始向下的步数
初始状态 dp[0][0][0] = 0 即没有任何旋转
终止状态 dp[len][0][0] 即 len 位都被旋转到指定数字的最小步数

代码

https://code.csdn.net/snippets/1888582

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define MAXN 1000
char s[MAXN + 5], t[MAXN + 5];
int dp[MAXN + 5][10][10];
int main() {
    while(scanf("%s%s", s + 1, t + 1) != EOF) {
        int len = strlen(s + 1);
        memset(dp, 0x3f, sizeof dp);
        dp[0][0][0] = 0;
        for(int i = 0; i < len; ++i)
            for(int j = 0; j <= 9; ++j)
                for(int k = 0; k <= 9; ++k) {
                    /** 向上旋转 */
                    int cnt = (t[i + 1] - (s[i + 1] + j) + 20) % 10;
                    for(int j1 = 0; j1 <= cnt; ++j1)
                        for(int k1 = 0; k1 <= j1; ++k1) {
                            int nj = (k + j1) % 10;
                            dp[i + 1][nj][k1] = min(dp[i + 1][nj][k1], dp[i][j][k] + cnt);
                        }
                    /** 向下旋转 */
                    cnt = (s[i + 1] + j - t[i + 1] + 10) % 10;
                    for(int j1 = 0; j1 <= cnt; ++j1)
                        for(int k1 = 0; k1 <= j1; ++k1) {
                            int nj = (k - j1 + 10) % 10; //注意要转换为向上旋转的步数，便于统一 | (10 - k1) 也是转化
                            dp[i + 1][nj][(10 - k1) % 10] = min(dp[i + 1][nj][(10 - k1) % 10], dp[i][j][k] + cnt);
                        }
                }
        printf("%d\n", dp[len][0][0]);
    }
}