HDU 3830 - Checkers(二分LCA)****

题目：

http://acm.hdu.edu.cn/showproblem.php?pid=3830

题意：

给出直线上三个点的初始位置，和最终位置，每次可以选择一个点经过另一个点等间隔跳跃，但是不能经过两个点。求出是否能从初始状态到达最终状态。能的话输出最小步数。

思路：

将一个状态作为一个点，建二叉树。其根为状态能到达的三点等距的状态。

若题目给出的初始位置和最终位置都能到达同一个初始状态，则有答案。二分求解两个状态的LCA，答案即深度。

否则没有答案。

详解：http://www.cnblogs.com/scau20110726/archive/2013/06/14/3135024.html

AC.

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>

using namespace std;
typedef long long ll;
struct Node {
    ll x, y, z;
    ll dep;
}s, t, rs, rt;

void init(Node &a)
{
    if(a.x > a.y) swap(a.x, a.y);
    if(a.x > a.z) swap(a.x, a.z);
    if(a.y > a.z) swap(a.y, a.z);
}

bool judge(Node a, Node b)
{
    if(a.x == b.x && a.y == b.y && a.z == b.z)
        return true;
    return false;
}
ll Abs(ll x)
{
    return x < 0? -x: x;
}
Node get_root(Node &a)
{
    ll lxy, lyz;
    Node r = a;
    r.dep = 0;
    ll dep = 0;

    while(Abs(r.y - r.x) != Abs(r.z - r.y)) {
        lxy = Abs(r.x - r.y); lyz = Abs(r.y - r.z);

        if(lxy > lyz) {
            ll c = (lxy-1)/lyz;
            dep += c;
            r.y -= c*lyz;
            r.z -= c*lyz;
        }
        else {
            ll c = (lyz - 1)/lxy;
            dep += c;
            r.x += c*lxy;
            r.y += c*lxy;
        }
    }
    a.dep = dep;
    return r;
}
void update(Node &a, ll cnd)
{
    ll cont = 0;
    ll lxy, lyz;
    while(cont < cnd) {
        lxy = Abs(a.x - a.y);
        lyz = Abs(a.y - a.z);
        ll tmp = Abs(cnd-cont);
        if(lxy > lyz) {
            ll c = (lxy - 1)/lyz;
            ll cc = min(c, tmp);
            a.y -= cc*lyz;
            a.z -= cc*lyz;
            a.dep -= cc;
            cont += cc;
        }
        else {
            ll c = (lyz - 1)/lxy;
            ll cc = min(c, tmp);
            a.x += cc*lxy;
            a.y += cc*lxy;
            a.dep -= cc;
            cont += cc;
        }
    }
}
ll solve()
{
    ll l = 0, r = s.dep;
    ll ans;
    Node ss, tt;
    while(l <= r) {
        ll mid = (l+r)/2;
        ll dep = s.dep - mid;
        ss = s; tt = t;
        update(ss, dep);
        update(tt, dep);
        if(!judge(ss, tt)) {
            r = mid - 1;
        }
        else l = mid+1;
    }
    return 2*(s.dep-r);
}
int main()
{
    //freopen("in", "r", stdin);
    while(~scanf("%I64d%I64d%I64d", &s.x, &s.y, &s.z)) {
        scanf("%I64d%I64d%I64d", &t.x, &t.y, &t.z);

        init(s);
        init(t);

        rs = get_root(s), rt = get_root(t);

        if(!judge(rs, rt)) {
            printf("NO\n");
            continue;
        }

        ll dep = abs(s.dep - t.dep);
        if(s.dep > t.dep) {
            update(s, dep);
        }
        else update(t, dep);

        ll ans = solve();
        printf("YES\n");
        printf("%I64d\n", ans+dep);
    }
    return 0;
}