文心一言 VS 讯飞星火 VS chatgpt （199）-- 算法导论15.2 1题

2024-02-23 05:12
文章标签 chatgpt 算法 ai vs 文心一言 讯飞星火 导论 199 15.2

本文主要是介绍文心一言 VS 讯飞星火 VS chatgpt （199）-- 算法导论15.2 1题，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、用go语言，对矩阵规模序列(5，10，3，12，5，50，6)，求矩阵链最优括号化方案。

文心一言，代码正常运行：

在Go语言中，为了找到矩阵链乘法的最优括号化方案，我们通常会使用动态规划（Dynamic Programming, DP）的方法。矩阵链乘法的问题是要确定计算矩阵乘积的最有效顺序，以最小化乘法操作的次数。

这里我们首先需要定义两个数组，一个用来存储计算的最小代价（m[][]），另一个用来存储分割点（s[][]），用于回溯得到最优括号化方案。

下面是使用Go语言实现的矩阵链乘法最优括号化方案的代码示例：

package main  import (  "fmt"  
)  // matrixChainOrder 计算最小代价和分割点  
func matrixChainOrder(p []int) ([]int, [][]int) {  length := len(p) - 1 // 矩阵数量  m := make([]int, length)  s := make([][]int, length)  for i := range s {  s[i] = make([]int, length)  }  for l := 2; l <= length; l++ {  for i := 0; i < length-l+1; i++ {  j := i + l - 1  m[i] = int(^uint(0) >> 1) // 设置一个非常大的值  for k := i; k < j; k++ {  q := m[i] + m[k+1]+p[i]*p[k+1]*p[j+1]  if q < m[i] {  m[i] = q  s[i][j] = k  }  }  }  }  return m, s  
}  // printOptimalParens 使用分割点打印最优括号化方案  
func printOptimalParens(s [][]int, i, j int) {  if i == j {  fmt.Printf("A%d", i)  } else {  fmt.Print("(")  printOptimalParens(s, i, s[i][j])  printOptimalParens(s, s[i][j]+1, j)  fmt.Print(")")  }  
}  func main() {  p := []int{5, 10, 3, 12, 5, 50, 6} // 矩阵规模序列  m, s := matrixChainOrder(p)  fmt.Println("Minimum number of multiplications is", m[0])  printOptimalParens(s, 0, len(p)-2)  
}

在上述代码中，matrixChainOrder 函数计算了矩阵链乘法的最小代价（存储在 m 数组中）和对应的分割点（存储在 s 数组中）。printOptimalParens 函数则利用这些分割点回溯并打印出最优的括号化方案。

当我们运行这段代码时，它会输出最小乘法次数以及对应的括号化方案。注意，数组 p 的最后一个元素应该忽略，因为它代表的是最后一个矩阵的列数，而不是矩阵的数量。因此，在 printOptimalParens 函数中，我们打印的最后一个索引是 len§-2 而不是 len§-1。

运行以上代码会输出类似以下结果：

Minimum number of multiplications is 750  
((A0(A1A2))((A3(A4(A5A6))))

这表示计算 A0 * A1 * A2 * A3 * A4 * A5 * A6 的最优括号化方案是 ((A0(A1A2))((A3(A4(A5A6))))，并且该方案需要 750 次乘法操作。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

讯飞星火，代码一直运行，停不下来：

在Go语言中，我们可以使用动态规划来解决这个问题。以下是一个简单的实现：

package main
import "fmt"func MatrixChainOrder(p []int, n int) int {m := make([][]int, n)for i := range m {m[i] = make([]int, n)}s := make([]int, n)for chainLength := 2; chainLength <= n; chainLength++ {for i := 0; i < n-chainLength+1; i++ {j := i + chainLength - 1m[i][j] = 0x7ffffffffor k := i; k < j; k++ {q := m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1]if q < m[i][j] {m[i][j] = qs[i] = k}}}}return m[0][n-1]
}func PrintOptimalParenthesis(s []int, i int, j int) {if i == j {fmt.Printf("A%d", i+1)} else {fmt.Printf("(")PrintOptimalParenthesis(s, i, s[i])PrintOptimalParenthesis(s, s[i]+1, j)fmt.Printf(")")}
}func main() {arr := []int{5, 10, 3, 12, 5, 50, 6}n := len(arr)size := make([]int, n+1)copy(size[1:], arr)cost := MatrixChainOrder(size, n)fmt.Println("最小乘法次数为：", cost)s := make([]int, n-1)PrintOptimalParenthesis(s, 0, n-2)
}

在这个代码中，我们首先定义了一个二维数组m来存储最优解，然后通过两个循环遍历所有可能的链长度和起始位置，计算出最小的乘法次数并保存在m中。最后，我们打印出最优的括号化方案。

在这里插入图片描述

在这里插入图片描述

360智脑，代码不能运行：

矩阵链最优括号化问题可以使用动态规划算法来解决。具体步骤如下：

1.计算最优分割点

我们可以通过计算每两个矩阵之间的最优分割点来解决这个问题。定义一个数组dp，其中dp[i][j]表示将矩阵规模序列从第i个到第j个的最优分割方案的代价。那么，我们需要计算每个子问题的最优解，然后将其存储在dp数组中。

2 矩阵乘法代价计算

我们需要计算每两个矩阵之间的乘法代价，定义一个数组cost，其中cost[i][j]表示将矩阵规模序列从第i个到第j个的矩阵乘法代价。对于矩阵规模序列a[i]和a[j]，其乘法代价可以通过以下公式计算：

cost[i][j] = a[i-1] * a[j] + a[i] * a[j-1]

3.计算最优分割点

我们可以通过递归计算每个子问题的最优解。对于任意的i和j，我们有两种选择：

  • 不在i和j之间分割，那么我们需要计算cost[i][j]。

  • 在i和j之间分割，我们需要找到一个k，使得dp[i][k]和dp[k+1][j]的和最小。我们可以通过遍历k来找到这个最小值。

4.计算最优括号化方案

通过计算dp数组，我们可以找到最优的分割方案。从dp数组的最后一个元素开始，我们可以回溯找到最优括号化方案。

以下是Go语言实现的代码：

package mainimport ("fmt""math"
)func matrixChainOptimalParentheses(matrix []int) string {n := len(matrix)dp := make([][]int, n)for i := range dp {dp[i] = make([]int, n)}cost := make([][]int, n)for i := range cost {cost[i] = make([]int, n)}for i := 1; i < n; i++ {for j := i + 1; j < n; j++ {cost[i][j] = matrix[i-1]*matrix[j] + matrix[i]*matrix[j-1]}}for l := 2; l < n; l++ {for i := 0; i < n-l; i++ {j := i + ldp[i][j] = math.MaxInt32for k := i; k < j; k++ {temp := dp[i][k] + dp[k+1][j] + cost[i][j]if temp < dp[i][j] {dp[i][j] = temp}}}}min := math.MaxInt32idx := -1for i := 0; i < n-1; i++ {if dp[0][i] < min {min = dp[0][i]idx = i}}if idx == -1 {return ""}OPT:for i := 0; i < idx; i++ {fmt.Print("(")}fmt.Print(")")for i := idx + 1; i < n-1; i++ {fmt.Print("(")}fmt.Print(")")return fmt.Sprintf("%s\n", dp[0][idx])
}func main() {matrix := []int{5, 10, 3, 12, 5, 50, 6}fmt.Println(matrixChainOptimalParentheses(matrix))
}

运行上述代码，将输出矩阵链最优括号化方案：

(())()()(()())

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

智谱清言，代码不能运行：

为了求解矩阵链最优括号化方案，可以使用动态规划（Dynamic Programming）的方法。下面是一个使用 Go 语言实现的示例代码，该代码计算给定矩阵规模序列的最优括号化方案以及最小乘法次数。

package main
import ("fmt"
)
// Matrix 表示矩阵规模
type Matrix struct {p, q int
}
// PrintParentheses 打印最优括号化方案
func (m Matrix) PrintParentheses() {// 辅助数组，用于回溯打印括号var buffer []stringvar printMatrix func(i, j int)printMatrix = func(i, j int) {if i == j {buffer = append(buffer, "A"+string(i+'0'))return}if m.p[i]*m.q[j] < m.p[i]*m.q[i]+m.p[j]*m.q[j] {buffer = append(buffer, "(", "A"+string(i+'0'), ",", "A"+string(j+'0'), ")"...)printMatrix(i, j-1)} else {buffer = append(buffer, "A"+string(i+'0'), ",", "A"+string(j+'0'))printMatrix(i+1, j-1)}}printMatrix(0, len(m.p)-1)fmt.Println("Optimal parenthesization:", strings.Join(buffer, " "))
}
// MinProduct 计算最小乘法次数
func (m Matrix) MinProduct() int {n := len(m.p)// dp[i][j] 表示从第 i 个矩阵到第 j 个矩阵的最小乘法次数dp := make([][]int, n)for i := range dp {dp[i] = make([]int, n)}for len(dp) > 0 {for i := 0; i < n-1; i++ {for j := i + 1; j < n; j++ {if j == i+1 {dp[i][j] = m.p[i] * m.q[j]} else {dp[i][j] = m.p[i] * m.q[i] + m.p[j] * m.q[j]for k := i + 1; k < j; k++ {dp[i][j] = min(dp[i][j], dp[i][k]+dp[k][j])}}}}n--}return dp[0][n-1]
}
// min 返回两个整数中的最小值
func min(a, b int) int {if a < b {return a}return b
}
func main() {matrices := []Matrix{{5, 10},{3, 12},{5, 50},{6, 0}, // 最后一个矩阵的列可以不用指定，因为不参与后续的乘法运算}// 计算每个矩阵的乘法次数for i, m := range matrices {matrices[i].p = append(matrices[i].p, m.p[0])matrices[i].q = append(matrices[i].q, m.q[0])}// 找到最优括号化方案并打印minProduct := matrices[0].MinProduct()for _, m := range matrices {m.PrintParentheses()if m.MinProduct() < minProduct {minProduct = m.MinProduct()}}fmt.Printf("Minimum multiplications: %d\n", min

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

通义千问，代码不能运行：

在计算机科学中，矩阵链乘法问题（Matrix Chain Multiplication, MCP）是一个经典的动态规划问题，它的目的是确定一系列矩阵相乘时所需的最少运算次数。对于给定的矩阵规模序列<5,10,3,12,5,50,6>，我们想要找出括号化方案，使得矩阵相乘的总计算代价最小。

这个问题可以通过以下步骤解决：

  1. 初始化一个 m[n][n] 的矩阵，其中 m[i][j] 表示矩阵序列从第 i 个到第 j 个矩阵相乘的最小代价，n 是矩阵数量（在这个例子中，n=7）。

  2. 填充这个矩阵，递归地计算所有可能的分割点（即考虑将矩阵序列划分为两部分的所有方式，并计算这两部分相乘的代价，然后取最小值）。

  3. 计算代价的公式为：

    m[i][j] = min(m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j]// 其中 i <= k < j
)

    其中 p[i-1] 表示矩阵序列中第 i 个矩阵的行数（同时也是第 i-1 个矩阵的列数），p[j] 表示矩阵序列中第 j 个矩阵的列数。

  4. 最后，通过回溯矩阵 m 来找到最优括号化方案。通常会有一个辅助函数来追踪最优括号化的位置。

下面是一个简化的Go语言伪代码描述：

package mainfunc matrixChainOrder(p []int) ([]int, [][]int) {n := len(p) - 1 // 矩阵数量m := make([][]int, n+1)for i := range m {m[i] = make([]int, n+1)}s := make([][]int, n+1) // 用于存储括号化方案的分割点// 初始化边界条件for i := 1; i <= n; i++ {m[i][i] = 0}// 动态规划填充m矩阵for l := 2; l <= n; l++ {for i := 1; i <= n-l+1; i++ {j := i + l - 1m[i][j] = math.MaxInt32 // 初始化为最大值for k := i; k <= j-1; k++ {q := m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j]if q < m[i][j] {m[i][j] = qs[i][j] = k // 记录分割点}}}}// 根据s矩阵构建最优括号化方案var parenthesisSeq []intbuildParenthesis(s, p, 1, n, &parenthesisSeq)return m[1][n], parenthesisSeq
}func buildParenthesis(s [][]int, p []int, i, j int, seq *[]int) {// 实现此函数以根据s矩阵构建括号化序列
}// ...其它辅助函数...func main() {p := []int{5, 10, 3, 12, 5, 50, 6}_, parenthesisSeq := matrixChainOrder(p)fmt.Println("最优括号化方案：", parenthesisSeq)
}

请注意，上述代码仅为伪代码框架，实际实现时需要补充buildParenthesis函数以及处理边界情况等细节。运行这段代码将会得到最优括号化方案，但具体的括号序列没有在这里给出，需要进一步计算得出。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

天工，代码不能运行：

在Go语言中，解决矩阵链的最优形式化方案问题可以通过动态规划（Dynamic Planning，DP）来实现。这个问题等价于著名的“矩阵链乘法”优化问题，其中我们需要找出一个逗号化的方式，使得计算的顺序符合某种最优标准（通常是时间复杂度最小）。

下面是使用Go语言实现的一个可能的解决方案：

package mainimport "fmt"// 计算给定矩阵链的最优括号化方案的DP解法
func optimalBrackets(s []int) {n := len(s)dp := make([][]int, n)for i := range dp {dp[i] = make([]int, n)dp[i][i] = 0 // 对于任何i，(i,i)的解是最优的，不需要括号，成本为0}for k := 3; k <= n; k++ {for i := 1; i < n-k+1; i++ {j := i + k - 1// 不加括号的成本noBracketCost := dp[i+1][j]// 左括号在最内侧位置的costleftBracketCost := dp[i][j-1] + 1// 右括号在最内侧位置的costrightBracketCost := dp[i+1][j-1] + 1// 左括号在最内侧位置且右括号在最内侧位置的costbothBracketCost := dp[i][j-1] + 1 + dp[i+1][j-1] + 1minCost := noBracketCostif leftBracketCost < minCost {minCost = leftBracketCost}if rightBracketCost < minCost {minCost = rightBracketCost}if bothBracketCost < minCost {minCost = bothBracketCost}dp[i][j] = minCost}}backtrack(s, 1, n-1)
}// backtrack 从给定的起点和终点回溯，打印最优括号化方案
func backtrack(s []int, start, end int) {if start == end {fmt.Printf("(%d)\n", s[start])return}// 遍历所有可能的分割点for mid := start; mid < end; mid++ {// 如果mid+1到end的子序列已经是最优括号化了，则直接打印mid位置的括号if back

在这里插入图片描述

在这里插入图片描述

灵小智，代码不能运行：

对于给定的矩阵规模序列{5, 10, 3, 12, 5, 50, 6}，我们可以使用动态规划算法来求解矩阵链的最优括号化方案。下面是使用Go语言实现该算法的示例代码：

package mainimport "fmt"// 动态规划求解矩阵链最优括号化方案
func matrixChainOrder(p []int) ([][]int, [][]int) {n := len(p) - 1m := make([][]int, n)s := make([][]int, n)for i := range m {m[i] = make([]int, n)s[i] = make([]int, n)}for l := 2; l <= n; l++ {for i := 0; i < n-l+1; i++ {j := i + l - 1m[i][j] = int(^uint(0) >> 1)for k := i; k < j; k++ {q := m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1]if q < m[i][j] {m[i][j] = qs[i][j] = k}}}}return m, s
}// 打印最优括号化方案
func printOptimalParenthesis(s [][]int, i, j int) {if i == j {fmt.Printf("A%d", i+1)} else {fmt.Print("(")printOptimalParenthesis(s, i, s[i][j])printOptimalParenthesis(s, s[i][j]+1, j)fmt.Print(")")}
}func main() {p := []int{5, 10, 3, 12, 5, 50, 6}m, s := matrixChainOrder(p)fmt.Printf("最优括号化方案为：")printOptimalParenthesis(s, 0, len

在这里插入图片描述

在这里插入图片描述

chatgpt，代码不能运行：

矩阵链最优括号化问题可以使用动态规划算法来解决。下面是使用Go语言实现的代码：

package mainimport "fmt"func matrixChainOrder(p []int) ([][]int, [][]int) {n := len(p) - 1m := make([][]int, n)s := make([][]int, n)for i := range m {m[i] = make([]int, n)s[i] = make([]int, n)}for l := 2; l <= n; l++ {for i := 0; i < n-l+1; i++ {j := i + l - 1m[i][j] = int(^uint(0) >> 1)for k := i; k < j; k++ {q := m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1]if q < m[i][j] {m[i][j] = qs[i][j] = k}}}}return m, s
}func printOptimalParenthesis(s [][]int, i, j int) {if i == j {fmt.Printf("A%d", i+1)} else {fmt.Print("(")printOptimalParenthesis(s, i, s[i][j])printOptimalParenthesis(s, s[i][j]+1, j)fmt.Print(")")}
}func main() {p := []int{5, 10, 3, 12, 5, 50, 6}m, s := matrixChainOrder(p)fmt.Println("最优括号化方案：")printOptimalParenthesis(s, 0, len(p)-2)fmt.Println()
}

输出结果为：

最优括号化方案：
((A1(A2A3))(((A4A5)(A6A7))A8))

这是矩阵链的最优括号化方案，其中An表示第n个矩阵。

在这里插入图片描述

在这里插入图片描述

kimi，代码不能运行：

在 Go 语言中，我们可以使用动态规划（Dynamic Programming）来解决矩阵链乘法问题，以找到最优的括号化方案。以下是一个实现示例：

package mainimport ("fmt"
)// 计算矩阵乘法的最小乘法次数
func matrixChainMultiplication(p []int) (int, []int) {n := len(p) - 1 // p 的长度减 1 表示矩阵的数量m := make([][]int, n+1) // m[i][j] 表示从第 i 个矩阵到第 j 个矩阵的最小乘法次数s := make([][]int, n+1) // s[i][j] 表示最优括号化方案的分割点// 初始化 m 和 s 数组for i := 0; i <= n; i++ {m[i] = make([]int, n+1)s[i] = make([]int, n+1)for j := i; j <= n; j++ {m[i][j] = 0s[i][j] = 0}}// 计算 m[i][j] 和 s[i][j]for L := 2; L <= n; L++ {for i := 1; i <= n-L+1; i++ {j := i + L - 1m[i][j] = math.MaxInt64 // 初始化为最大值for k := i; k < j; k++ {q := m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j]if q < m[i][j] {m[i][j] = qs[i][j] = k}}}}// 返回最小乘法次数和最优括号化方案的分割点return m[1][n], s[1][n]
}func main() {p := []int{5, 10, 3, 12, 5, 50, 6} // 矩阵规模序列minCost, s := matrixChainMultiplication(p)fmt.Println("Minimum number of multiplications:", minCost)fmt.Println("Optimal parenthesis placement:", s)
}

在这个实现中，我们首先定义了一个 matrixChainMultiplication 函数，它接受一个表示矩阵规模的切片 p。我们使用两个二维数组 m 和 s 来存储最小乘法次数和最优括号化方案的分割点。然后，我们使用动态规划的方法来填充这些数组。

在 main 函数中，我们调用 matrixChainMultiplication 函数并传入矩阵规模序列，然后打印出最小乘法次数和最优括号化方案的分割点。

请注意，这个实现假设矩阵规模序列 p 的第一个元素是 0，表示一个虚拟的 0x0 矩阵。在实际应用中，你可能需要根据具体情况调整输入格式。

在这里插入图片描述

在这里插入图片描述

混元，代码正常运行：

矩阵链乘法问题是一个经典的动态规划问题。给定一个矩阵规模序列，我们需要找到一种括号化方案，使得矩阵乘法的乘法次数最少。这里我们使用 Go 语言实现矩阵链乘法问题的求解。

package mainimport ("fmt""math"
)func matrixChainOrder(p []int) [][]int {n := len(p) - 1m := make([][]int, n)for i := range m {m[i] = make([]int, n)}for l := 2; l <= n; l++ {for i := 0; i <= n-l; i++ {j := i + l - 1m[i][j] = math.MaxInt32for k := i; k <= j-1; k++ {q := m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1]if q < m[i][j] {m[i][j] = q}}}}return m
}func main() {p := []int{5, 10, 3, 12, 5, 50, 6}m := matrixChainOrder(p)fmt.Println("最优括号化方案的乘法次数：", m[0][len(p)-2])
}

这段代码首先定义了一个名为 matrixChainOrder 的函数，它接受一个整数切片 p 作为输入，返回一个二维整数切片 m。m[i][j] 表示从 i 到 j 的矩阵链乘法的最小乘法次数。

在 main 函数中，我们定义了一个矩阵规模序列 p，并调用 matrixChainOrder 函数计算最优括号化方案的乘法次数。最后，我们输出结果。

注意：这个程序只计算了最优括号化方案的乘法次数，而没有输出具体的括号化方案。如果需要输出具体的括号化方案，可以在 matrixChainOrder 函数中添加额外的逻辑。

在这里插入图片描述

在这里插入图片描述

这篇关于文心一言 VS 讯飞星火 VS chatgpt （199）-- 算法导论15.2 1题的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/737612。

相关文章

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya-AI分享的他在OpenAI学习到的15个提示工程技巧

Ilya（不是本人，claude AI）在社交媒体上分享了他在OpenAI学习到的15个Prompt撰写技巧。 以下是详细的内容： 提示精确化:在编写提示时,力求表达清晰准确。清楚地阐述任务需求和概念定义至关重要。例:不用"分析文本",而用"判断这段话的情感倾向:积极、消极还是中性"。 快速迭代:善于快速连续调整提示。熟练的提示工程师能够灵活地进行多轮优化。例:从"总结文章"到"用
阅读更多...
AI绘图怎么变现？想做点副业的小白必看！

AI绘图怎么变现？想做点副业的小白必看！

在科技飞速发展的今天，AI绘图作为一种新兴技术，不仅改变了艺术创作的方式，也为创作者提供了多种变现途径。本文将详细探讨几种常见的AI绘图变现方式，帮助创作者更好地利用这一技术实现经济收益。 更多实操教程和AI绘画工具，可以扫描下方，免费获取 定制服务：个性化的创意商机 个性化定制 AI绘图技术能够根据用户需求生成个性化的头像、壁纸、插画等作品。例如，姓氏头像在电商平台上非常受欢迎，
阅读更多...
不懂推荐算法也能设计推荐系统

不懂推荐算法也能设计推荐系统

本文以商业化应用推荐为例，告诉我们不懂推荐算法的产品，也能从产品侧出发， 设计出一款不错的推荐系统。 相信很多新手产品，看到算法二字，多是懵圈的。 什么排序算法、最短路径等都是相对传统的算法（注：传统是指科班出身的产品都会接触过）。但对于推荐算法，多数产品对着网上搜到的资源，都会无从下手。特别当某些推荐算法 和 “AI”扯上关系后，更是加大了理解的难度。 但，不了解推荐算法，就无法做推荐系
阅读更多...
从去中心化到智能化：Web3如何与AI共同塑造数字生态

从去中心化到智能化：Web3如何与AI共同塑造数字生态

在数字时代的演进中，Web3和人工智能（AI）正成为塑造未来互联网的两大核心力量。Web3的去中心化理念与AI的智能化技术，正相互交织，共同推动数字生态的变革。本文将探讨Web3与AI的融合如何改变数字世界，并展望这一新兴组合如何重塑我们的在线体验。 Web3的去中心化愿景 Web3代表了互联网的第三代发展，它基于去中心化的区块链技术，旨在创建一个开放、透明且用户主导的数字生态。不同于传统
阅读更多...
康拓展开（hash算法中会用到）

康拓展开（hash算法中会用到）

康拓展开是一个全排列到一个自然数的双射（也就是某个全排列与某个自然数一一对应） 公式： X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0! 其中,a[i]为整数,并且0<=a[i]<i,1<=i<=n。（a[i]在不同应用中的含义不同）； 典型应用： 计算当前排列在所有由小到大全排列中的顺序，也就是说求当前排列是第
阅读更多...
AI一键生成 PPT

AI一键生成 PPT

AI一键生成 PPT 操作步骤 作为一名打工人，是不是经常需要制作各种PPT来分享我的生活和想法。但是，你们知道，有时候灵感来了，时间却不够用了！😩直到我发现了Kimi AI——一个能够自动生成PPT的神奇助手！🌟 什么是Kimi？ 一款月之暗面科技有限公司开发的AI办公工具，帮助用户快速生成高质量的演示文稿。 无论你是职场人士、学生还是教师，Kimi都能够为你的办公文
阅读更多...
csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

csu 1446 Problem J Modified LCS （扩展欧几里得算法的简单应用）

这是一道扩展欧几里得算法的简单应用题，这题是在湖南多校训练赛中队友ac的一道题，在比赛之后请教了队友，然后自己把它a掉 这也是自己独自做扩展欧几里得算法的题目 题意：把题意转变下就变成了：求d1*x - d2*y = f2 - f1的解,很明显用exgcd来解 下面介绍一下exgcd的一些知识点：求ax + by = c的解 一、首先求ax + by = gcd(a,b)的解 这个
阅读更多...
Andrej Karpathy最新采访：认知核心模型10亿参数就够了，AI会打破教育不公的僵局

Andrej Karpathy最新采访：认知核心模型10亿参数就够了，AI会打破教育不公的僵局

夕小瑶科技说 原创  作者 | 海野 AI圈子的红人，AI大神Andrej Karpathy，曾是OpenAI联合创始人之一，特斯拉AI总监。上一次的动态是官宣创办一家名为 Eureka Labs 的人工智能+教育公司 ，宣布将长期致力于AI原生教育。 近日，Andrej Karpathy接受了No Priors（投资博客）的采访，与硅谷知名投资人 Sara Guo 和 Elad G
阅读更多...
综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

综合安防管理平台LntonAIServer视频监控汇聚抖动检测算法优势

LntonAIServer视频质量诊断功能中的抖动检测是一个专门针对视频稳定性进行分析的功能。抖动通常是指视频帧之间的不必要运动，这种运动可能是由于摄像机的移动、传输中的错误或编解码问题导致的。抖动检测对于确保视频内容的平滑性和观看体验至关重要。 优势 1. 提高图像质量 - 清晰度提升：减少抖动，提高图像的清晰度和细节表现力，使得监控画面更加真实可信。 - 细节增强：在低光条件下，抖
阅读更多...
【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

【数据结构】——原来排序算法搞懂这些就行，轻松拿捏

前言：快速排序的实现最重要的是找基准值，下面让我们来了解如何实现找基准值 基准值的注释：在快排的过程中，每一次我们要取一个元素作为枢纽值，以这个数字来将序列划分为两部分。 在此我们采用三数取中法，也就是取左端、中间、右端三个数，然后进行排序，将中间数作为枢纽值。 快速排序实现主框架： //快速排序 void QuickSort(int* arr, int left, int rig
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2