UVa 10795 A Different Task

题目分析

问题描述

这是一个经典的三柱汉诺塔问题的变种。在标准的汉诺塔问题中，所有盘子初始都在 $\text{A}$ 柱上，目标是将所有盘子移动到 $\text{C}$ 柱上，移动过程中需要遵守以下规则：

1. 每次只能移动一个盘子
2. 任何时候大盘子都不能放在小盘子上面

本题的变种在于：

• 初始状态和目标状态中，每个盘子可以在任意柱子上（$\text{A}$、$\text{B}$ 或 $\text{C}$）
• 两种状态都保证每个柱子上的盘子从上到下是递减排列的
• 需要求出从初始状态变换到目标状态所需的最小移动步数

关键思路

解决这个问题的核心思想是递归分解和对称处理。

1. 基础汉诺塔分析

对于标准的汉诺塔问题（$n$ 个盘子从 $\text{A}$ 移到 $\text{C}$），最小步数为 $2^n-1$。其递归解法为：

• 将上面 $n-1$ 个盘子从 $\text{A}$ 移到 $\text{B}$（借助 $\text{C}$）
• 将第 $n$ 个盘子从 $\text{A}$ 移到 $\text{C}$
• 将 $n-1$ 个盘子从 $\text{B}$ 移到 $\text{C}$（借助 $\text{A}$）

2. 本题的特殊处理

对于任意初始和目标状态，我们需要找到一种高效的计算方法：

关键观察：从最大的盘子开始考虑（编号从 $1$ 到 $n$，$1$ 最小，$n$ 最大）

• 如果某个盘子 $k$ 在初始状态和目标状态中处于同一柱子，那么它不需要移动
• 我们只需要找到最大的需要移动的盘子 $k$
• 在移动盘子 $k$ 之前，需要把上面所有的 $k-1$ 个盘子移到第三根柱子（既不是初始位置也不是目标位置的柱子）

3. 递归函数设计

定义函数 $solve(P,n,target)$：

• 表示将状态 $P$ 中最大的 $n$ 个盘子全部移动到 $target$ 柱子所需的最小步数
• 递归计算：
  • 如果盘子 $n$ 已经在目标柱子上：$solve(P,n-1,target)$
  • 否则：需要先把上面 $n-1$ 个盘子移到第三根柱子 $\text{other}$，步数为 $solve(P,n-1,other)$，然后移动第 $n$ 个盘子，这总共需要 $solve(P,n-1,other)+2^{n-1}$ 步

4. 最终答案计算

找到最大的 $k$ 使得 $start[k]\ne target[k]$：

• 如果找不到这样的 $k$，说明初始状态就是目标状态，答案为 $0$
• 否则，计算第三根柱子 $other=6-start[k]-target[k]$（因为 $1+2+3=6$）
• 最终答案 = $solve(start,k-1,other)+1+solve(target,k-1,other)$

算法复杂度

• 时间复杂度：$O(N)$，每个盘子最多处理一次
• 空间复杂度：$O(N)$，用于存储状态数组

代码实现

// A Different Task
// UVa ID: 10795
// Verdict: Accepted
// Submission Date: 2025-10-17
// UVa Run Time: 0.000s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <iostream>
#include <vector>
using namespace std;

typedef long long ll;

// 递归函数：将P状态中最大的n个盘子全部移动到target柱子所需的最小步数
ll solve(const vector<int>& P, int n, int target) {
    if (n == 0) return 0;  // 没有盘子需要移动
    if (P[n] == target) {
        // 当前盘子已经在目标柱子上，只需处理上面的n-1个盘子
        return solve(P, n - 1, target);
    } else {
        // 计算第三根柱子（既不是当前所在也不是目标柱子）
        int other = 6 - P[n] - target;
        // 先把上面的n-1个盘子移到other柱子，然后移动当前盘子
        // 移动n-1个盘子需要2^(n-1)-1步，加上移动当前盘子的1步
        return solve(P, n - 1, other) + (1LL << (n - 1));
    }
}

int main() {
    int N, caseNum = 1;
    while (cin >> N && N != 0) {
        vector<int> start(N + 1), target(N + 1);
        // 读入初始状态，start[i]表示第i个盘子的初始位置
        for (int i = 1; i <= N; i++) cin >> start[i];
        // 读入目标状态，target[i]表示第i个盘子的目标位置
        for (int i = 1; i <= N; i++) cin >> target[i];
        
        // 从最大的盘子开始找，找到第一个需要移动的盘子
        int k = N;
        while (k >= 1 && start[k] == target[k]) k--;
        
        ll ans = 0;
        if (k >= 1) {
            // 计算第三根柱子
            int other = 6 - start[k] - target[k];
            // 计算总步数
            ans = solve(start, k - 1, other) + 1 + solve(target, k - 1, other);
        }
        cout << "Case " << caseNum++ << ": " << ans << endl;
    }
    return 0;
}

样例分析

样例1

输入：
3
1 1 1
2 2 2
输出：
Case 1: 7

分析：所有盘子从 $\text{A}$ 移到 $\text{B}$，就是标准的汉诺塔问题，$2^3-1=7$ 步。

样例2

输入：
3
1 2 3
3 2 1
输出：
Case 2: 3

分析：只有盘子 $1$ 和 $3$ 需要移动，共 $3$ 步。

样例3

输入：
4
1 1 1 1
1 1 1 1
输出：
Case 3: 0

分析：初始状态就是目标状态，不需要移动。

总结

本题通过递归分解和对称处理的方法，将复杂的任意状态转换问题转化为经典的汉诺塔子问题。关键思路是从最大的盘子开始处理，利用汉诺塔问题的经典性质来高效计算最小步数。算法的时间复杂度为 $O(N)$，能够高效处理 $N\le 60$ 的情况。