HDU 3830 Checkers 2011 Multi-University Training Contest 1 - Host by HNU

题目地址：http://acm.hdu.edu.cn/showproblem.php?pid=3830

知识点：LCA，二叉树，二分答案

首先，我们把3个数排好序。设三个数从小到大是a, b, c

设：s1=b-as2=c-b

那么b可以跳动到a左边，或者c右边。

如果s1<s2，那么a可以跳到bc中间

如果s1>s2，那么c可以跳到ab中间

也就是说，如果s1≠s2，那么一个局面有3种跳法。

如果s1=s2，那么只有2种跳法。

如果我们用图来表示状态之间的关系，就很容易发现，状态之间组成的联

系实际上是二叉树组成的森林。

每一个s1=s2的状态都是一棵二叉树的根。

其余的每个状态，a或c往中间跳表示往父亲节点走一步

对于所有状态，中间节点往左右跳分别对应往左右孩子走一步。

原问题转换成了树上最短路问题。我们设起始状态对应节点p，目标状态对

应节点q。那么问题是：1.p和q是否同根。 2.如果同根，求p到q的距离。

这两个问题都可以用LCA的知识来解决。（LCA最近公共祖先）

如果p和q不存在LCA那么输出NO。

如果存在，那么计算LCA(p,q)到p和q分别的距离，相加即为答案。

我们可以通过辗转相除法直接计算p和q在二叉树中的深度。

为了方便求LCA，我们首先把p和q深度调整到相同。h(x)表示x的深度。

不妨设h(p)≤h(q)。我们把q往上走h(q)-h(p)步。

求2个深度相同的点的LCA，我们可以采用二分答案的方法。

对于二分答案：LCA到p的距离mid，

如果p往上走mid和q往上走mid到达的点相同，

那么 答案≤mid

否则 答案＞mid

如此一来，我们得到了一个O((logS)^2)的算法。问题被完美解决。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#include<vector>
#include<stack>
#include<map>
using namespace std;
struct State
{
    long long x,y,z,d;//d 表示当前状态距离根状态的距离
}start,end;
void st(State &t)//给状态升序 x,y,z
{
    if(t.x>t.y)
    swap(t.x,t.y);
    if(t.x>t.z)
    swap(t.x,t.z);
    if(t.y>t.z)
    swap(t.y,t.z);
}
inline bool Equal(const State &a, const State &b)//判断两个状态是否一致
{
    return a.x == b.x && a.y == b.y && a.z == b.z;
}

State Root(State &src)//找src状态的根状态
{
    State t=src;
    int p=t.z-t.y,q=t.y-t.x,r;
    while(p!=q)
    {
        if(p>q)//右侧区间大，r表示可以通过几次跳跃
        {
            r=(p-1)/q;
            t.y+=r*q;
            t.x+=r*q;       
        }
        else
        {
            r=(q-1)/p;
            t.z-=r*p;
            t.y-=r*p;
        }
        src.d+=r;
        st(t);
        p=t.z-t.y;
        q=t.y-t.x;
    }
    return t;
}
State SearchParent(State &src,long long step)//找src状态的前step个节点
{
    State t=src;
    while(step>0)
    {
        int p=t.z-t.y,q=t.y-t.x,r;
        if(p>q)
        {
            r=(p-1)/q;
            if(r>step) r=step;
            t.x+=r*q;
            t.y+=r*q;
        }
        else
        {
            r=(q-1)/p;
            if(r>step) r=step;
            t.z-=r*p;
            t.y-=r*p;
        }
        step-=r;
        st(t);
        p=t.z-t.y;
        q=t.y-t.x;
    }
    return t;
}
int main()
{
    int x,y,z,xx,yy,zz;
    while(scanf("%d%d%d%d%d%d",&x,&y,&z,&xx,&yy,&zz)==6)
    {
        start.x=x;start.y=y;start.z=z;start.d=0;
        end.x=xx;end.y=yy;end.z=zz;end.d=0;
        st(start);st(end);

        if(!Equal(Root(start),Root(end)))
        {
        printf("NO\n");
        }
        else
        {
            long long deep1=start.d,deep2=end.d,dis=start.d-end.d>0?start.d-end.d:end.d-start.d;
            if(start.d>end.d) start=SearchParent(start,dis);
            else end=SearchParent(end,dis);//使得两个状态的深度一致
            
            long long mid,low=0,hei=deep1<deep2?deep1:deep2;
            while(low<hei)//二分找到最近的公共祖先
            {
                mid=(low+hei)/2;
                if(Equal(SearchParent(start,mid),SearchParent(end,mid)))
                hei=mid;
                else
                low=mid+1;
            }
            printf("YES\n%d\n",low*2+dis);//结果为深度差加上两倍到公共祖先的距离
        }
    }
return 0;
}