P1852跳跳棋 题解

好妙啊！这道题让我大开眼界！
写一篇题解加深一下印象。

思路

我重点对把原问题建模成一个树上问题的部分进行补充。

最开始读题的时候没有看到最多只跳过一个棋子，没想到这竟然是突破口。

我们假设一个状态 $(x, y, z)$，不妨设 $x \le y \le z$。

考虑它能怎么变化？这里为了方便描述，在引入两个变量 $d1,d2$ 表示 $x$ 和 $z$ 与 $y$ 之间的距离。

它会有以下几种变换方式：

1. $y$ 向左跳，$y \to y - 2 \times d1$，$(x, y, z) \to (y - 2 \times d1, x, z)$

2. $y$ 向右跳，$y \to y + 2 \times d2$， $(x, y, z) \to (x, z, y + 2 \times d2)$

3. $x$ 向右（中间）跳， $x \to x + 2 \times d1$， $(x, y, z) \to (y, x + 2 \times d1, z)$

4. $z$ 向左（中间）跳， $z \to z - 2 \times d2$，$(x, y, z) \to (x, z - 2 \times d2)$

可以发现由于最多只跳过一个棋子，$3$，$4$ 操作必然矛盾。
换句话说，假如只进行 $3$，$4$ 操作操作将是唯一的（会操作小的那边）!（\震惊）

这里有一个小发现： $1,2$ 操作和 $3,4$ 操作是互逆的：
比如 $(1, 2, 9)$ 进行 $3$ 操作 变成 $(2, 3, 9)$；$(2, 3, 9)$ 进行 $1$ 操作 又变回 $(1, 2, 9)$。

思考继续深入。每次 $(x, y, z)$ 的范围都会减少 $\min(d1, d2)$。

范围会在某个状态重新变大吗或无法变化吗？

答案是后者。我们刚才忘记讨论 $d1 = d2$ 的情况了！假如 $d1 = d2$ 那就无法操作了。

我们假设这样的状态为 $(x', y', z')$。

从 $(x', y', z')$ 到 $(x, y, z)$ 要进行的操作是不确定的 （$1$，$2$ 其中一种）。

而从 $(x, y, z)$ 到 $(x', y', z')$ 要进行的操作是确定的（$3$，$4$ 其中一种）。

并且 $1, 2$ 和 $3, 4$ 操作是互逆的。

二叉树不就是这样的吗？走到儿子和回到父亲是互逆的。儿子有多个，不确定；父亲只有一个，确定。

所以从原始状态到目标状态的过程对应的就是树上两点的距离。

设原始状态，目标状态分别为 $A$， $B$。

解决方法就是先找到 LCA ，再计算出 $A$，$B$ 到 LCA 的距离（用 $3，4$ 操作唯一解决）

剩下部分可以参考别的题解，主要的就是我这里的 jump 函数。

#include<bits/stdc++.h>
using namespace std;
struct node{
    int x, y, z;
//	void print() {
//		cout << x << " " << y << " " << z << "\n"; 
//	}
    bool operator == (node T) {
        return (x == T.x  && y == T.y && z == T.z);
    }
}A, B;
pair<node, int> get(int x, int y, int z) {
    int res = 0;
    while(1) {
        int d1 = y - x, d2 = z - y;
        if(d1 == d2) break;
        if(d1 < d2) {
            int s = (d2 - 1) / d1;
            y = z - d2 + s * d1;
            x = y - d1;
            res += s;
        }
        else {
            int s = (d1 - 1) / d2;
            y = x + d1 - s * d2;
            z = y + d2;
            res += s;
        }		
    }
    return {(node){x, y, z}, res};
}// 跳到根的步数 
 
node jump(int x, int y, int z, int step) {
    while(step) {
        int d1 = y - x, d2 = z - y;
        if(d1 == d2) break;
        if(d1 < d2) {
            int s = min(step, (d2 - 1) / d1);
            y = z - d2 + s * d1;
            x = y - d1;
            step -= s;
        }
        else {
            int s = min(step, (d1 - 1) / d2);
            y = x + d1 - s * d2;
            z = y + d2;
            step -= s;
        }	
    }
    return (node){x, y, z};
}// 跳 step 步到的点 
 
void init(node &P) {
    int a, b, c; 
    cin >> a >> b >> c;
    P.x = min({a, b, c});
    P.z = max({a, b, c});
    P.y = a + b + c - P.x - P.z;
}
 
int main() {
    init(A), init(B);
    auto tmp1 = get(A.x, A.y, A.z);
    auto tmp2 = get(B.x, B.y, B.z);
    if(!(tmp1.first == tmp2.first)) {
        cout << "NO";
        return 0;
    }
    cout << "YES\n"; 
    int tot1 = tmp1.second, tot2 = tmp2.second;
    if(tot1 < tot2) swap(A, B), swap(tot1, tot2);
    A = jump(A.x, A.y, A.z, tot1 - tot2);
    int l = 0, r = 1e9, ans = 0;
    while(l <= r) {
        int mid = (l + r) / 2;
        if(jump(A.x, A.y, A.z, mid) == jump(B.x, B.y, B.z, mid)) {
            ans = mid, r = mid - 1;
        }
        else l = mid + 1;
    }
    cout << ans * 2 + tot1 - tot2;
    return 0;
}