八大常用算法思想及示例（Swift实现）

木叶丸2023-12-03 14:59

数据结构跟算法的关系

数据结构和算法是计算机科学中两个密切相关的概念。

数据结构是一种组织和存储数据的方式，它定义了数据元素之间的关系和操作。常见的数据结构包括数组、链表、栈、队列、树、图等。数据结构的选择和设计对于解决问题和实现算法非常重要，不同的数据结构适用于不同类型的问题和操作。

算法是解决问题的一系列步骤和规则。它描述了如何利用给定的输入数据来产生期望的输出结果。算法可以基于不同的思想和技巧，如枚举、递推、递归、分治、动态规划、贪心、回溯等。算法的设计和优化可以提高问题的求解效率和准确性。

数据结构和算法之间存在密切的关系。数据结构提供了存储和组织数据的方式，而算法则利用数据结构来解决问题。选择合适的数据结构可以提供高效的数据操作和访问，而设计高效的算法可以利用数据结构的特性来实现快速和准确的问题求解。

在实际应用中，数据结构和算法通常是相互依赖的。合理选择和设计数据结构可以为算法提供更好的基础，而高效的算法也可以充分发挥数据结构的优势。因此，深入理解和掌握数据结构和算法对于计算机科学和软件开发非常重要。

枚举

枚举算法是一种穷举搜索的算法，通过列举问题的所有可能状态，逐一与目标状态进行比较，从而找到满足条件的解。枚举算法的基本思想是将问题的解空间进行穷举，找出所有可能的解，并在逐一列举的过程中进行判断和筛选。

枚举算法的优点是简单易懂，适用于问题规模较小的情况。然而，枚举算法的缺点是运算量较大，当问题规模增大时，执行速度会变慢。

枚举算法常用于解决一些简单的数学问题，如百钱买百鸡问题和生理周期问题。在百钱买百鸡问题中，通过枚举公鸡、母鸡和小鸡的数量，找到满足条件的解[1]。在生理周期问题中，通过枚举时间，找到下一次三个高峰同天的时间[2]。

总结枚举算法的思想：

  1. 简单数学模型：将问题转化为简单的数学模型，尽量减少变量数量，使其相互独立。
  2. 减少搜索空间：利用已有知识，缩小变量的取值范围，避免不必要的计算。
  3. 合适的搜索顺序：按照条件表达式的顺序进行搜索，保持搜索顺序与数学模型一致。

实例：百钱买百鸡

问题描述：公鸡每只5元，母鸡每只3元，三只小鸡1元，用100元买100只鸡，问公鸡、母鸡、小鸡各多少只？

算法分析：利用枚举法解决该问题，以三种鸡的个数为枚举对象，穷举各种鸡的个数，并根据总数和总花费的条件判断是否是问题的解。

以下是百钱买百鸡问题的Swift实现代码：

swift 复制代码 
func buyChicken() {
    for x in 0...20 {
        for y in 0...33 {
            let z = 100 - x - y
            if (5 * x + 3 * y + z / 3) == 100 && z % 3 == 0 {
                print("公鸡的数量：\(x) 只")
                print("母鸡的数量：\(y) 只")
                print("小鸡的数量：\(z) 只")
                print()
            }
        }
    }
}

buyChicken()

这段代码使用了嵌套循环来遍历所有可能的解法。其中，x表示公鸡的数量，y表示母鸡的数量，z表示小鸡的数量。通过计算满足条件的x、y和z的值，即可得到公鸡、母鸡和小鸡的数量。

运行结果如下：

公鸡的数量：0 只
母鸡的数量：25 只
小鸡的数量：75 只

公鸡的数量：4 只
母鸡的数量：18 只
小鸡的数量：78 只

公鸡的数量：8 只
母鸡的数量：11 只
小鸡的数量：81 只

公鸡的数量：12 只
母鸡的数量：4 只
小鸡的数量：84 只

递推

递推算法是一种通过已知条件和状态之间的关系，逐步推导出结果的算法思想。它可以分为顺推法和逆推法两种。

  1. 顺推法：顺推法从已知的初始条件出发，通过不同状态之间的关系，逐步推导出结果。一个经典的例子是斐波那契数列，其中每一项等于前两项之和。通过顺推法，我们可以通过已知的初始条件，计算出任意一项的值[1]。

  2. 逆推法：逆推法是顺推法的逆过程。它从已知的结果出发，通过状态之间的关系，逐步推导出问题的初始条件。一个例子是求解存款问题，通过已知的最后一个月的存款数，可以逆推出前面各个月的存款数[1]。

顺推法和逆推法都是递推算法的应用，它们通过找到问题不同状态之间的关系，解决问题。它们的不同之处在于顺推法是从初始条件出发，逐步推导出结果，而逆推法是从结果出发，逐步推导出初始条件。

实例：斐波那契数列

斐波那契数列是一个经典的数列，它的每个数都是前两个数的和。下面是斐波那契数列的Swift实现代码：

swift 复制代码 
// 使用递归实现斐波那契数列
func fibonacciRecursive(_ n: Int) -> Int {
    if n <= 1 {
        return n
    }
    return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2)
}

// 使用循环实现斐波那契数列
func fibonacciIterative(_ n: Int) -> Int {
    if n <= 1 {
        return n
    }
    var a = 0
    var b = 1
    for _ in 2...n {
        let temp = a + b
        a = b
        b = temp
    }
    return b
}

// 测试代码
let n = 10
let recursiveResult = fibonacciRecursive(n)
let iterativeResult = fibonacciIterative(n)
print("递归实现：第 \(n) 个斐波那契数是 \(recursiveResult)")
print("循环实现：第 \(n) 个斐波那契数是 \(iterativeResult)")

这段代码中，我们提供了两种实现斐波那契数列的方法。fibonacciRecursive函数使用递归的方式实现，而fibonacciIterative函数使用循环的方式实现。你可以根据需要选择其中一种方法来计算斐波那契数列的第n个数。

递归

递归算法是一种解决问题的方法，其中函数在执行过程中调用自身。它将一个大问题分解为一个或多个相同类型的子问题，并通过解决这些子问题来解决原始问题。

递归算法的基本思想是通过不断地调用自身来解决问题，直到达到基本情况（递归终止条件），然后逐步返回结果，最终得到问题的解。

递归算法通常包含两个关键要素：

  1. 递归调用：在函数内部调用自身来解决子问题。
  2. 递归终止条件：定义一个或多个基本情况，当满足这些条件时，递归调用停止，返回结果。

递归算法可以用于解决许多问题，如计算阶乘、斐波那契数列、树的遍历等。它可以简化问题的表达和解决过程，但需要注意递归深度和性能方面的考虑，以避免出现栈溢出或效率低下的情况。

总结起来，递归算法是一种通过将问题分解为子问题并通过递归调用自身来解决问题的方法。它需要定义递归调用和递归终止条件，并可以用于解决各种问题。

实例：汉诺塔问题

汉诺塔问题是经典的递归问题，它涉及将一堆盘子从一个柱子移动到另一个柱子，同时遵循以下规则：

  1. 每次只能移动一个盘子。
  2. 大盘子不能放在小盘子上面。

下面是汉诺塔问题的Swift实现代码：

swift 复制代码 
func hanoi(n: Int, from: String, to: String, aux: String) {
    if n == 1 {
        print("Move disk 1 from \(from) to \(to)")
    } else {
        hanoi(n: n-1, from: from, to: aux, aux: to)
        print("Move disk \(n) from \(from) to \(to)")
        hanoi(n: n-1, from: aux, to: to, aux: from)
    }
}

let numberOfDisks = 3
hanoi(n: numberOfDisks, from: "A", to: "C", aux: "B")

在上面的代码中，hanoi函数接受四个参数：n表示盘子的数量，from表示起始柱子，to表示目标柱子，aux表示辅助柱子。函数首先检查是否只有一个盘子，如果是，则直接将盘子从起始柱子移动到目标柱子。否则，它会先将n-1个盘子从起始柱子移动到辅助柱子，然后将最后一个盘子从起始柱子移动到目标柱子，最后再将n-1个盘子从辅助柱子移动到目标柱子。

在示例中，我们调用hanoi函数来解决3个盘子的汉诺塔问题，起始柱子为"A"，目标柱子为"C"，辅助柱子为"B"。

分治

分治算法是一种解决问题的算法思想，它将一个大问题分解为多个相同或相似的子问题，然后递归地解决这些子问题，最后将子问题的解合并得到原问题的解。

分治算法的基本思想可以总结为以下三个步骤：

  1. 分解（Divide）：将原问题划分为多个相同或相似的子问题。
  2. 解决（Conquer）：递归地解决每个子问题。如果子问题足够小，可以直接求解。
  3. 合并（Combine）：将子问题的解合并得到原问题的解。

分治算法通常适用于具有以下特点的问题：

  1. 问题可以被划分为多个相同或相似的子问题。
  2. 子问题的解可以合并得到原问题的解。
  3. 子问题的解可以独立地求解，没有相互依赖关系。

分治算法的典型应用包括归并排序、快速排序和二分查找等。它可以将复杂的问题分解为简单的子问题，通过递归求解子问题并合并子问题的解来得到原问题的解。分治算法的优势在于可以降低问题的复杂度，并提高算法的效率。

总结起来，分治算法是一种将问题分解为子问题、递归求解子问题并合并子问题解的算法思想。它适用于可以划分为多个相同或相似子问题的问题，并可以降低问题的复杂度。

实例：归并排序

以下是使用Swift实现的归并排序算法的代码，附有注释说明：

swift 复制代码 
func mergeSort(_ array: [Int]) -> [Int] {
    // Base case: if the array has only one element, return it
    guard array.count > 1 else { return array }
    
    // Split the array in half
    let middleIndex = array.count / 2
    let leftArray = Array(array[0..<middleIndex])
    let rightArray = Array(array[middleIndex..<array.count])
    
    // Recursively call mergeSort on the left and right halves
    let sortedLeft = mergeSort(leftArray)
    let sortedRight = mergeSort(rightArray)
    
    // Merge the sorted left and right halves
    return merge(sortedLeft, sortedRight)
}

func merge(_ left: [Int], _ right: [Int]) -> [Int] {
    var leftIndex = 0
    var rightIndex = 0
    var orderedArray: [Int] = []
    
    // Compare elements from the left and right arrays and append the smaller one to the ordered array
    while leftIndex < left.count && rightIndex < right.count {
        if left[leftIndex] < right[rightIndex] {
            orderedArray.append(left[leftIndex])
            leftIndex += 1
        } else {
            orderedArray.append(right[rightIndex])
            rightIndex += 1
        }
    }
    
    // Append the remaining elements from the left array
    while leftIndex < left.count {
        orderedArray.append(left[leftIndex])
        leftIndex += 1
    }
    
    // Append the remaining elements from the right array
    while rightIndex < right.count {
        orderedArray.append(right[rightIndex])
        rightIndex += 1
    }
    
    return orderedArray
}

let array = [7, 2, 6, 3, 9]
let sortedArray = mergeSort(array)
print(sortedArray) // Output: [2, 3, 6, 7, 9]

以上代码实现了归并排序算法。归并排序是一种分治算法，通过将数组分成两半，递归地对左右两半进行排序，然后将排序后的两半合并得到最终的有序数组。在合并过程中，比较左右两个数组的元素，并按照从小到大的顺序将它们添加到有序数组中。最终得到的有序数组即为归并排序的结果。

动态规划

动态规划算法是一种解决多阶段决策问题的算法思想，它通过将问题分解为多个子问题，并保存子问题的解来避免重复计算，从而高效地求解问题。

动态规划算法的基本思想可以总结为以下几个步骤：

  1. 定义状态：将原问题划分为多个阶段，并定义每个阶段的状态。
  2. 确定状态转移方程：根据问题的性质和约束条件，确定不同阶段之间的状态转移关系。
  3. 初始化边界条件：对于最初的阶段，确定初始状态的值。
  4. 递推求解：根据状态转移方程，从初始阶段开始逐步求解每个阶段的状态，直到达到最终阶段。
  5. 求解最优解：根据求解得到的各个阶段的状态，确定最优解。

动态规划算法通常适用于具有以下特点的问题：

  1. 问题具有最优子结构：问题的最优解可以由子问题的最优解推导得到。
  2. 子问题重叠：问题的子问题之间存在重叠，即同一个子问题可能会被多次求解。

动态规划算法的优势在于通过保存子问题的解来避免重复计算，从而提高算法的效率。它常用于求解最优化问题，如最长公共子序列、背包问题、最短路径等。

总结起来，动态规划算法是一种通过将问题分解为多个子问题，并保存子问题的解来避免重复计算的算法思想。它适用于具有最优子结构和子问题重叠特点的问题，并通过递推求解每个阶段的状态来求解最优解。

实例：最长公共子序列

两个字符串的最长公共子序列（LCS）是指这两个字符串中最长的有相同顺序的子序列。

举例说明一下，"Hello World" 和 "Bonjour le monde" 的 LCS 是 "oorld"。如果从左到右依次扫过字符串，你会发现 o、 o、 r 、l、 d 在两个字符串中出现的顺序是一样的。

其他的子序列为 "ed" 和 "old"，但是它们都比 "oorld" 要短。

注意：不要和最长公共字符串混淆了，后者必须是两个字符串的子字符串，也就是字符是直接相邻的。但对公共序列来说，字符之间并不是连续，但是它们必须有相同的顺序。

计算两个字符串 a 和 b 的 LCS 方法之一是通过动态规划和回溯法。

动态规划算法计算最长公共子序列长度的示例代码：

swift 复制代码 
func longestCommonSubsequence(_ text1: String, _ text2: String) -> Int {
    let m = text1.count
    let n = text2.count
    
    var dp = [[Int]](repeating: [Int](repeating: 0, count: n + 1), count: m + 1)
    
    let text1Array = Array(text1)
    let text2Array = Array(text2)
    
    for i in 1...m {
        for j in 1...n {
            if text1Array[i - 1] == text2Array[j - 1] {
                dp[i][j] = dp[i - 1][j - 1] + 1
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
            }
        }
    }
    
    return dp[m][n]
}

这段代码使用一个二维数组 dp 来保存最长公共子序列的长度。其中 dp[i][j] 表示 text1 的前 i 个字符和 text2 的前 j 个字符的最长公共子序列的长度。通过遍历两个字符串，如果当前字符相等，则最长公共子序列的长度加一；如果不相等，则取前一个字符的最长公共子序列长度的最大值。最后返回 dp[m][n]，即 text1 和 text2 的最长公共子序列的长度。

贪心

贪心算法是一种常见的算法思想，它在每一步选择中都采取当前状态下最优的选择，以期望最终能够得到全局最优解。贪心算法通常适用于一些具有最优子结构性质的问题，即通过局部最优解能够推导出全局最优解。

贪心算法的基本思路可以总结为以下几个步骤：

  1. 定义问题的解空间，并确定问题的最优解的性质。
  2. 根据问题的最优解性质，设计一个选择策略，每次选择当前状态下的最优解。
  3. 利用选择策略，逐步构建问题的解，直到得到全局最优解。

贪心算法的优点是简单、高效，适用于一些具有贪心选择性质的问题。然而，贪心算法并不适用于所有问题，因为它只考虑了当前状态下的最优选择，而没有考虑到全局的影响。在某些情况下，贪心算法可能会得到次优解或者不正确的结果。

因此，在使用贪心算法时，需要仔细分析问题的性质，确保贪心选择策略能够得到全局最优解。有时候，需要结合其他算法思想，如动态规划或回溯法，来解决问题。

总而言之，贪心算法是一种简单而高效的算法思想，适用于一些具有最优子结构性质的问题。但在使用贪心算法时，需要注意问题的性质，确保贪心选择策略能够得到全局最优解。

实例：旅行推销员问题

旅行推销员问题（Traveling Salesman Problem，TSP）是一个经典的组合优化问题，要求找到一条最短的路径，使得一个推销员可以访问一系列城市并返回起始城市。

贪心算法是一种近似解决TSP的方法。它基于贪心思想，每次选择最优的局部决策，希望通过这种方式达到全局最优解。下面是一个使用贪心算法思想解决TSP的示例：

  1. 初始化：选择一个起始城市作为当前城市，并将其标记为已访问。
  2. 重复以下步骤，直到所有城市都被访问：
    • 在当前城市中，选择距离最近且未访问过的城市作为下一个城市。
    • 将下一个城市标记为已访问。
    • 更新当前城市为下一个城市。
    • 将当前城市添加到路径中。
  3. 将最后一个城市与起始城市相连，形成闭合路径。

以下是使用贪心算法思想解决旅行推销员问题的 Swift 代码实现：

swift 复制代码 
import Foundation

func tspGreedy(adjacencyMatrix: [[Int]]) -> [Int] {
    let numCities = adjacencyMatrix.count
    var visited = [Bool](repeating: false, count: numCities)
    var path = [Int]()
    var currentCity = 0
    
    path.append(currentCity)
    visited[currentCity] = true
    
    for _ in 0..<(numCities - 1) {
        var nextCity = -1
        var minDistance = Int.max
        
        for city in 0..<numCities {
            if !visited[city] && adjacencyMatrix[currentCity][city] < minDistance {
                nextCity = city
                minDistance = adjacencyMatrix[currentCity][city]
            }
        }
        
        path.append(nextCity)
        visited[nextCity] = true
        currentCity = nextCity
    }
    
    // 将最后一个城市与起始城市相连，形成闭合路径
    path.append(0)
    
    return path
}

// 示例：计算旅行推销员问题的最短路径
let adjacencyMatrix = [
    [0, 2, 9, 10],
    [1, 0, 6, 4],
    [15, 7, 0, 8],
    [6, 3, 12, 0]
]

let shortestPath = tspGreedy(adjacencyMatrix: adjacencyMatrix)
print("最短路径: \(shortestPath)")

在上述代码中，定义了一个名为 tspGreedy 的函数，它接受一个邻接矩阵作为输入，并返回最短路径。函数使用贪心算法思想来计算最短路径，并将结果存储在 path 数组中。最后，我们打印出计算得到的最短路径。

请注意，贪心算法是一种近似解法，不能保证得到全局最优解。对于大规模的问题，贪心算法可能无法找到最优解，因此在实际应用中，可能需要使用其他更高效的算法来解决TSP。

回溯

回溯算法是一种通过不断尝试所有可能解的搜索算法，常用于解决组合优化问题、排列问题、子集问题等。其基本思想是通过递归的方式，按照某种顺序尝试所有可能的选择，如果当前选择不符合要求，则回溯到上一步进行其他选择，直到找到符合要求的解或者全部尝试完毕。

下面是回溯算法的基本思想和步骤：

  1. 确定问题的解空间：将问题抽象成一个树形结构，树的每个节点表示问题的一个局部解或者一个选择。

  2. 确定问题的约束条件：定义问题的约束条件，用于判断一个局部解是否满足要求，以及是否需要继续搜索下去。

  3. 确定问题的搜索顺序：确定在解空间树中搜索的顺序，有时可以通过排序或者剪枝等方式减少搜索的分支。

  4. 回溯搜索：从根节点开始，按照搜索顺序逐步向下搜索，每次选择一个未被排除的分支，直到达到叶子节点或者当前节点的局部解不满足约束条件。

  5. 判断是否满足最终目标：如果当前节点的局部解满足了问题的约束条件，可以将其作为一个候选解进行保存或者输出。如果目标是找到所有解，则继续搜索其他可能的分支。

  6. 回溯到上一步：如果当前节点的局部解不满足约束条件，或者已经达到叶子节点，需要回溯到上一步，撤销当前选择，并且尝试其他分支。

  7. 继续搜索：根据搜索顺序选择下一个分支进行搜索，重复步骤4-6，直到找到所有解或者搜索完所有分支。

回溯算法的优点是可以找到所有解，但是在搜索过程中可能会遇到大量的重复计算，导致效率较低。为了提高效率，可以使用剪枝等技术来减少不必要的搜索分支。

实例：八皇后问题

模拟

模拟算法是一种基于模拟或模型的计算方法，它通过在计算机程序中模拟真实世界的过程，来解决问题或预测系统行为。它通常涉及构建一个模型，该模型对问题或系统进行抽象，并根据模型的规则和条件进行仿真。

下面是模拟算法的一般思想和步骤：

  1. 定义模型：确定问题或系统的关键方面，并定义模型来表示它们。模型可以是数学模型、逻辑模型、状态机、图形模型等，根据具体问题的性质而定。

  2. 初始化状态：根据问题的初始条件，设置模型的初始状态。

  3. 模拟过程：根据模型的规则和条件，模拟问题或系统的演变过程。这可能涉及到时间的推进、状态的更新、事件的触发等。在每个时间步骤或状态更新之后，根据模型的规则和条件进行相应的操作和计算。

  4. 终止条件：定义模拟的终止条件。这可能是达到一定的时间、达到某种特定状态、满足某种条件等。

  5. 收集结果：在模拟过程中，根据需要收集和记录关键的结果或输出。

  6. 分析和解释：根据收集的结果，进行分析和解释。这可能涉及到数据处理、统计分析、可视化等方法，以获得对问题或系统的理解。

  7. 优化和验证：根据模拟结果，进行问题的优化或验证。这可能包括调整模型参数、改进模拟算法的设计或进行实验验证，以提高模拟结果的准确性和可靠性。

模拟算法的优势在于它可以在计算机中模拟复杂的过程和系统，提供对问题的深入理解和洞察。它可以用于解决各种实际问题，如物理系统的仿真、交通流量的模拟、经济市场的建模等。然而，模拟算法也面临一些挑战，如模型的准确性、计算效率、对参数选择的敏感性等。

总结来说，模拟算法是一种基于模型的计算方法，通过在计算机中模拟问题或系统的演变过程，来解决问题或预测系统行为。它涉及定义模型、初始化状态、模拟过程、终止条件、收集结果、分析解释等步骤。模拟算法能够提供对问题的深入理解和洞察，但需要注意模型的准确性和计算效率。

不同算法思想之间的联系与区别

不同算法思想之间存在联系和区别，下面是对它们的联系和区别的总结：

  1. 贪心算法（Greedy Algorithm）和动态规划（Dynamic Programming）：

    • 联系：贪心算法和动态规划都用于求解最优化问题，它们都关注局部最优解与全局最优解之间的关系。
    • 区别：贪心算法每次选择当前最优的解决方案，不会回溯或修改选择；而动态规划通过将问题划分为子问题，并利用子问题的最优解构建全局最优解，需要存储中间结果。

  2. 分治算法（Divide and Conquer）和动态规划：

    • 联系：分治算法和动态规划都将问题划分为子问题来求解。
    • 区别：分治算法将问题划分为相互独立的子问题，然后将子问题的解合并得到原问题的解；而动态规划将问题划分为重叠子问题，并通过存储子问题的解来避免重复计算。

  3. 回溯算法（Backtracking）和深度优先搜索（DFS）：

    • 联系：回溯算法和深度优先搜索都涉及到遍历问题的解空间。
    • 区别：回溯算法通过在搜索过程中进行选择、尝试和回溯来找到问题的解，可以回退到之前的状态；而深度优先搜索是一种遍历树或图的算法，通过递归地探索每个可能的分支，直到找到解或遍历完整个空间。

  4. 分支界限算法（Branch and Bound）和回溯算法：

    • 联系：分支界限算法和回溯算法都用于求解组合优化问题。
    • 区别：分支界限算法通过限定上界和下界来快速剪枝，以减少搜索空间；而回溯算法则通过选择、尝试和回溯来遍历所有可能的解空间，不进行剪枝。

这些联系和区别揭示了不同算法思想在解决问题时的不同策略和思维方式。理解它们之间的联系和区别有助于我们选择合适的算法思想和设计出更高效的算法。

相关推荐
DARLING Zero two♡6 分钟前
【优选算法】Pointer-Slice：双指针的算法切片（下）
java·数据结构·c++·算法·leetcode
游是水里的游1 小时前
【算法day19】回溯：分割与子集问题
算法
不想当程序猿_1 小时前
【蓝桥杯每日一题】分糖果——DFS
c++·算法·蓝桥杯·深度优先
南城花随雪。1 小时前
单片机：实现FFT快速傅里叶变换算法（附带源码）
单片机·嵌入式硬件·算法
dundunmm2 小时前
机器学习之scikit-learn（简称 sklearn）
python·算法·机器学习·scikit-learn·sklearn·分类算法
古希腊掌管学习的神2 小时前
[机器学习]sklearn入门指南（1）
人工智能·python·算法·机器学习·sklearn
波音彬要多做2 小时前
41 stack类与queue类
开发语言·数据结构·c++·学习·算法
Noah_aa2 小时前
代码随想录算法训练营第五十六天 | 图 | 拓扑排序（BFS）
数据结构
KpLn_HJL2 小时前
leetcode - 2139. Minimum Moves to Reach Target Score
java·数据结构·leetcode
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10RAG 实践- Ollama+RagFlow 部署本地知识库