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

五、设计一个 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 := 0for _, 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 := 0for _, 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 mainimport "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 intfor _, 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 mainimport ("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 := 0endIndex := 0for 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 mainimport ("fmt"
)func longestIncreasingSubsequence(nums []int) int {n := len(nums)if n == 0 {return 0}dp := make([]int, n) // dp[i]表示以nums[i]结尾的最长递增子序列长度maxLen := 1          // 最长递增子序列的长度，默认为1for i := 0; i < n; i++ {dp[i] = 1 // 初始化dp数组为1for 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 mainimport ("fmt"
)// LIS 函数计算序列的最长单调递增子序列的长度
func LIS(seq []int) int {n := len(seq)lis := make([]int, n)maxLIS := 0// 初始化 lis 数组，每个元素的 LIS 长度初始为 1for 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 mainimport ("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 := 0for _, 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.hqwc.cn/news/512098.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

从Win转Mac，我的感受如何

从Win转Mac，我的感受如何

文章目录 前言MacBook优点美观动画流畅安装软件方便轻便、续航强大多数命令和Linux通用系统稳定、安全做工精美、视听体验好CPU性能较好触控板体验好 MacBook缺点缺乏部分软件部分操作逻辑不是很科学&#xff1f;玩不了多少游戏 总结与展望 前言 整个大学期间&#xff0c;我的主…
阅读更多...
JavaScript - 基础写法

JavaScript - 基础写法

JavaScript - 基础写法 1、JavaScript 的三种书写方式 内联&#xff1a; <script></script> script标签写在body结束的位置 外联(引入外部的js文件形式、cdn) <script src"js文件路径&#xff08;本地的/外部&#xff09;">这里不要写其他js代码…
阅读更多...
泊位与岸桥联合调度问题

泊位与岸桥联合调度问题

研究课题 泊位与岸桥联合调度 要解决问题 通过控制船舶航速&#xff0c;控制船舶实际到港时间&#xff1b;通过分配泊位&#xff08;靠泊位置&#xff09;和岸桥数量&#xff0c;控制该船舶实际离港时间以及同一泊位的下一艘船的开始靠泊作业时间。 研究目标 对于计划期内所有…
阅读更多...
设计模式：工厂模式 ⑤

设计模式：工厂模式 ⑤

一、思想 工厂模式&#xff1a;一个中介作用&#xff0c;在创建对象的时候。 主要作用&#xff1a;屏蔽对象创建过程&#xff0c;减少上层关注度&#xff0c;解耦并且内部方法可做更多扩展增强的处理。(比如使用映射消除if代码&#xff0c;存在多个同类对象需要抽象策略处理的时…
阅读更多...
华为配置基于VLAN限速示例

华为配置基于VLAN限速示例

华为配置基于VLAN限速示例 组网图形 图1 流量监管配置组网图 表1 Switch为上行流量提供的QoS保障 流量类型 CIR(kbps) PIR(kbps) DSCP优先级 语音 2000 10000 46 视频 4000 10000 30 数据 4000 10000 14 ^^^ 流分类简介配置注意事项组网需求配置思路操作步…
阅读更多...
solana-keygen new生成的地址与用其助记词导入钱包后的地址不一致

solana-keygen new生成的地址与用其助记词导入钱包后的地址不一致

问题&#xff1a;solana-keygen new生成的地址与用其助记词导入钱包后的地址不一致 答案&#xff1a;将输入BIP39 Passphrase这一步省了&#xff0c;也就是直接回车&#xff0c;啥也不输入。 原理&#xff1a;输入Passphrase会再进行一次加密运算&#xff08;私钥&#xff0c;…
阅读更多...
《springcloud alibaba》 三 sentinel流量控制

《springcloud alibaba》 三 sentinel流量控制

目录 sentinel准备流控规则 qpspom.xmlapllication.yml启动类controller查看结果流控提示不太友好 流控规则 线程数全局异常处理pom.xmlapplication.yml启动类实体类controller类异常类测试 关联流控模式关联jmeter 链路servicecontroller代码调整 流控效果Warm UP 熔断降级规则…
阅读更多...
【快刊合集】中科院2区SCI，Elsevier出版社，仅2个月录用！

【快刊合集】中科院2区SCI，Elsevier出版社，仅2个月录用！

【SciencePub学术】 1 计算机智能类SCI&#xff08;高质量/分区上升&#xff09; 【期刊简介】IF&#xff1a;6.5-7.0&#xff0c;JCR1区&#xff0c;中科院2区 【出版社】Elsevier出版社 【版面类型】正刊&#xff0c;仅5篇版面 【检索情况】SCIE在检&#xff0c;预计3个…
阅读更多...
AI日报：埃隆·马斯克起诉OpenAI

AI日报：埃隆·马斯克起诉OpenAI

埃隆马斯克&#xff08;ElonMusk&#xff09;正在起诉OpenAI涉嫌违约&#xff0c;声称这位ChatGPT的创建者违反了其成为非营利组织的创始承诺&#xff0c;这位科技亿万富翁表示&#xff0c;他资助并培育了这一承诺。 在一份长达46页的爆炸性投诉中&#xff0c;马斯克将OpenAI首…
阅读更多...
在三个el-form-item中的el-radio的值中取一个发送给后端怎么获取

在三个el-form-item中的el-radio的值中取一个发送给后端怎么获取

问: 请问,这段代码怎么获取:无策略,策略1,策略2的值? 回答: 问: 三个里面只可以选中一个吗? 回答:
阅读更多...
docker容器内修改容器时间

docker容器内修改容器时间

因为开发需要&#xff0c;需要临时修改容器内时间测试&#xff0c;且不影响宿主机的原始时间。调研了下相关方法&#xff0c;现做记录如下. LIBFAKETIME ​ libfaketime 可以安装在linux和macOS系统。它使用操作系统的预加载library机制&#xff0c;因此对于静态链接或setuid程…
阅读更多...
linemap | 这样好看的山峦地图真的可以快速绘制啦~~

linemap | 这样好看的山峦地图真的可以快速绘制啦~~

上一次介绍了Python绘制svg的优秀可视化库Pygal&#xff0c;今天我们介绍一下一个优秀的R地图可视化绘制包-linemap包&#xff0c;顾名思义&#xff0c;该包是是为了绘制由线组成的地图&#xff0c;其官网如下&#xff1a;https://github.com/rCarto/linemap。该包主要拥有两个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023