【P1588】丢失的牛——区间dp/bfs

（题面来自Luogu）

题目描述

FJ丢失了他的一头牛，他决定追回他的牛。已知FJ和牛在一条直线上，初始位置分别为x和y，假定牛在原地不动。FJ的行走方式很特别：他每一次可以前进一步、后退一步或者直接走到2*x的位置。计算他至少需要几步追上他的牛。

输入格式

第一行为一个整数t(≤10)，表示数据组数；接下来每行包含一个两个正整数x和y(0<x,y≤10^5)，分别表示FJ和牛的坐标。

输出格式

对于每组数据，输出最少步数。

　　这个数据范围下bfs能过实在是很玄……（你以为你的dp能胜过我的bfs吗，jojo！）

　　由于这题第一次扫到某点得到的就是最优解，不需要重复遍历，bfs的复杂度是O(n)的。

bfs代码：

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
queue<int> q;
bool vis[100010];
int dis[100010];
int main() {
    ios::sync_with_stdio(0);
    int t, x, y;
    cin >> t;
    while (t--) {
        cin >> x >> y;
        if (x > y) {
            cout << x - y << endl;
            continue;
        }
        while (q.size()) q.pop();
        memset(vis, 0, sizeof(vis));
        q.push(x);
        dis[x] = 0;
        vis[x] = true;
        while (!q.empty()) {
            int k = q.front();
            q.pop();
            if (k == y) {
                cout << dis[k] << endl;
                break;
            }
            for (int i = 0; i <= 2; ++i) {
                int v;
                switch (i) {
                    case 0:
                        v = 2 * k;
                        break;
                    case 1:
                        v = k + 1;
                        break;
                    case 2:
                        v = k - 1;
                }
                if (vis[v] || !v || v > 100000) continue;
                dis[v] = dis[k] + 1;
                vis[v] = true;
                q.push(v);
            }
        }
    }
　return 0;
}

　　主要想谈一谈dp的做法。这题用区间dp的思路并不显然，写出来则非常优美。设f[i]表示到达点i的最短步数，边界状态f[x] = 0。容易想到，f[i]可以从如下状态递推而来：

　　f[i] = min(f[i - 1], f[i + 1]) + 1（i为奇数）

　　f[i] = min(f[i - 1], f[i + 1], f[i / 2]) + 1（i为偶数）

　　这就是f的状态转移方程。只要设计出转移阶段（顺序）进行转移，最终f[y]就是所求答案。这也是本题dp设计的难点，合适的顺序安排要保证用来更新f[i]的若干状态在使用时都已经达到了最优。

　　考虑到小于x的位置仅可能是从x倒退回来，那么我们可以先从f[x - 1]到f[1]倒着递推，有f[i] = f[i + 1] + 1。这样得到的每个f[i](i 属于 [1, x - 1])一定是最优解。同时，我们可以用每个f[i]更新一次f[2i]。接下来我们从f[x + 1]顺着递推到f[y]，此时的每个点i满足f[i] = min(f[i], f[i - 1] + 1, f[i + 1] + 1)。最后一个参数比较特殊，它表示要考虑f[i + 1]之前被某个i*2更新的情况。现在每个f[i]都已经是最优解，我们同样要用f[i]来更新f[2i]，为了避免特判，数组开两倍。

　　写到这里发现一个没有被卡掉的漏洞：由于没有拿f[x]来更新f[2x]，对于y = 2x的情况程序会给出由f[2x - 1]和f[2x + 1]更新出的错误答案，因此第二个循环应当从f[x]开始递推。

dp代码：（是不是短了很多呢）

#include <iostream>
#include <cstring>
using namespace std;
int f[200100];
int main() {
    int t, x, y;
    cin >> t;
    while (t--) {
        cin >> x >> y;
        memset(f, 0x3f, sizeof(f));
        f[x] = 0;
        for (int i = x - 1; i; --i) {
            f[i] = f[i + 1] + 1;
            f[i << 1] = min(f[i << 1], f[i] + 1);
        }
        for (int i = x; i <= y; ++i) {
            f[i] = min(f[i], min(f[i + 1] + 1, f[i - 1] + 1));
            f[i << 1] = min(f[i << 1], f[i] + 1);
        }
        cout << f[y] << endl;
    }
    return 0;
}