BZOJ #2144 跳跳棋 （lca和gcd的模型转化和完美结合）

题目描述：

在数轴上有三个棋子，初始时位置为$x,y,z$，要求用最少的操作步数让位置变成$a,b,c$。每次操作可以任选一颗棋子，以另一个棋子为中轴跳动，跳动后距离不边，且每次只能跳过一颗棋子。

解题思路：

因为有限制，两边只有一颗棋子能跨过中间跳，而中间的棋子就可以往两边跳。如果注意观察的话，会发现往两边跳和往中间跳是互逆的。所以我们把状态连接起来是一棵树，而题目要求的就是始末状态在树上的距离。但如果每次暴力往上跳的话，时间复杂度会爆炸。再仔细观察的话，还会发现设中间棋子与两边棋子的距离为$(l,r)$的话，假设$l>r$，那么每次往上跳就会变成$(l-r,r)$，而这与求$gcd$的过程类似，所以我们就可以$log$地求出一个点的祖先。外面二分深度，就能求出$lca$。

代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int inf = 1e9;
int x, y, z, len1, len2, len;

struct sta {
    int x, y, z;
    sta(int _x = 0, int _y = 0, int _z = 0) {x = _x, y = _y, z = _z;}
    void sort() {
        if (y < x) swap(x, y);
        if (z < x) swap(x, z);
        if (z < y) swap(z, y);
    }
} st, en, s, e;

int equal(sta a, sta b) {
    if (a.x != b.x || a.y != b.y || a.z != b.z) return 0;
    return 1;
}

sta find(sta now, int r, int &len) {
    int k = 0;
    for (len = 0; r; len += k) {
        int a = now.y - now.x, b = now.z - now.y;
        if (a == b) return now;
        if (a > b) {
            k = min((a - 1) / b, r);
            r -= k;
            now.y -= k * b, now.z -= k * b;
        }
        if (a < b) {
            k = min((b - 1) / a, r);
            r -= k;
            now.x += k * a, now.y += k * a; 
        }
    }
    return now;
}

void divide() {
    st = find(st, len1 - len2, len);
    int l = 0, r = len2;
    while (l < r) {
        int m = l + r >> 1;
        if (equal(find(st, m, len), find(en, m, len))) r = m; else l = m + 1;
    }
    printf("%d", l * 2 + len1 - len2);
}

int main() {
    scanf("%d %d %d", &x, &y, &z);
    st = sta(x, y, z), st.sort();
    scanf("%d %d %d", &x, &y, &z);
    en = sta(x, y, z), en.sort();
    s = find(st, inf, len1);
    e = find(en, inf, len2);
    if (!equal(s, e)) {
        printf("NO\n");
        return 0;
    }
    printf("YES\n");
    if (len1 < len2) swap(st, en), swap(len1, len2);
    divide();
    return 0;
}