数据结构与算法之排序: LeetCode 164. 最大间距 (Ts, Py, Go版)

MobaXterm破解14个会话限制的保姆级教程(附Python环境配置指南) 本文提供了MobaXterm破解14个会话限制的详细教程,并深入讲解了如何配置稳定的Python环境以支持相关脚本运行。通过理解软件授权机制、安全实践步骤以及许可文件的应用,帮助用户解除会话数量限制,实现高效的远程服务器管理与自动化运维。 阅读详情

最大间距

  • https://leetcode.cn/problems/maximum-gap/description/

描述

  • 给定一个无序的数组 nums,返回 数组在排序之后,相邻元素之间最大的差值 。如果数组元素个数小于 2,则返回 0 。
  • 您必须编写一个在「线性时间」内运行并使用「线性额外空间」的算法。

示例 1

输入: nums = [3,6,9,1]
输出: 3
解释: 排序后的数组是 [1,3,6,9], 其中相邻元素 (3,6) 和 (6,9) 之间都存在最大差值 3。

示例 2

输入: nums = [10]
输出: 0
解释: 数组元素个数小于 2,因此返回 0。

备注

  • leetcode 的上的这一题,没有说明是整数的限定
  • 如果在用例中新增了小数,会报错,比如: xx.xx is not a valid value of type integer

提示

  • 1 <= nums.length <= 10510^5105
  • 0 <= nums[i] <= 10910^9109

Typescript 版算法实现


1 )借用原生sort + 迭代取相邻最大值

function maximumGap(nums: number[]): number {
    // 如果数组长度小于2返回0
    if (nums.length < 2) return 0;
    // 排序 这个在 leetcode 上要传入回调,否则排序是乱序的
    nums.sort((a, b) => a - b);
    // 用它来保存相邻元素的最大差值
    let max = 0;
    for (let i = 1; i < nums.length; i++) max = Math.max(max, nums[i] - nums[i - 1]);
    return max;
};
  • 这个结果是对的,但是不符合题意
  • 因为题目要求是线性的,一个原生sort的复杂度是 O(nlogn)
  • 注意这个sort要传入回调
    • 这个回调是和默认一致的从小到大,
    • 不传回调,则在 leetcode 环境中debug发现获得的排序是乱的,无法通过

2 )基数排序来解

// 基数排序
function radixSort(list: number[]) {
	const len = list.length; // 获取数组长度
	const max = Math.max(...list); // 获取数组中最大值
	let i = 0; // 用于计数的数组
	let radix = 1; // 基数(个:1, 十:10, 百: 100, ...)
	const tmp = new Array(len); // 临时倒腾数组
	while(max >= radix) {
		// 初始化存储桶 0 ~ 9, 全0填充
		const bucket = new Array(10).fill(0);
		// 对当前基数下的值进行累加计算总数
		for(i=0; i<len; i++) {
			// 获取当前基数下的值, 也就是对应的桶的下标
			const currentRadixNum = Math.floor(list[i] / radix) % 10;
			bucket[currentRadixNum] ++; // 从 0 开始自增, 这里桶中存储的是当前下标下对应数据的累计个数
		}
		// 计算当前数据位置: 基于桶内每个下标对应数据的累计个数,计算当前元素在整个桶中的位置,并反向赋值给当前桶
		for(i = 1; i<10; i++) {
			bucket[i] += bucket[i-1];
		}
		// 将a[i]的值按照桶存储的位置倒腾到临时数组tmp中
		for(i = len-1; i>=0; i--) {
			const currentRadixNum = Math.floor(list[i] / radix) % 10; // 当前基数下的数字
			const currentIndex = bucket[currentRadixNum] - 1; // bucket存储的是位置,位置-1为下标
			tmp[currentIndex] = list[i]; // 根据桶存储的位置, 
			bucket[currentRadixNum] --; // 桶内当前元素累计值 自减
		}
		// 再将临时数组中的元素倒腾回list中,此时完成了一轮的基于基数的处理
		list.splice(0, len, ...tmp);
		radix *= 10; // 基数进位处理
	}
}

function maximumGap(nums: number[]): number {
  // 如果数组长度小于2返回0
  if (nums.length < 2) return 0;
  radixSort(nums);
  // 用它来保存相邻元素的最大差值
  let max = 0;
  for (let i = 1; i < nums.length; i++) max = Math.max(max, nums[i] - nums[i - 1]);
  return max;
};
  • 参考: https://blog.youkuaiyun.com/Tyro_java/article/details/134191965
  • 虽然时间复杂度降下来了,满足题意,效率还行

3 )计数排序来解

function countSort(list:number[]) {
	const len: number = list.length;
	if (len < 2) return;
	// 获取最大值和最小值
	const max: number = Math.max(...list);
	const min: number = Math.min(...list);
	// 初始化计数数组
	const countList: number[] = new Array(max - min + 1).fill(0);
	// 初始化目标数组
	const result: number[] = new Array(len);
	// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
	for(let i:number = 0; i < len; i++) countList[list[i] - min]++; // 遍历完成后计数数组就变成了累计数组
	// 计算位置: 由上面的累计结果,计算累加后的位置, countList数组从累计数组,变成了位置数组
	for(let j = 1; j < max - min + 1; j++) {
		countList[j] += countList[j - 1];
	}
	// 根据累加后的位置, 将原数组中的数据按照位置进行分配,就得到排好序的数组,备注:数据可能重复,使用过的数据记得-1,从后向前遍历更好理解
	for (let k:number = len - 1; k >= 0; k--) {
		const currentIndex = countList[list[k] - min] - 1;
		result[currentIndex] = list[k]; // 将原数组的当前元素整合到 result数组对应的位置之中
		countList[list[k] - min] --; // 使用一次后,累计的数量自减,防止重复使用导致错误
	}
    list.splice(0, len, ...result); // 重新洗牌,用 result 内元素替换
}

function maximumGap(nums: number[]): number {
  // 如果数组长度小于2返回0
  if (nums.length < 2) return 0;
  countSort(nums);
  // 用它来保存相邻元素的最大差值
  let max = 0;
  for (let i = 1; i < nums.length; i++) max = Math.max(max, nums[i] - nums[i - 1]);
  return max;
};
  • 参考: https://blog.youkuaiyun.com/Tyro_java/article/details/134172583
  • 备注:可以做,但计数排序更适用于密集型数据,不适合这个场景,如果用例数据中有: [99999999, 2] 这类,则非常低效
  • 无法通过 leetcode 的测试用例

4 )桶排序

function maximumGap(nums: number[]): number {
    const n: number = nums.length;
    if (n < 2) return 0;
    const minVal: number = Math.min(...nums);
    const maxVal: number = Math.max(...nums);
    const d: number = Math.max(1, Math.floor(maxVal - minVal) / (n - 1));
    const bucketSize = Math.floor((maxVal - minVal) / d) + 1;

    const bucket: number[][] = new Array(bucketSize).fill(0).map(x => new Array(2).fill(0));
    for (let i: number = 0; i < bucketSize; ++i) {
        bucket[i].fill(-1);
    }
    for (let i: number = 0; i < n; i++) {
        const idx: number = Math.floor((nums[i] - minVal) / d);
        if (bucket[idx][0] === -1) {
            bucket[idx][0] = bucket[idx][1] = nums[i];
        } else {
            bucket[idx][0] = Math.min(bucket[idx][0], nums[i]);
            bucket[idx][1] = Math.max(bucket[idx][1], nums[i]);
        }
    }

    let max: number = 0;
    let prev: number = -1;
    for (let i: number = 0; i < bucketSize; i++) {
        if (bucket[i][0] == -1) {
            continue;
        }
        if (prev != -1) {
            max = Math.max(max, bucket[i][0] - bucket[prev][1]);
        }
        prev = i;
    }
    return max;
};
  • 官方提供的 桶排序 解题思路

Python3 版算法实现


1 ) 方案1

class Solution:
    def maximumGap(self, nums: List[int]) -> int:
        # 如果数组长度小于2返回0
        if len(nums) < 2:
            return 0
        # 排序
        nums.sort()
        # 用它来保存相邻元素的最大差值
        max_gap = 0
        for i in range(1, len(nums)):
            max_gap = max(max_gap, nums[i] - nums[i - 1])
        return max_gap

2 ) 方案2

class Solution:
    def maximumGap(self, nums: List[int]) -> int:
        # 如果数组长度小于2返回0
        if len(nums) < 2:
            return 0
        self.radix_sort(nums)
        # 用它来保存相邻元素的最大差值
        max_gap = 0
        for i in range(1, len(nums)):
            max_gap = max(max_gap, nums[i] - nums[i - 1])
        return max_gap

    def radix_sort(self, lst: list) -> None:
        max_val = max(lst)  # 获取数组中最大值
        radix = 1  # 基数(个:1, 十:10, 百: 100, ...)
        while max_val >= radix:
            bucket = [0] * 10  # 初始化存储桶 0 ~ 9, 全0填充
            tmp = [0] * len(lst)  # 临时倒腾数组
            
            # 对当前基数下的值进行累加计算总数
            for num in lst:
                current_radix_num = (num // radix) % 10
                bucket[current_radix_num] += 1
            
            # 计算当前数据位置: 基于桶内每个下标对应数据的累计个数,计算当前元素在整个桶中的位置,并反向赋值给当前桶
            for i in range(1, 10):
                bucket[i] += bucket[i - 1]
            
            # 将lst[i]的值按照桶存储的位置倒腾到临时数组tmp中
            for i in range(len(lst) - 1, -1, -1):
                current_radix_num = (lst[i] // radix) % 10
                current_index = bucket[current_radix_num] - 1
                tmp[current_index] = lst[i]
                bucket[current_radix_num] -= 1
            
            # 再将临时数组中的元素倒腾回lst中,此时完成了一轮的基于基数的处理
            lst[:] = tmp[:]
            radix *= 10  # 基数进位处理

3 ) 方案3

class Solution:
    def maximumGap(self, nums: List[int]) -> int:
        # 如果数组长度小于2返回0
        if len(nums) < 2:
            return 0
        self.count_sort(nums)
        # 用它来保存相邻元素的最大差值
        max_gap = 0
        for i in range(1, len(nums)):
            max_gap = max(max_gap, nums[i] - nums[i - 1])
        return max_gap


    def count_sort(self, lst: list) -> None:
        if len(lst) < 2:
            return
        max_val = max(lst)  # 获取最大值
        min_val = min(lst)  # 获取最小值
        count_list = [0] * (max_val - min_val + 1)  # 初始化计数数组
        result = [0] * len(lst)  # 初始化目标数组
        
        # 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
        for num in lst:
            count_list[num - min_val] += 1
        
        # 计算位置: 由上面的累计结果,计算累加后的位置, countList数组从累计数组,变成了位置数组
        for i in range(1, len(count_list)):
            count_list[i] += count_list[i - 1]
        
        # 根据累加后的位置, 将原数组中的数据按照位置进行分配,就得到排好序的数组
        for i in range(len(lst) - 1, -1, -1):
            current_index = count_list[lst[i] - min_val] - 1
            result[current_index] = lst[i]
            count_list[lst[i] - min_val] -= 1
        
        # 重新洗牌,用 result 内元素替换
        lst[:] = result[:]
  • 这种超出内存限制

4 ) 方案4

class Solution:
    def maximumGap(self, nums: List[int]) -> int:
        n = len(nums)
        if n < 2:
            return 0
        min_val = min(nums)
        max_val = max(nums)
        d = max(1, (max_val - min_val) // (n - 1))
        bucket_size = ((max_val - min_val) // d) + 1

        bucket = [[-1, -1] for _ in range(bucket_size)]
        for num in nums:
            idx = (num - min_val) // d
            if bucket[idx][0] == -1:
                bucket[idx][0] = bucket[idx][1] = num
            else:
                bucket[idx][0] = min(bucket[idx][0], num)
                bucket[idx][1] = max(bucket[idx][1], num)

        max_gap = 0
        prev = -1
        for i in range(bucket_size):
            if bucket[i][0] == -1:
                continue
            if prev != -1:
                max_gap = max(max_gap, bucket[i][0] - bucket[prev][1])
            prev = i
        return max_gap

Golang 版算法实现


1 ) 方案1

func maximumGap(nums []int) int {
	// 如果数组长度小于2返回0
	if len(nums) < 2 {
		return 0
	}
	// 排序
	sort.Ints(nums)
	// 用它来保存相邻元素的最大差值
	maxGap := 0
	for i := 1; i < len(nums); i++ {
		maxGap = max(maxGap, nums[i]-nums[i-1])
	}
	return maxGap
}

2 ) 方案2

func radixSort(list []int) {
	maxVal := max(list...)
	radix := 1
	tmp := make([]int, len(list))
	for maxVal/radix > 0 {
		bucket := make([]int, 10)
		for _, num := range list {
			currentRadixNum := (num / radix) % 10
			bucket[currentRadixNum]++
		}
		for i := 1; i < 10; i++ {
			bucket[i] += bucket[i-1]
		}
		for i := len(list) - 1; i >= 0; i-- {
			currentRadixNum := (list[i] / radix) % 10
			currentIndex := bucket[currentRadixNum] - 1
			tmp[currentIndex] = list[i]
			bucket[currentRadixNum]--
		}
		copy(list, tmp)
		radix *= 10
	}
}

func maximumGap(nums []int) int {
	// 如果数组长度小于2返回0
	if len(nums) < 2 {
		return 0
	}
	radixSort(nums)
	// 用它来保存相邻元素的最大差值
	maxGap := 0
	for i := 1; i < len(nums); i++ {
		maxGap = max(maxGap, nums[i]-nums[i-1])
	}
	return maxGap
}

func max(nums ...int) int {
	maxVal := nums[0]
	for _, num := range nums[1:] {
		if num > maxVal {
			maxVal = num
		}
	}
	return maxVal
}

3 ) 方案3

func maximumGap(nums []int) int {
	// 如果数组长度小于2返回0
	if len(nums) < 2 {
		return 0
	}
	countSort(nums)
	// 用它来保存相邻元素的最大差值
	maxGap := 0
	for i := 1; i < len(nums); i++ {
		maxGap = max(maxGap, nums[i]-nums[i-1])
	}
	return maxGap
}

func countSort(lst []int) {
	if len(lst) < 2 {
		return
	}
	maxVal := max(lst...)
	minVal := min(lst...)
	rangeVal := maxVal - minVal + 1
	countList := make([]int, rangeVal)
	result := make([]int, len(lst))

	// 对原数组的数据在计数数组中累计,原数组的值是计数数组的下标
	for _, num := range lst {
		countList[num-minVal]++
	}

	// 计算位置: 由上面的累计结果,计算累加后的位置, countList数组从累计数组,变成了位置数组
	for i := 1; i < len(countList); i++ {
		countList[i] += countList[i-1]
	}

	// 根据累加后的位置, 将原数组中的数据按照位置进行分配,就得到排好序的数组
	for i := len(lst) - 1; i >= 0; i-- {
		currentIndex := countList[lst[i]-minVal] - 1
		result[currentIndex] = lst[i]
		countList[lst[i]-minVal]--
	}

	// 重新洗牌,用 result 内元素替换
	copy(lst, result)
}

func max(nums ...int) int {
	maxVal := nums[0]
	for _, num := range nums[1:] {
		if num > maxVal {
			maxVal = num
		}
	}
	return maxVal
}

func min(nums ...int) int {
	minVal := nums[0]
	for _, num := range nums[1:] {
		if num < minVal {
			minVal = num
		}
	}
	return minVal
}
  • 超出内存限制

4 ) 方案4

func maximumGap(nums []int) int {
	n := len(nums)
	if n < 2 {
		return 0
	}
	minVal := minArray(nums)
	maxVal := maxArray(nums)
	d := max(1, (maxVal-minVal)/(n-1))
	bucketSize := (maxVal-minVal)/d + 1

	// 初始化桶
	bucket := make([][2]int, bucketSize)
	for i := range bucket {
		bucket[i] = [2]int{-1, -1}
	}

	// 将每个元素放入相应的桶中
	for _, num := range nums {
		idx := (num - minVal) / d
		if bucket[idx][0] == -1 {
			bucket[idx][0] = num
			bucket[idx][1] = num
		} else {
			bucket[idx][0] = min(bucket[idx][0], num)
			bucket[idx][1] = max(bucket[idx][1], num)
		}
	}

	// 计算最大差值
	maxGap := 0
	prev := -1
	for i := 0; i < bucketSize; i++ {
		if bucket[i][0] == -1 {
			continue
		}
		if prev != -1 {
			maxGap = max(maxGap, bucket[i][0]-bucket[prev][1])
		}
		prev = i
	}
	return maxGap
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

// 辅助函数:计算数组的最小值
func minArray(nums []int) int {
	minVal := nums[0]
	for _, num := range nums[1:] {
		if num < minVal {
			minVal = num
		}
	}
	return minVal
}

// 辅助函数:计算数组的最大值
func maxArray(nums []int) int {
	maxVal := nums[0]
	for _, num := range nums[1:] {
		if num > maxVal {
			maxVal = num
		}
	}
	return maxVal
}
基于YOLOv8和时序模型的异常动作检测系统 异常动作检测是计算机视觉领域的重要应用,广泛应用于智能监控、安防系统、老人看护等场景。本项目结合YOLOv8目标检测和LSTM时序模型,实现对打架、摔倒、奔跑等异常动作的实时检测,并提供了完整的Web界面。多技术融合: 结合YOLOv8目标检测和LSTM时序建模实时检测: 支持实时视频流处理和文件分析用户友好: 提供完整的Web界面可扩展性: 模块化设计便于功能扩展高性能: 包含多种优化策略。 阅读详情

相关推荐

数据结构与算法——7-2 一元多项式的乘法与加法运算 (20分)

设计函数分别求两个一元多项式的乘积与和。 输入格式: 输入分2行,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系数和指数(绝对值均为不超过1000的整数)。数字间以空格分隔。 输出格式: 输出分2行,分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔,但结尾不能有多余空格。零多项式应输出0 0。 输入样例: 4 3 4 -5 2 6 1 -2 0 3 5 20 -7 4 3 1 输出样例: 15 24 -25 22 30 21 -10 2

qazwsxxxxxasd的博客 1484

数据结构与算法笔记:字典序最大问题分析

字典序最大问题 问题描述 给定一个1到n的排列(无序状态的),依次插入到栈中,在每时每刻都可以多次从栈中弹出栈顶 问:应如何使得弹出栈顶的序列的字典序最大,并输出这个序列 问题分析 什么是字典序 比如两个序列:5,4,3,2,1和1,2,3,4,5 这两个中第一个的字典序最大 每个位置上的数字比其他序列上同一位置的数字要大 比如:第一位置中5比1大,第二位置中4比2大这样 即:字典序最大 = 从左向右看这个序列,每个数字都尽量大 题目给定一个1到n的排列,每个数字只出现一次 要使出栈的字典序最大

Wang的专栏 4393

通达信指标DLL加密与一机一码授权实战指南

在软件保护领域,代码混淆与授权管理是核心技术,旨在防止核心算法被逆向工程与非法分发。其原理在于将关键逻辑编译为二进制动态链接库(DLL),实现逻辑黑盒化,并结合硬件指纹生成唯一机器码进行绑定,从而构建一套可控的软件使用授权体系。这项技术的核心价值在于有效保护开发者的知识产权与商业利益,防止策略泄露与盗版泛滥。其典型应用场景包括金融交易策略、商业软件以及各类需要保护核心代码的插件开发。本文聚焦于通达信交易软件,详细阐述了如何通过DLL加密与一机一码绑定技术,为自定义指标公式构建一套安全、可靠的保护方案,解决指

weixin_29327525的博客 291

数据结构与算法笔记:农夫过河问题python3实现

问题描述 农夫(Human)过河。一个农夫带着一只狼(Wolf),一只羊(Sheep)和一些菜(Vegetable)过河。河边只有一条船,由于船太小,只能装下农夫和他的一样东西。在无人看管的情况下,狼要吃羊,羊要吃菜,请问农夫如何才能使三样东西平安过河? 要求: 输出一行,为最终的过河方式,方案格式为 过河人员、回来人员、过河人员、回来人员、…、过河人员。 过去和回来的人员之间,用空格隔开。 以四...

Wang的专栏 3374

利用Ghidra与SVD插件实现STM32固件深度逆向分析

本文详细介绍了如何利用Ghidra逆向工程框架结合SVD插件,实现对STM32固件(.bin文件)的深度逆向分析。通过加载描述芯片外设寄存器的SVD文件,Ghidra能将晦涩的硬件地址操作转换为可读的寄存器符号,极大提升了对嵌入式固件中通信协议、安全校验等关键逻辑的分析效率。文章涵盖了从Java环境搭建、工具配置到实战逆向解析的完整流程。

peach的博客 945

小卫星多普勒频偏MATLAB代码

多普勒频偏是由于发射机和接收机之间的相对运动而引起的频率变化。对于小卫星,由于其速度和高度的变化,多普勒频偏会变得更加明显。本文将探讨小卫星多普勒频偏的原理、影响因素以及补偿方法。多普勒频偏的原理当发射机和接收机之间存在相对运动时,接收到的信号频率会发生变化。这种频率变化称为多普勒频偏。其原理可以描述如下:设发射机和接收机之间的距离为 d,发射信号的频率为 f0,发射机和接收机的相对速度为 v。则接收到的信号频率 f 为:其中 c 为光速。

qq_59747472的博客 247

数据结构与算法笔记:计算思维之经典农夫过河问题C++实现

农夫、羊、狼、菜的过河问题 问题描述 角色:农夫,羊,狼,菜 条件1:船很小,只能装下农夫和其他一个角色 条件2:无人看管,羊吃菜,狼吃羊 问:如何让其他三种角色被农夫平安带着过河? 相关分析 我们可以先用人脑尝试一下相关渡河策略 1 ) 先渡狼,人回来再渡菜,人回来再渡羊 2 ) 先渡菜,人回来再渡狼,人回来再渡羊 以上两种很好想到,而且我们可以知道羊这种角色是不能先渡河过去的,羊需要最后再渡 如果先渡了羊了,之后再渡任何其他角色,都要将羊带回来 可以参考小游戏:http://gameschool

Wang的专栏 3314

【用unity实现100个游戏之16】Unity程序化生成随机2D地牢游戏1(附项目源码)

关于使用TileMap生成随机2D地图,其实之前已经有做过类似的,感兴趣可以看看 但是随着学习深入,发现之前做的比较粗糙和不够全面,最近又在外网看到

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 2218

数据结构与算法笔记:图搜索之DFS详解

图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) !!!本文详解!!! 深度优先搜索DFS 深度优先遍历DFS, 这个策略其实是非常stupid or simple的,比BSF要简单的多 同样,我们可以通过一个故事来开始 在古希腊神话中, Ariadne是Crete的国王Minos的公主,她给忒修斯(Theseus)一个线团 使得忒修斯成功进入迷宫杀死牛头怪兽,但事后忒修斯抛弃了她 这是一个有道德意义的故事又或者存在不同的版本, 但不是我们的研究的对象

Wang的专栏 3119

Vibe Coding 实战指南:用 3 类社区资源实现每周高效追新

介绍一种分层技术雷达校准方法,通过领域过滤器(L1技术栈锚定、L2能力映射、L3场景收敛)精准筛选AI编程相关更新,结合可验证的Shell命令与CI任务卡,将信息过载压缩为可执行、可审计的工程实践。

weixin_27251469的博客 332

STM32H750VB与AD5292通讯,写入阻值后,AD5292 的阻值没有变化,如何解决?

🏆 本文收录于《全栈Bug调优(实战版)》专栏,致力于分享我在项目实战过程中遇到的各类Bug及其原因,并提供切实有效的解决方案。无论你是初学者还是经验丰富的开发者,本文将为你指引出一条更高效的Bug修复之路,助你早日登顶,迈向财富自由的梦想🚀!同时,欢迎大家关注、收藏、订阅本专栏,更多精彩内容正在持续更新中。让我们一起进步,Up!Up!Up!    备注: 部分问题/难题源自互联网,经过精心筛选和整理,结合数位十多年大厂实战经验资深大佬经验总结所得,数条可行方案供所需之人参考。

**My Coding Family** 1103

数据结构与算法笔记:计算思维之人鬼渡河问题

人鬼渡河问题 1 ) 问题描述 目标:将东岸的3人3鬼通过一只小船安全转移到西岸,希望摆渡次数尽可能少 条件 船的容量有限,一次最多只能坐2人(或2鬼或1人1鬼) 无论是在河的东岸还是在河的西岸,一旦鬼数多于人数,则人将被鬼吃掉 怎样渡河的大权掌握在人的手中 说明:划船的时间忽略不计。船一靠岸即将船与岸视为一体,人和鬼即使还没有下 船也视为已上岸 任务:编写程序,求出一种渡河方案 备注:图片托管于github,请确保网络的可访问性 2 ) 分析 目标是找

Wang的专栏 2447

YOLOv8 智能交通流量监测完整解决方案

YOLOv8智能交通流量监测系统基于先进的目标检测技术,提供实时车辆识别与统计分析功能。该系统通过虚拟检测线实现多方向车流量统计,支持多种车辆类型分类,并具备数据可视化、异常事件预警等核心功能。完整解决方案包含模型训练、实时检测、批量处理、结果分析等模块,并提供Flask API和Docker两种部署方案。系统采用YOLOv8算法实现高效检测,支持GPU加速,可通过量化、剪枝等技术进一步优化性能,为智能交通管理提供可靠的数据支持和技术保障。

u010117029的博客 119

数据结构与算法之二叉树: LeetCode 701. 二叉搜索树中的插入操作 (Ts版)

1 ) 方案1:模拟。2 ) 方案2:递归。

Wang的专栏 2270

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

数据结构与算法笔记:计算思维之下楼梯台阶和象棋跳马问题

下台阶问题 1 ) 问题描述 从楼上走到楼下共有 h 个台阶,每一步有三种走法 走一个台阶; 走二个台阶; 走三个台阶。 问:一共可以走出多少种方案? 即共要多少步? 每一步走几级台阶? 2 ) 分析 初始思路 我们根据题目给定的场景,先简单模拟一下,设定 h=4h=4h=4 备注:图片托管于github,请确保网络的可访问性 如上图所示, 这里有4阶楼梯, 红色数字代表每一步走几级台阶 这里枚举了4层台阶的所有可能情况, 但是不管具体有几级台阶,下

Wang的专栏 2113

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

Python笔记:滑动验证码的识别算法

概述 用程序识别极验滑动验证码的验证,包括分析识别思路、识别缺口位置、生成滑块拖动路径、模拟实现滑块拼合通过验证等步骤。 准备工作 使用Python库是Selenium,浏览器为Chrome。请确保已安装Selenium库和ChromeDriver浏览器驱动。 关于极验滑动验证码: 极验滑动验证码官网为:http://www.geetest.com/ 验证方式为拖动滑块拼合图像,若图像完全拼合...

Wang的专栏 2104

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

数据结构与算法之堆: LeetCode 295. 数据流的中位数 (Ts版)

/ 返回 1.5 ((1 + 2) / 2)中位数是有序整数列表中的中间值。如果列表的大小是偶数,则没有中间值,中位数是两个中间值的平均值。3 ) 方案3:有序集合 + 双指针。2 ) 方案2:优先队列-优化版。1 ) 方案1:优先队列。

Wang的专栏 1907

数据结构与算法笔记:计算思维之谁做的好事与刑侦作案问题

谁做的好事 清华附中有四位同学中的一位做了好事,不留名,表扬信来了之后,校长问这四位是谁做的好事。 A说:不是我。 B说:是C。 C说:是D。 D说:他胡说。 已知:三个人说的是真话,一个人说的是假话。 现在请你根据这些信息,编写程序找出做了好事的人。 分析 将四个人说的四句话(自然语言)转换成计算机可以计算的式子, 可使用循环枚举的方式来判断 (1) 思路一:通过字符表示人 先定义一个字符变量 thisman 表示要寻找的做了好事的人的“名字(代号)”(A、B、C、D),即 char this

Wang的专栏 1833

数据结构与算法笔记:图搜索之BFS详解

图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) 广度优先搜索BFS 我们可以用比喻来说明广度优先搜索算法 在一片草木枯黄的深秋草原上,在草原的某一处出现了一处野火 一开始的时候野火集中于一点之上,在这点野火耗尽当前植被变成灰烬之前点燃了周围的植被 比如节点s是初始火种,假设我们手中有一个秒表,每过1秒,我们的大火会向外迈进一步 这个过程只能向外,不能向内,因为只能点燃植被,不能把灰烬点燃 蓝色的点是即将变为灰烬的点,红色的点是刚被点燃的点,灰色的圆形或

Wang的专栏 1794

数据结构与算法之动态规划: LeetCode 1494. 并行课程 II (Ts版)

给你一个整数 n 表示某所大学里课程的数目,编号为 1 到 n ,数组 relations 中, relations[i] = [xi, yi] 表示一个先修课的关系,也就是课程 xi 必须在课程 yi 之前上。解释:上图展示了题目输入的图。一个最优方案是:第一学期上课程 2 和 3,第二学期上课程 4 ,第三学期上课程 1 ,第四学期上课程 5。然后第二个学期上课程 1 ,第三个学期上课程 4。在一个学期中,你 最多 可以同时上 k 门课,前提是这些课的先修课在之前的学期里已经上过了。

Wang的专栏 1749

数据结构与算法笔记:求直方图最大面积算法分析

直方图最大面积 问题描述 有n列的直方图,第j列高度为hjh_jhj​, 求一个面积最大的子矩阵 备注:图片托管于github,请确保网络的可访问性 格式要求 输入第一行正整数n,第二行n个空格隔开的非负整数 数据范围: 所有直方图的列不会超过30000 关键算法实现 1 ) 算法1:时间复杂度为: O(n3)O(n^3)O(n3)的实现 分析 矩形面积为底和高的乘积 底部从a到b,那么底边长为: b-a+1 高为:min{hi∣a≤i≤b}min \{h

Wang的专栏 1664

数据结构与算法之LRU: 实现 LRU 缓存算法功能 (Ts, Py, Go版)

LRU - Lease Recently Used 最近使用如果内存优先,只缓存最近使用的,删除 ‘沉睡’ 数据核心 api: get set分析。

Wang的专栏 1599

数据结构与算法之贪心: LeetCode 455. 分饼干 (Ts, Py, Go版)

对每个孩子 i,都有一个胃口值 g[i],这是能让孩子们满足胃口的饼干的最小尺寸;并且每块饼干 j,都有一个尺寸 s[j]。如果 s[j] >= g[i],我们可以将这个饼干 j 分配给孩子 i ,这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子,并输出这个最大数值。假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能给一块饼干。2 )排序 + 双指针 + 贪心。1 )排序 + 遍历。

Wang的专栏 1568

动态规划(Dynamic Programming)详解:从入门到 LeetCode Hot 100

将一个复杂问题拆分成多个规模更小的子问题,通过保存子问题的计算结果,避免重复计算,最终得到原问题的答案。先看一个经典问题。dp[i] = 以第 i 个元素结尾的最优结果例如最长递增子序列。最长递增子序列不一定以最后一个元素结尾,因此必须遍历整个数组取最大值。dp[i] = 前 i 个元素的最优结果这种情况下,最终答案通常就是dp[n]。关键在于理解 dp 数组的定义。动态规划的核心并不是背诵某个固定模板,而是建立正确的状态定义,并通过状态转移方程解决问题。dp[i] 或 dp[i][j] 表示什么?

zengjiajun2006的博客 893

LeetCode2941~2960题目解析

LeetCode2941~2960题目解析

jiaomubai的博客 178

Rust LeetCode443 算法题解

LeetCode 443 字符串压缩:原地行程编码,用 start 标记组起点、next 扫描组边界、i 原地写出;长度 1 不写计数使编码不膨胀,写指针不越过读指针。时间 O(n),额外空间 O(1)。

weixin_43379230的博客 102
上一篇: 数据结构与算法之查找: LeetCode 374. 猜数字大小 (Ts, Py, Go版)
下一篇: 数据结构与算法之排序: LeetCode 922. 按奇偶排序数组 II (Ts, Py, Go版)
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值