LeetCode 1040. Moving Stones Until Consecutive II(java)

最新推荐文章于 2025-05-25 18:28:46 发布

katrina95

最新推荐文章于 2025-05-25 18:28:46 发布

阅读量687

点赞数

CC 4.0 BY-SA版权

分类专栏：计算机算法

本文链接：https://blog.csdn.net/katrina95/article/details/95042036

计算机算法专栏收录该内容

221 篇文章

订阅专栏

本文探讨了一种在无限数轴上进行的游戏策略，玩家需将位于特定位置的石头移动至非端点位置，直到石头形成连续排列。文章详细解析了如何计算完成游戏所需的最小和最大步数，通过实例说明了不同情况下的最佳移动策略。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

On an infinite number line, the position of the i-th stone is given by stones[i]. Call a stone an endpoint stone if it has the smallest or largest position.

Each turn, you pick up an endpoint stone and move it to an unoccupied position so that it is no longer an endpoint stone.

In particular, if the stones are at say, stones = [1,2,5], you cannot move the endpoint stone at position 5, since moving it to any position (such as 0, or 3) will still keep that stone as an endpoint stone.

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: [7,4,9]
Output: [1,2]
Explanation: 
We can move 4 -> 8 for one move to finish the game.
Or, we can move 9 -> 5, 4 -> 6 for two moves to finish the game.

Example 2:

Input: [6,5,4,3,10]
Output: [2,3]
We can move 3 -> 8 then 10 -> 7 to finish the game.
Or, we can move 3 -> 7, 4 -> 8, 5 -> 9 to finish the game.
Notice we cannot move 10 -> 2 to finish the game, because that would be an illegal move.

Example 3:

Input: [100,101,104,102,103]
Output: [0,0]

Note:

3 <= stones.length <= 10^4
1 <= stones[i] <= 10^9
stones[i] have distinct values.

思路：求min: 找到一个<=n的间隔内连续数字个数最多的，然后min = n-个数。如果min = 1, 判断是否为1，2，3，10的情况，如果是，则min+1. 求max: 比较两个端点和最近点的距离，max = 所有点之间的距离 - 小的端点距离 + 1（移动一个端点到另一端） - 1（移动完另一端距离-1）；

class Solution {
    public int[] numMovesStonesII(int[] stones) {
        int[] res = new int[2];
        Arrays.sort(stones);
        int n = stones.length;
        //min
        int min = 0;
        for (int i = 0; i < n; i++) {
            int compute = 1;
            int j = i + 1;
            while(j < n && stones[j] - stones[i] <= n - 1) {
                compute++;
                j++;
            }
            min = Math.max(min, compute);
        }
        //max
        int max = 0;
        for (int i = 1; i < n; i++) {
            max = max + stones[i] - stones[i-1] - 1;
        }
        if (stones[1] - stones[0] <= stones[n-1] - stones[n-2])  max = max - (stones[1] - stones[0] - 1);
        else max = max - (stones[n-1] - stones[n-2] - 1);
        res[0] = n - min;
        if (res[0] == 1) {
            if ((stones[n-2] - stones[0] == n-2 && stones[n-1] != stones[n-2] + 2) 
                || (stones[n-1] - stones[1] == n-2 && stones[0] + 2 != stones[1])) {
                res[0] = res[0] + 1;
            }
        }
        res[1] = max;
        return res;
    }
}

思路二：

class Solution {
    public int[] numMovesStonesII(int[] stones) {
        int[] res = new int[2];
        Arrays.sort(stones);
        int n = stones.length;
        //min
        int min = n-1;
        int i = 0;
        for (int j = 0; j < n; ++j) {
            while (stones[j] - stones[i] >= n) ++i;
            //j-i+1 == n-1表示从i到j有n个可能的连续数里的n-1个。第二个判断条件判断n-1个数都连续，还是有一个地方不连续，差1。
            //j-i+1 == n表示n个数都连续。
            if (j - i + 1 == n - 1 && stones[j] - stones[i] +1 == n-1) {
                //n-1个数都连续
                min = Math.min(min, 2);
            } else {
                min = Math.min(min, n - (j - i + 1));
            }
        }
        res[0] = min;
        //max
        int max = 0;
        max = Math.max(stones[n-1] - stones[1] - (n-2), stones[n-2] - stones[0] - (n-2));
        res[1] = max;
        return res;
    }
}