计蒜客题解——T1257：哆啦A梦的时光机

题目相关

题目链接

计蒜客 OJ，https://nanti.jisuanke.com/t/T1257。

题目描述

哆啦A梦有一个神奇的道具：时光机。坐着它，大雄和他的伙伴们能穿越时空，回到过去或者去到未来。

有一天，大雄和他的伙伴们想穿越时空进行探险，可是时光机却出了一点故障，只能进行有限的时空穿越操作。大雄他们需要从现在出发，到达一个目标时间点进行探险，结束后再返回到现在，他们希望尽可能减少时光机的操作次数，你能帮助他们吗？

假设大雄和他的伙伴们出发的时间点（现在）为 S(0<S<1,000,000)，希望到达的时间点（目标）为 T(0<T<1,000,000)，已知时光机可以进行如下的时空穿越操作（X 为正整数）：

可以从任意时刻 X 穿越到 X+1 或者 X−1 时刻

可以从任意时刻 X 穿越到 X×2 时刻

当 X 为偶数时，可以从 X 时刻穿越到 X/2 时刻

请问，大雄和他的伙伴们从 S 时刻出发，先到达 T 时刻，再回到 S 时刻最少需要多少次时空穿越操作？

输入格式

输入的第一个数是一个正整数 N，表示测试数据一共有 N 组（0<N<20）。

之后有 N 行，每一行包含两个正整数 S 和 T，表示出发和到达时间点。S≠T。

输出格式

输出包括N行，每一行一个正整数，表示每组测试数据对应的最少时光机操作次数。

样例输入

2
5 17
4 8

样例输出

8
2

题目分析

题意分析

给定一个开始数据，然后按照下列规则，变成另外一个数据，最少需要几次：

规则1：数据 X 可以变为 X+1。

规则2：数据 X 可以变为 X-1。

规则3：数据 X 可以变为 2*X。

规则4：数据 X 如果是偶数，可以变为 X/2。

样例数据分析

我们就分析一组数据，我们选择 5 17 这组数据。问题就是从 5 开始，按照规则变成 17 需要最少几步。那么根据规则我们可以画出如下的一棵树：

从上图我们可以非常清晰的看出，从 5 变成 17，只需要 4 次。由于规则中有对称部分，规则 1 和规则 2 对称，规则 3 和规则 4 对称。因此 17 变为 5 也需要 4 次，这样输出答案为 8 次。

编程思路

从上图可以看出，这是一个典型的 BFS 题目，因为题目要求我们输出最小次数。因此我们可以写出一个大体框架。

1、读入数据。

2、从开始数据开始，进行 BFS 遍历，看到达结束数据需要几次。

技术细节

1、已知数据，如何按照规则变为下一个数据？

我比较傻，暂时没有想出统一代码，我就逐一编写规则。代码类似：

按照规则1，X+1，变化数据，并测试数据是否已经访问过。
按照规则2，X-1，变化数据，并测试数据是否已经访问过。
按照规则3，X*2，变化数据，并测试数据是否已经访问过。
按照规则4，如果是偶数，则X/2，变化数据，并测试数据是否已经访问过。

2、如何记录一个数据已经访问过？

第一次我想节约点空间，使用 unorderd_map 来记录访问性。定义方法如下：

unordered_map<int, bool> vis;

结果导致有 4 个样例超时，没有通过。主要 unorderd_map 内部是哈希表实现，相对比较耗时，导致了 TLE。

最后只要不考虑空间问题，直接定义如下：

const int MAXN = 1e6+2;
bool vis[MAXN];

AC 参考代码

#include <bits/stdc++.h>

using namespace std;

typedef struct _POS {
    int value;
    int dis;
} POS;

const int MAXN = 1e6+2;
bool vis[MAXN];

//从st点开始到ed点
int bfs(int st, int ed, int dis) {
    memset(vis, 0, sizeof(vis));//初始化vis不能少
    queue<POS> q;

    POS now, next;
    now.value = st;
    now.dis   = dis;
    q.push(now);
    vis[st] = true;

    while (false==q.empty()) {
        now = q.front();
        q.pop();

        //判断是否终点
        if (now.value==ed) {
            return now.dis*2;
        }

        //规则1
        next.value = now.value+1;
        if (next.value>0 && next.value<1000000 && false==vis[next.value]) {
            next.dis = now.dis+1;
            q.push(next);
            vis[next.value] = true;
        }

        //规则2
        next.value = now.value-1;
        if (next.value>0 && next.value<1000000 && false==vis[next.value]) {
            next.dis = now.dis+1;
            q.push(next);
            vis[next.value] = true;
        }

        //规则3
        next.value = now.value*2;
        if (next.value>0 && next.value<1000000 && false==vis[next.value]) {
            next.dis = now.dis+1;
            q.push(next);
            vis[next.value] = true;
        }

        //规则4//偶数
        if (0==now.value%2) {
            next.value = now.value/2;
            if (next.value>0 && next.value<1000000 && false==vis[next.value]) {
                next.dis = now.dis+1;
                q.push(next);
                vis[next.value] = true;
            }            
        }
    }

    return 0;
}

int main() {
    int n;
    cin >> n;

    for (int i=0; i<n; i++) {
        int s, t;
        cin>>s>>t;
        cout<<bfs(s, t, 0) << endl;
    }

    return 0;
}