端点石子移动问题

问题描述

小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 的长度。

相关推荐
YuTaoShao7 小时前
【LeetCode 热题 100】141. 环形链表——快慢指针
java·算法·leetcode·链表
小小小新人121238 小时前
C语言 ATM (4)
c语言·开发语言·算法
你的冰西瓜8 小时前
C++排序算法全解析(加强版)
c++·算法·排序算法
এ᭄画画的北北8 小时前
力扣-31.下一个排列
算法·leetcode
绝无仅有9 小时前
企微审批对接错误与解决方案
后端·算法·架构
用户50408278583910 小时前
1. RAG 权威指南:从本地实现到生产级优化的全面实践
算法
Python×CATIA工业智造11 小时前
详细页智能解析算法:洞悉海量页面数据的核心技术
爬虫·算法·pycharm
无聊的小坏坏12 小时前
力扣 239 题:滑动窗口最大值的两种高效解法
c++·算法·leetcode
黎明smaly12 小时前
【排序】插入排序
c语言·开发语言·数据结构·c++·算法·排序算法