文心一言 VS 讯飞星火 VS chatgpt （208）-- 算法导论15.4 5题

news2024/7/6 17:56:40

五、设计一个 O( n 2 n^2 n2) 时间的算法，求一个 n 个数的序列的最长单调递增子序列。要写代码的时候，请用go语言。

文心一言，抛panic：

在 Go 语言中设计一个 O(n^2) 时间复杂度的算法来求一个 n 个数的序列的最长单调递增子序列（Longest Increasing Subsequence, LIS）可以使用动态规划的方法。以下是一个实现示例：

package main  
  
import (  
	"fmt"  
)  
  
// LIS 使用动态规划来求一个序列的最长单调递增子序列  
func LIS(nums []int) []int {  
	n := len(nums)  
	if n == 0 {  
		return []int{}  
	}  
  
	// dp[i] 表示以 nums[i] 结尾的最长递增子序列的长度  
	dp := make([]int, n)  
	// 初始化 dp 数组，每个元素自身构成一个长度为 1 的递增子序列  
	for i := 0; i < n; i++ {  
		dp[i] = 1  
	}  
  
	// 初始化最长递增子序列的末尾元素数组  
	lis := make([]int, n)  
	// 最长递增子序列的长度  
	maxLen := 1  
	// 最长递增子序列的末尾元素索引  
	maxIndex := 0  
  
	for i := 1; i < n; i++ {  
		for j := 0; j < i; j++ {  
			// 如果 nums[i] 大于 nums[j]，则考虑将 nums[i] 添加到以 nums[j] 结尾的递增子序列  
			if nums[i] > nums[j] && dp[i] < dp[j]+1 {  
				dp[i] = dp[j] + 1  
				lis[i] = j // 记录状态转移路径  
			}  
		}  
		// 更新最长递增子序列的长度和末尾元素索引  
		if dp[i] > maxLen {  
			maxLen = dp[i]  
			maxIndex = i  
		}  
	}  
  
	// 根据状态转移路径反向构建最长递增子序列  
	result := make([]int, maxLen)  
	for i := maxIndex; i >= 0; i = lis[i] {  
		result[maxLen-1-i] = nums[i]  
	}  
  
	return result  
}  
  
func main() {  
	nums := []int{10, 9, 2, 5, 3, 7, 101, 18}  
	lis := LIS(nums)  
	fmt.Println("The longest increasing subsequence is:", lis)  
}

这个算法的时间复杂度是 O(n^2)，其中 n 是序列的长度。我们创建了一个 dp 数组来存储以每个元素结尾的最长递增子序列的长度，并通过比较每个元素和它之前的元素来更新 dp 数组。我们也创建了一个 lis 数组来记录状态转移的路径，以便在算法结束时反向构建出最长递增子序列。

当 dp[i] 的值更新时，我们记录下是哪个 dp[j] 转移过来的，即 lis[i] = j。这样，在构建最长递增子序列时，我们可以从 maxIndex（最长递增子序列的末尾元素索引）开始，根据 lis 数组反向追溯，得到整个子序列。

在 main 函数中，我们调用 LIS 函数并打印出最长递增子序列。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

讯飞星火，代码正常运行：

在Go语言中，我们可以使用动态规划来解决这个问题。以下是实现最长单调递增子序列的代码：

package main
import "fmt"

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

func longestIncreasingSubsequence(nums []int) int {
    n := len(nums)
    dp := make([]int, n)
    for i := range dp {
        dp[i] = 1
    }
    for i := 1; i < n; i++ {
        for j := 0; j < i; j++ {
            if nums[i] > nums[j] {
                dp[i] = max(dp[i], dp[j]+1)
            }
        }
    }
    maxLen := 0
    for _, v := range dp {
        maxLen = max(maxLen, v)
    }
    return maxLen
}

func main() {
    nums := []int{10, 9, 2, 5, 3, 7, 101, 18}
    fmt.Println("Length of Longest Increasing Subsequence is", longestIncreasingSubsequence(nums))
}

在这个程序中，我们首先定义了一个一维数组dp，其中dp[i]表示以第i个元素结尾的最长递增子序列的长度。然后，我们遍历数组，对于每个元素，我们都检查它之前的所有元素，如果当前元素大于之前的某个元素，那么我们就更新dp[i]的值。最后，我们返回dp数组中的最大值，这就是最长递增子序列的长度。

在这里插入图片描述

在这里插入图片描述

360智脑，代码正常运行：

以下是一个使用Go语言实现的O(n^2)时间的算法，用于求解一个n个数的序列的最长单调递增子序列：

package main 
 
import "fmt"
 
func longestMonotonicSubsequence(X []int, n int) int {
    // 初始化dp数组 
    dp := make([]int, n+1)
    for i := range dp {
        dp[i] = 1 
    }
 
    // 从第二个元素开始遍历 
    for i := 1; i < n; i++ {
        for j := 0; j < i; j++ {
            // 如果X[i]大于X[j]，并且dp[i]小于dp[j]+1 
            if X[i] > X[j] && dp[i] < dp[j]+1 {
                dp[i] = dp[j] + 1 
            }
        }
    }
 
    // 找到dp数组中的最大值 
    max := 0 
    for _, v := range dp {
        if v > max {
            max = v 
        }
    }
 
    return max 
}
 
func main() {
    X := []int{10, 22, 9, 33, 21, 50, 41, 60}
    n := len(X)
    fmt.Println(longestMonotonicSubsequence(X, n))
}

在这个算法中，我们使用了一个动态规划的方法。我们首先初始化一个dp数组，其中dp[i]表示序列X中以X[i]结尾的最长单调递增子序列的长度。然后，我们从第二个元素开始遍历X，对于每个元素X[i]，我们检查它是否大于之前的元素X[j]，并且dp[i]是否小于dp[j]+1。如果是，我们就更新dp[i]为dp[j]+1。最后，我们找到dp数组中的最大值，即为所求的最长单调递增子序列的长度。

在这里插入图片描述

在这里插入图片描述

智谱清言，代码正常运行：

在计算机科学中，最长单调递增子序列（Longest Monotonically Increasing Subsequence，简称 LIS）问题可以通过动态规划在 O( n 2 n^2 n2)的时间内解决。下面是一个使用 Go 语言实现的 O(n^2) 动态规划算法来解决最长单调递增子序列问题：

package main
import (
	"fmt"
)
// lis 函数计算最长单调递增子序列的长度
func lis(nums []int) int {
	if len(nums) == 0 {
		return 0
	}
	// dp[i] 表示以 nums[i] 结尾的最长单调递增子序列的长度
	dp := make([]int, len(nums))
	// 初始化dp数组，每个元素的值都是1，因为每个数字本身都可以构成一个长度为1的递增子序列
	for i := range dp {
		dp[i] = 1
	}
	// 动态规划填表
	for i := 1; i < len(nums); i++ {
		for j := 0; j < i; j++ {
			if nums[i] > nums[j] {
				dp[i] = max(dp[i], dp[j]+1)
			}
		}
	}
	// 找出dp数组中的最大值，即为最长单调递增子序列的长度
	maxLength := 0
	for _, length := range dp {
		maxLength = max(maxLength, length)
	}
	return maxLength
}
// max 函数返回两个整数中的最大值
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}
func main() {
	// 测试数据
	nums := []int{10, 9, 2, 5, 3, 7, 101, 18}
	fmt.Println("The length of the longest increasing subsequence is:", lis(nums))
}

这段代码首先初始化一个动态规划数组 dp，其中 dp[i] 表示以 nums[i] 结尾的最长单调递增子序列的长度。然后，它通过两层循环来填充这个数组，如果在 nums 中的某个较小的元素 nums[j] 之后有元素 nums[i]，则 dp[i] 可以更新为 dp[j] + 1。最后，它遍历 dp 数组以找到最大的值，这个值就是最长单调递增子序列的长度。

请注意，尽管这个算法是 O(n^2) 的，但对于较大的数据集，它可能不是最优的。在实际应用中，可以考虑使用二分搜索优化算法，将时间复杂度降低到 O(nlogn)。

在这里插入图片描述

在这里插入图片描述

天工，代码正常运行：

以下是一个使用动态规划算法来找出一个包含 n 个元素的序列的最长单调递增子序列（LIS）的 Go 语言实现。这个算法的时间复杂度是 O(n^2)。

package main

import "fmt"

// findLISLength 使用动态规划找出给定数组的最长单调递增子序列的长度。
func findLISLength(nums []int) int {
    if len(nums) == 0 {
        return 0
    }

    dp := make([]int, len(nums))
    dp[0] = 1 // 初始化第一个元素的 LIS 为 1。

    for i := 1; i < len(nums); i++ {
        for j := 0; j < i; j++ {
            if nums[i] > nums[j] {
                dp[i] = max(dp[i], dp[j]+1)
            }
        }
    }

    // 找到最长 LIS 长度。
    var maxLen int
    for _, length := range dp {
        if length > maxLen {
            maxLen = length
        }
    }
    return maxLen
}

// max 返回两个整数中较大的一个。
func max(a, b int) int {
    if a >= b {
        return a
    }
    return b
}

func main() {
    nums := []int{10, 22, 9, 33, 21, 50, 30, 60, 80}
    length := findLISLength(nums)
    fmt.Printf("Length of LIS: %d\n", length)
}

这段代码定义了一个 findLISLength 函数，它接受一个整数切片作为输入，并返回该序列的最长单调递增子序列的长度。函数内部使用了一个名为 dp 的动态规划数组，用于存储每个元素在 LIS 中的可能最大长度。通过迭代和比较，逐步构建出整个数组在 LIS 中的长度，最后通过遍历 dp 数组来找到最长的 LIS 长度。

在 main 函数中，有一个示例数组 nums，调用 findLISLength 函数并打印结果。你可以替换 nums 中的值以测试不同的数组。

在这里插入图片描述

在这里插入图片描述

灵小智，代码正常运行：

Sure! 下面是一个使用Go语言实现的O($n^2$)时间复杂度的算法来求解一个n个数的序列的最长单调递增子序列。

package main

import (
	"fmt"
)

func longestIncreasingSubsequence(nums []int) []int {
	length := len(nums)
	dp := make([]int, length)
	for i := 0; i < length; i++ {
		dp[i] = 1
	}

	for i := 1; i < length; i++ {
		for j := 0; j < i; j++ {
			if nums[i] > nums[j] && dp[i] < dp[j]+1 {
				dp[i] = dp[j] + 1
			}
		}
	}

	maxLen := 0
	endIndex := 0
	for i := 0; i < length; i++ {
		if dp[i] > maxLen {
			maxLen = dp[i]
			endIndex = i
		}
	}

	result := make([]int, maxLen)
	result[maxLen-1] = nums[endIndex]
	maxLen--
	endIndex--

	for i := endIndex; i >= 0; i-- {
		if nums[i] < nums[endIndex] && dp[i] == maxLen {
			result[maxLen-1] = nums[i]
			maxLen--
			endIndex = i
		}
	}

	return result
}

func main() {
	nums := []int{10, 22, 9, 33, 21, 50, 41, 60}
	lis := longestIncreasingSubsequence(nums)
	fmt.Println("最长递增子序列为：", lis)
}

希望这个算法和代码对你有所帮助！

在这里插入图片描述

在这里插入图片描述

chatgpt，代码正常运行：

要设计一个O(n^2)时间复杂度的算法来求一个n个数的序列的最长单调递增子序列，可以使用动态规划的思想。下面是用Go语言实现的代码：

package main

import (
	"fmt"
)

func longestIncreasingSubsequence(nums []int) int {
	n := len(nums)
	if n == 0 {
		return 0
	}

	dp := make([]int, n) // dp[i]表示以nums[i]结尾的最长递增子序列长度
	maxLen := 1          // 最长递增子序列的长度，默认为1

	for i := 0; i < n; i++ {
		dp[i] = 1 // 初始化dp数组为1
		for j := 0; j < i; j++ {
			if nums[j] < nums[i] && dp[j]+1 > dp[i] {
				dp[i] = dp[j] + 1 // 更新dp数组
			}
		}
		if dp[i] > maxLen {
			maxLen = dp[i]
		}
	}

	return maxLen
}

func main() {
	nums := []int{10, 22, 9, 33, 21, 50, 41, 60}
	fmt.Println("最长递增子序列长度:", longestIncreasingSubsequence(nums))
}

该代码使用动态规划算法，定义dp数组表示以每个位置元素结尾的最长递增子序列长度。初始化dp数组为1，并在遍历过程中更新dp值。最后返回dp数组中的最大值作为最长递增子序列的长度。

该算法的时间复杂度为O(n^2)，因为需要两层循环来遍历所有可能的子序列。

在这里插入图片描述

在这里插入图片描述

kimi，代码正常运行：

为了在 O(n^2) 时间内找到一个序列的最长单调递增子序列（LIS），我们可以使用一个经典的动态规划方法。这个算法的核心思想是维护一个数组 lis，其中 lis[i] 表示以第 i 个元素结尾的最长递增子序列的长度。对于每个元素，我们需要检查它之前的所有元素，如果当前元素大于之前的某个元素，我们更新 lis 数组。

以下是使用 Go 语言实现的 O(n^2) 时间复杂度的 LIS 算法：

package main

import (
	"fmt"
)

// LIS 函数计算序列的最长单调递增子序列的长度
func LIS(seq []int) int {
	n := len(seq)
	lis := make([]int, n)
	maxLIS := 0

	// 初始化 lis 数组，每个元素的 LIS 长度初始为 1
	for i := range lis {
		lis[i] = 1
	}

	// 遍历序列，更新 lis 数组
	for i := 1; i < n; i++ {
		for j := 0; j < i; j++ {
			if seq[i] > seq[j] && lis[i] < lis[j]+1 {
				lis[i] = lis[j] + 1
			}
		}
		// 更新最大 LIS 长度
		if lis[i] > maxLIS {
			maxLIS = lis[i]
		}
	}

	return maxLIS
}

func main() {
	seq := []int{10, 9, 2, 5, 3, 7, 101, 18}
	lisLength := LIS(seq)
	fmt.Printf("Length of the Longest Increasing Subsequence is: %d\n", lisLength)
}

在这个实现中，我们首先初始化 lis 数组，使得每个元素的 LIS 长度初始为 1。然后，我们使用两层循环来更新 lis 数组。外层循环遍历序列中的每个元素，内层循环检查当前元素之前的所有元素。如果找到一个较小的元素，我们尝试更新当前元素的 LIS 长度。最后，我们记录并返回最大的 LIS 长度。

这个算法的时间复杂度是 O(n^2)，因为我们需要对序列中的每个元素进行两次遍历。

在这里插入图片描述

在这里插入图片描述

混元，代码正常运行：

以下是使用 Go 语言实现的一个 O(n^2) 时间复杂度的算法，用于求一个 n 个数的序列的最长单调递增子序列：

package main

import (
	"fmt"
)

func longestIncreasingSubsequence(arr []int) int {
	n := len(arr)
	dp := make([]int, n)

	for i := range dp {
		dp[i] = 1
	}

	for i := 1; i < n; i++ {
		for j := 0; j < i; j++ {
			if arr[i] > arr[j] {
				dp[i] = max(dp[i], dp[j]+1)
			}
		}
	}

	maxLength := 0
	for _, val := range dp {
		maxLength = max(maxLength, val)
	}

	return maxLength
}

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

func main() {
	arr := []int{10, 22, 9, 33, 21, 50, 41, 60, 80}
	fmt.Printf("The length of the longest increasing subsequence is: %d\n", longestIncreasingSubsequence(arr))
}

这个实现使用动态规划方法。dp[i] 表示以 arr[i] 结尾的最长单调递增子序列的长度。对于每个元素 arr[i]，我们遍历其之前的所有元素 arr[j]，如果 arr[i] > arr[j]，则更新 dp[i] 为 max(dp[i], dp[j]+1)。最后，我们返回 dp 数组中的最大值，即为最长单调递增子序列的长度。

在这里插入图片描述

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1489609.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【数据结构】20 树的应用（堆及其操作）

【数据结构】20 树的应用（堆及其操作）

堆的定义 堆是一种优先队列&#xff0c;从堆中取出元素时按照元素的优先级大小&#xff0c;而不是元素进入队列的先后顺序。 堆的最常用结构是二叉树&#xff0c;一般为完全二叉树。通常使用数组来实现堆的存储。 最大堆&#xff1a;任一结点的值大于或等于其子节点的值。这一…
阅读更多...
【论文阅读】Mamba:选择状态空间模型的线性时间序列建模（一）

【论文阅读】Mamba:选择状态空间模型的线性时间序列建模（一）

文章目录 Mamba:选择状态空间模型的线性时间序列建模介绍状态序列模型选择性状态空间模型动机&#xff1a;选择作为一种压缩手段用选择性提升SSM 选择性SSM的高效实现先前模型的动机选择扫描总览&#xff1a;硬件感知状态扩展 Mamba论文 Mamba:选择状态空间模型的线性时间序列建…
阅读更多...
【.NET Core】深入理解IO - 读取器和编写器

【.NET Core】深入理解IO - 读取器和编写器

【.NET Core】深入理解IO - 读取器和编写器 文章目录 【.NET Core】深入理解IO - 读取器和编写器一、概述二、BinaryReader和BinaryWriter2.1 BinartReader类2.2 BinaryWriter类 三、StreamReader和StreamWriter3.1 StreamReader类3.1 StreamWriter类StreamWriter类构造函数Str…
阅读更多...
AI大语言模型【成像光谱遥感技术】ChatGPT应用指南

AI大语言模型【成像光谱遥感技术】ChatGPT应用指南

遥感技术主要通过卫星和飞机从远处观察和测量我们的环境&#xff0c;是理解和监测地球物理、化学和生物系统的基石。ChatGPT是由OpenAI开发的最先进的语言模型&#xff0c;在理解和生成人类语言方面表现出了非凡的能力。本文重点介绍ChatGPT在遥感中的应用&#xff0c;人工智能…
阅读更多...
想学习FPGA，建议购买哪一款开发板呢？

想学习FPGA，建议购买哪一款开发板呢？

FPGA项目&#xff1a; 多通道信号采集呈像系统 该系统是以Artix-7系列的FPGA为主控芯片&#xff0c;设计并实现了一款基于A7系列开发板的多通道信号采集呈像系统&#xff0c;该设计采用DAC芯片&#xff08;数模转换芯片&#xff09;将数字信号转换成模拟信号&#xff0c;通过…
阅读更多...
LLM春招，搜广推，nlp(2)

LLM春招，搜广推，nlp(2)

Encoder和Decoder怎么交互的 decoder里面的K&#xff0c;V输入用的是encoder的输出&#xff0c;并不是共享了K, V参数&#xff0c;decoder每层的参数都是独立的。Decoder每层是有两块Attention的&#xff1a;一块是正常的Self-Attention&#xff0c;QKV的输入都来自Decoder上一…
阅读更多...
ArcGIS学习（九）选址分析

ArcGIS学习（九）选址分析

ArcGIS学习（九）选址分析 本任务给大家带来的案例是租房选址分析。选址分析是我们平时经常接触到的分析场景。概括起来说，选址分析就是根据选址条件来确定哪些区域满足我们的选址要求。首先，先来看看我们这个案例的场景和基础数据。我们以某个城市某一租客的租房选址为例。…
阅读更多...
STM32CubeMX学习笔记8 -ADC

STM32CubeMX学习笔记8 -ADC

1. ADC简介 ADC 是Analog-to-Digital Converter的缩写。指模/数转换器或者模拟/数字转换器。是指将连续变量的模拟信号转换为离散的数字信号的器件。典型的模拟数字转换器将模拟信号转换为表示一定比例电压值的数字信号。简单地说就是将模拟电压值&#xff0c;转换成对应的肉眼…
阅读更多...
完结撒花~Matlab论文插图绘制模板第139期—罗盘图

完结撒花~Matlab论文插图绘制模板第139期—罗盘图

2021年2月2日&#xff0c;Matlab论文插图绘制模板第1期&#xff0c;启动。 三年后…… 2024年3月4日&#xff0c;Matlab论文插图绘制模板第139期&#xff0c;完结。 别的也不多说了&#xff0c;《Matlab论文插图绘制模板》1-139期精修合集&#xff0c;正加速整理制作中&…
阅读更多...
7款炫酷的前端动画特效分享（三）（附效果图及在线演示）

7款炫酷的前端动画特效分享（三）（附效果图及在线演示）

分享7款好玩的前端动画特效 其中有CSS动画、SVG动画、js小游戏等等 下方效果图可能不是特别的生动 那么你可以点击在线预览进行查看相应的动画特效 同时也是可以下载该资源的 CSS3模仿四季交替动画 基于HTML5CSS3实现的卡通风格一年四季交替动画特效 以下效果图只能体现框架的…
阅读更多...
mac下终端命令提示补全

mac下终端命令提示补全

欢迎来到我的博客&#xff0c;代码的世界里&#xff0c;每一行都是一个故事 mac下终端命令提示补全 前言Zsh-autosuggestions原理解析&#xff1a;智能提示的工作方式1. 命令历史分析&#xff1a;2. 智能提示生成&#xff1a;3. 用户交互和选择&#xff1a;4. 配置和个性化&…
阅读更多...
Java集合框架-Collection和Map

Java集合框架-Collection和Map

文章目录 Collection-单列集合特点ListArrayListLinkedListVecter SetHashSetTreeSet Map-键值对集合特点Map常用APIput添加细节remove Map的三种遍历方式1.通过键找值2.通过"键值对"3.Lambda表达式foreach源码 HashMap需求 为什么要使用泛型 泛型的优点1.集合中存储…
阅读更多...
《精益DevOps》译者序

《精益DevOps》译者序

计算机网络的发展导致了IT领域中的两个重要发展——虚拟化和分布式计算&#xff0c;云服务是虚拟化的一个直接体现&#xff0c;而微服务架构则是分布式计算的一个重要应用领域。不论是虚拟化还是分布式计算&#xff0c;都对软件工程中的研发效能提出了新的问题和挑战&#xff0…
阅读更多...
Linux x86平台获取sys_call_table

Linux x86平台获取sys_call_table

文章目录 前言一、根据call *sys_call_table来获取二、使用dump_stack三、根据MSR_LSTAR寄存器四、使用sys_close参考资料 前言 Linux 3.10.0 – x86_64 最简单获取sys_call_table符号的方法&#xff1a; # cat /proc/kallsyms | grep sys_call_table ffffffff816beee0 R sy…
阅读更多...
实名制交友-智能匹配-仿二狗交友系统-TP6+uni-APP小程序H5公众号-源码交付-支持二开！

实名制交友-智能匹配-仿二狗交友系统-TP6+uni-APP小程序H5公众号-源码交付-支持二开！

一、代码风格 通常不同的开发者具备不同的代码风格&#xff0c;但为了保证语音交友系统开发质量&#xff0c;在编码前需要进行代码风格的统一&#xff0c;通过制定一定的规则&#xff0c;约束开发者的行为。具有统一风格的代码才能更清晰、更完整、更容易理解、更方便后期维护…
阅读更多...
互联网加竞赛 车道线检测(自动驾驶 机器视觉)

互联网加竞赛 车道线检测(自动驾驶 机器视觉)

0 前言 无人驾驶技术是机器学习为主的一门前沿领域&#xff0c;在无人驾驶领域中机器学习的各种算法随处可见&#xff0c;今天学长给大家介绍无人驾驶技术中的车道线检测。 1 车道线检测 在无人驾驶领域每一个任务都是相当复杂&#xff0c;看上去无从下手。那么面对这样极其…
阅读更多...
AURIX CSA(上下文存储)介绍（续写中...）

AURIX CSA(上下文存储)介绍（续写中...）

1.CSA概述 CSA&#xff08;Context Save Areas&#xff09;上下文存储区域&#xff0c;每次函数调用、进入中断、进入Trap都会存CSA对象&#xff0c;便于退出时候恢复。每个CSA对象的大小为固定的64字节。最大可以支持分配为2^164M。 2.GPRs寄存器 32个通用寄存器(GPRs) 16个…
阅读更多...
Redis缓存【重点】

Redis缓存【重点】

参考链接 https://xiaolincoding.com/redis/cluster/cache_problem.html#%E7%BC%93%E5%AD%98%E9%9B%AA%E5%B4%A9 目录 缓存雪崩大量数据同时过期Redis 故障宕机 缓存击穿第一种方案&#xff0c;非法请求的限制第二种方案&#xff0c;缓存空值或者默认值第三种方案&#xff0c;使…
阅读更多...
回溯算法套路②组合型回溯+剪枝【基础算法精讲 15】

回溯算法套路②组合型回溯+剪枝【基础算法精讲 15】

学习地址 : 回溯算法套路②组合型回溯剪枝【基础算法精讲 15】_哔哩哔哩_bilibili 回顾 &#xff1a; 从n 个数中选出k个数的组合 &#xff0c; 可以看成是长度固定的子集 ; 剪枝技巧 : 77 . 组合 链接 : . - 力扣&#xff08;LeetCode&#xff09; 枚举下一个元素选…
阅读更多...
嵌入式中volatile关键字的使用方法

嵌入式中volatile关键字的使用方法

Hi,大家好&#xff01; 今天我们来学习一下volatile关键字&#xff0c;volatile关键字想必大家在平时编程中都见过或用过。可是小伙伴们有没有想过什么时候需要使用volatile关键字吗&#xff1f; 在C语言中&#xff0c;volatile是一个关键字&#xff0c;用于告诉编译器不要优化…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023