UVa 1631 Locker

原创于 2025-11-24 08:18:32 发布 · 1.1k 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #青少年编程

动态规划专栏收录该内容

137 篇文章

订阅专栏

题目描述

有一个密码锁，包含 $N$ 位数字，每位数字可以循环旋转到 $0$ - $9$ 。每次操作可以旋转 $1$ - $3$ 个连续数字向上或向下。

例如：

$\rightarrow 567901$ （将最后 $3$ 位向上旋转）
$\rightarrow 000900$ （将第 $4$ 位向下旋转）

给定当前状态和秘密密码，求从当前状态转到秘密密码所需的最少步数。

输入格式

多个测试用例（少于 $50$ 个）
每个用例两个等长字符串（长度 $≤1000\leq 1000$ ），表示当前状态和秘密密码

输出格式

每个用例输出一个整数，表示最少步数

题目分析

这是一个典型的动态规划问题，需要找到从初始状态转换到目标状态的最少操作次数。问题的难点在于：

操作特性：每次可以旋转 $1$ - $3$ 个连续数字
循环特性：数字旋转是循环的， $0$ 向下变成 $9$ ， $9$ 向上变成 $0$
操作影响：旋转操作会影响多个位置，需要协调处理

解题思路

状态设计

我们使用三维动态规划数组：

$d p [i] [x] [y]$ 表示处理完前 $i$ 位数字，且第 $i + 1$ 位当前值为 $x$ ，第 $i + 2$ 位当前值为 $y$ 时的最小步数

状态转移

对于每个位置 $i$ ，我们需要将当前位调整到目标值。有两种旋转方向：

向上旋转：旋转步数为 $\% 10$
向下旋转：旋转步数为 $\% 10$

在旋转当前位时，可以同时旋转后面的 $1$ - $3$ 位。关键约束是：旋转次数必须递减，即第 $i + 1$ 位的旋转次数 $≤\leq$ 当前位的旋转次数，第 $i + 2$ 位的旋转次数 $≤\leq$ 第 $i + 1$ 位的旋转次数。

算法流程

初始化 $d p [0] [or i g in [0]] [or i g in [1]] = 0$ ，其他状态为无穷大
对于每个位置 $i$ ，枚举所有可能的 $(x, y)$ 状态
对于每个状态，分别计算向上和向下旋转的步数
枚举后续位置的旋转次数，更新下一状态
最终答案为 $d p [n] [0] [0]$ ，表示所有位都处理完成

时间复杂度

状态数为 $\times 10 \times 10) = O(100n)$ ，每个状态转移需要 $\times 10)$ 次操作，总时间复杂度为 $O (10000 n)$ ，对于 $\leq 1000$ 可以接受。

代码实现

// Locker
// UVa ID: 1631
// Verdict: Accepted
// Submission Date: 2025-11-23
// UVa Run Time: 0.030s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>
using namespace std;

const int INF = 0x3f3f3f3f;
int dp[1005][10][10];
int origin[1005], target[1005];

int main() {
    string s1, s2;
    while (cin >> s1 >> s2) {
        int n = s1.length();
        for (int i = 0; i < n; i++) {
            origin[i] = s1[i] - '0';
            target[i] = s2[i] - '0';
        }
        
        memset(dp, 0x3f, sizeof(dp));
        dp[0][origin[0]][origin[1]] = 0;
        
        for (int i = 0; i < n; i++) {
            for (int x = 0; x < 10; x++) {
                for (int y = 0; y < 10; y++) {
                    if (dp[i][x][y] == INF) continue;
                    
                    int up = (target[i] - x + 10) % 10;
                    int down = (10 - up) % 10;
                    
                    // 向上旋转
                    for (int j = 0; j <= up; j++) {
                        for (int k = 0; k <= j; k++) {
                            int nx = (i + 1 < n) ? (y + j) % 10 : 0;
                            int ny = (i + 2 < n) ? (origin[i + 2] + k) % 10 : 0;
                            dp[i + 1][nx][ny] = min(dp[i + 1][nx][ny], dp[i][x][y] + up);
                        }
                    }
                    
                    // 向下旋转  
                    for (int j = 0; j <= down; j++) {
                        for (int k = 0; k <= j; k++) {
                            int nx = (i + 1 < n) ? (y - j + 10) % 10 : 0;
                            int ny = (i + 2 < n) ? (origin[i + 2] - k + 10) % 10 : 0;
                            dp[i + 1][nx][ny] = min(dp[i + 1][nx][ny], dp[i][x][y] + down);
                        }
                    }
                }
            }
        }
        
        cout << dp[n][0][0] << endl;
    }
    return 0;
}