题目要求

思路：数学推导

• 因为区间的对称，所以负数和正数的处理是完全相同的，所以就全当正数算；
• 目的是找最少的移动次数$nm$，那么可以粗暴地直接一直向着正方向走到最靠近$target$的位置，此时有两种情况：
  • 刚好到达，那么很快乐直接得到了答案；
  • 超了，又出现了两种solution：
    • 只需要把其中一步改成反方向，就可以刚好到达；
    • 需要再增加几步，然后改一步为反方向，才可以到达；
    • 只需翻转一步，翻多了说明走多了，不是最优解。
• 那么，翻转一步就可以刚好到达的情况满足什么条件呢？
  • 持续正向移动$nm$次走过的距离为$dis=\frac{nm\times(nm+1)}{2}$；
  • 当$dis$超过了两步时，翻转第一步即可；超过四步时，翻转第二步即可……发现超过偶数步，翻转其砍半的那一步即可，所以刚好到达的情况满足$(dis-target)\%2=0$；
• 由于刚好到达满足$dis-target=0$也能够整除$2$，所以题目目标可以改为找到最小的满足$(\frac{nm\times(nm+1)}{2}-target)\%2=0$的$nm$；
• 所以程序编写思路就是从最靠近目标的那一步$nm_{begin}=\lfloor\sqrt{2\times target}\rfloor$开始判断：
  • 能否直接到？
  • 能否翻转一步到？
  • 能否加一步翻转一步到？
  • 能否加两步翻转一步到？
  • ……
• 下一步考虑时间复杂度，加几步影响整体时间复杂度，所以看看最多需要加几步；
  • 加步数目的是保证$dis$和$target$的差值为偶数，也就是保证$dis$和$target$的奇偶一致，也就是通过$nm$影响$dis$的奇偶；
  • 证明发现加两步以内可以保证$dis$的奇偶被改变【具体是怎么正向推的不知道，但可以来一段不严谨的反向证明】；
  • 因为假设别的都不能判断奇偶，所以假设：
    • $nm=4x$，此时$dis=\frac{4x\times(4x+1)}{2}=2x\times(4x+1)$，由于$2x$为偶数，所以$dis$为偶数；
    • $nm=4x+1$，此时$dis=\frac{(4x+1)\times(4x+2)}{2}=(4x+1)\times(2x+1)$，由于二者均为奇数，所以$dis$为奇数；
    • $nm=4x+2$，此时$dis=\frac{(4x+2)\times(4x+3)}{2}=(2x+1)\times(4x+3)$，由于二者均为奇数，所以$dis$为奇数；
    • $nm=4x+3$，此时$dis=\frac{(4x+3)\times(4x+4)}{2}=(4x+3)\times(2x+2)$，由于$2x+2$为偶数，所以$dis$为偶数；
    • 发现在两步范围内就必然可以翻转$dis$的奇偶性。

Java

class Solution {
    public int reachNumber(int target) {
        if (target < 0)
            target = -target;
        int numMoves = (int) Math.sqrt(2 * target), dis = numMoves * (numMoves + 1) / 2;
        while (dis < target || (dis - target) % 2 == 1) {
            numMoves++;
            dis = numMoves * (numMoves + 1) / 2;
        }
        return numMoves;
    }
}

• 时间复杂度：$O(1)$，while最多两轮
• 空间复杂度：$O(1)$

C++

class Solution {
public:
    int reachNumber(int target) {
        if (target < 0)
            target = -target;
        int numMoves = (int) sqrt(2 * target), dis = numMoves * (numMoves + 1) / 2;
        while (dis < target || (dis - target) % 2 == 1) {
            numMoves++;
            dis = numMoves * (numMoves + 1) / 2;
        }
        return numMoves;
    }
};

• 时间复杂度：$O(1)$，while最多两轮
• 空间复杂度：$O(1)$

Rust

impl Solution {
    pub fn reach_number(target: i32) -> i32 {
        let mut tar = target.abs();        
        let mut numMoves = ((2 * tar) as f64).sqrt() as i32;
        let mut dis = numMoves * (numMoves + 1) / 2;
        while (dis < tar || (dis - tar) % 2 == 1) {
            numMoves += 1;
            dis = numMoves * (numMoves + 1) / 2;
        }
        numMoves
    }
}

• 时间复杂度：$O(1)$，while最多两轮
• 空间复杂度：$O(1)$

总结

• 开心找规律;
• 想到了和这个差不多的解法，不过是从头开始找，时间复杂度会高一些到$O(\log(nm))$。