LeetCode1033. Moving Stones Until Consecutive(java)

Three stones are on a number line at positions a, b, and c.

Each turn, you pick up a stone at an endpoint (ie., either the lowest or highest position stone), and move it to an unoccupied position between those endpoints. Formally, let’s say the stones are currently at positions x, y, z with x < y < z. You pick up the stone at either position x or position z, and move that stone to an integer position k, with x < k < z and k != y.

The game ends when you cannot make any more moves, ie. the stones are in consecutive positions.

When the game ends, what is the minimum and maximum number of moves that you could have made? Return the answer as an length 2 array: answer = [minimum_moves, maximum_moves]

Example 1:

Input: a = 1, b = 2, c = 5
Output: [1,2]
Explanation: Move the stone from 5 to 3, or move the stone from 5 to 4 to 3.

Example 2:

Input: a = 4, b = 3, c = 2
Output: [0,0]
Explanation: We cannot make any moves.

Example 3:

Input: a = 3, b = 5, c = 1
Output: [1,2]
Explanation: Move the stone from 1 to 4; or move the stone from 1 to 2 to 4.

Note:

1 <= a <= 100
1 <= b <= 100
1 <= c <= 100
a != b, b != c, c != a

思路：我的想法：max直接可以通过（y-x-1） + （z-y-1）获得，相当于每次endpoint都只向另一边移一个。min的话，通过每次求间隔较小的那个，然后二分mid点赋值。但实际上，min的最大值是2，因为x, y, z -> x, x+1, y -> x, x+1, x+2.一定能移到，所以版本一是不够好的，版本二才是正解。

版本一：

class Solution {
    public int[] numMovesStones(int a, int b, int c) {
        int[] res = new int[2];
        int[] stone = new int[]{a, b, c};
        Arrays.sort(stone);
        res[1] = stone[2] - stone[0] - 2;
        helper(stone, res);
        if (res[0] > 2) res[0] = 2;
        return res;
    }
    public void helper(int[] stone, int[] res) {
        if (stone[0] == stone[1] - 1 && stone[1] == stone[2] - 1) {
            return;
        }
        int x = stone[1] - stone[0] - 1;
        int y = stone[2] - stone[1] - 1;
        if (x == 0 || y == 0) {
            res[0]++;
            return;
        } else if (x <= y) {
            int mid = (stone[0] + stone[1]) / 2;
            stone[2] = stone[1];
            stone[1] = mid;
            res[0]++;
            helper(stone, res);
        } else {
            int mid = (stone[1] + stone[2]) / 2;
            stone[0] = stone[1];
            stone[1] = mid;
            res[0]++;
            helper(stone, res);
        }
        return;
    }
}

版本二：正解

class Solution {
    public int[] numMovesStones(int a, int b, int c) {
        int[] res = new int[2];
        int[] stone = new int[]{a, b, c};
        Arrays.sort(stone);
        res[1] = stone[2] - stone[0] - 2;
        if (stone[0] == stone[1] - 1 && stone[1] == stone[2] - 1) res[0] = 0;
        else if (stone[1] - stone[0] <= 2 || stone[2] - stone[1] <= 2) res[0] = 1;
        else res[0] = 2;
        return res;
    }
}