端点石子移动问题

问题描述

小S正在玩一个关于石子的游戏,游戏中给定了一些石子,它们位于一维数轴上的不同位置,位置用数组 stones 表示。如果某个石子处于最小或最大的一个位置,我们称其为端点石子。

在每个回合,小S可以将一颗端点石子移动到一个未占用的位置,使其不再是端点石子。值得注意的是,如果石子的位置是连续的,则游戏结束,因为没有可以进行的移动操作。

你需要帮助小S找到可以移动的最小次数。


测试样例

样例1:

输入:stones = [7, 4, 9]

输出:1

样例2:

输入:stones = [6, 5, 4, 3, 10]

输出:2

样例3:

输入:stones = [1, 2, 3, 4, 5]

输出:0

Java代码

ini 复制代码
 import java.util.Arrays;
  public class Main {
  public static int solution(int[] stones) {
    if (stones.length == 1) {
        return 0;
    }
    
    Arrays.sort(stones);
    int n = stones.length;
    // 特殊处理 n = 2 的情况
    if (n == 2) {
        if (stones[1] - stones[0] == 1) {
            return 0; // 相邻则不需要移动
        }
        return 2; // 不相邻则需要移动两次
    }

    // 计算最大移动次数
    int maxMoves = stones[n - 1] - stones[0] + 1 - n;

    // 计算最小移动次数,使用滑动窗口
    int minMoves = Integer.MAX_VALUE;
    int j = 0;
    for (int i = 0; i < n; i++) {
        // 确保窗口内最多有 n 个石子
        while (j < n && stones[j] - stones[i] + 1 <= n) {
            j++;
        }
        // 如果窗口内有 n - 1 个石子,且空位为 1,则需要特殊处理
        int alreadyInPlace = j - i;
        if (alreadyInPlace == n - 1 && stones[j - 1] - stones[i] + 1 == n - 1) {
            minMoves = Math.min(minMoves, 2);
        } else {
            minMoves = Math.min(minMoves, n - alreadyInPlace);
        }
    }

    return Math.min(minMoves, maxMoves);
}

public static void main(String[] args) {
    System.out.println(solution(new int[]{7, 4, 9}) == 1); // 输出:true
    System.out.println(solution(new int[]{6, 5, 4, 3, 10}) == 2); // 输出:true
    System.out.println(solution(new int[]{1, 2, 3, 4, 5}) == 0); // 输出:true
    System.out.println(solution(new int[]{6, 8}) == 1); // 输出:true
    System.out.println(solution(new int[]{11, 14}) == 2); // 输出:true
}
}

时间复杂度分析

  1. 排序操作

    • Arrays.sort(stones); 使用的是快速排序,时间复杂度为 O(n log n)
  2. 特殊处理 n = 2 的情况

    • 这部分是常数时间操作,时间复杂度为 O(1)
  3. 计算最大移动次数

    • int maxMoves = stones[n - 1] - stones[0] + 1 - n; 是常数时间操作,时间复杂度为 O(1)
  4. 计算最小移动次数,使用滑动窗口

    • 外层 for 循环遍历数组,时间复杂度为 O(n)
    • 内层 while 循环在最坏情况下会遍历整个数组,但由于 j 是递增的,每个元素最多被访问两次(一次在 for 循环中,一次在 while 循环中),所以内层循环的总时间复杂度为 O(n)
    • 因此,滑动窗口部分的总时间复杂度为 O(n)

总时间复杂度

  • 排序操作:O(n log n)
  • 特殊处理和滑动窗口:O(n)

综合起来,代码的总时间复杂度为 O(n log n),其中 n 是数组 stones 的长度。

相关推荐
边疆.17 分钟前
C++类和对象 (中)
c语言·开发语言·c++·算法
binqian29 分钟前
【K8S】kubernetes-dashboard.yaml
算法·贪心算法
Wils0nEdwards1 小时前
Leetcode 合并 K 个升序链表
算法·leetcode·链表
Tisfy1 小时前
LeetCode 3211.生成不含相邻零的二进制字符串:二进制枚举+位运算优化
算法·leetcode·二进制·题解·枚举·位运算
好看资源平台1 小时前
深入理解所有权与借用——借用与生命周期管理
开发语言·算法·rust
qiaoxinyu19891 小时前
线性代数(1)——线性方程组的几何意义
线性代数·算法·机器学习
爱吃饭团的饭桶2 小时前
【附源码】Python :哈密顿回路
开发语言·python·算法
TNTLWT2 小时前
算法:查找
算法
feilieren2 小时前
leetcode - 684. 冗余连接
java·开发语言·算法
余~185381628002 小时前
矩阵系统源码搭建,OEM贴牌技术
网络·人工智能·线性代数·算法·矩阵