五大经典算法

1. 分治法：将一个大问题分解为若干个小问题，通过递归地解决小问题并将它们的解合并得到大问题的解。

   def divide_conquer(nums):
       if len(nums) == 1:
           return nums[0]
       else:
           mid = len(nums) // 2
           left_sum = divide_conquer(nums[:mid])
           right_sum = divide_conquer(nums[mid:])
           return left_sum + right_sum
   
   nums = [1, 2, 3, 4, 5]
   result = divide_conquer(nums)
   print("数字和:", result)

2. 动态规划法：通过将问题分解为相互重叠的子问题，利用子问题的解来构建整体问题的解。动态规划通常用于求解具有最优子结构的问题。

   def fibonacci(n):
       if n <= 1:
           return n
       else:
           dp = [0] * (n+1)
           dp[0] = 0
           dp[1] = 1
           for i in range(2, n+1):
               dp[i] = dp[i-1] + dp[i-2]
           return dp[n]
   
   n = 10
   result = fibonacci(n)
   print("斐波那契数", n, "是:", result)

3. 贪心算法：通过每一步选择当前最优解，从而希望达到整体最优解的算法。贪心算法通常不保证得到全局最优解，但在某些问题上具有很好的效果。

   def coin_change(coins, amount):
       coins.sort(reverse=True)
       count = 0
       for coin in coins:
           if amount >= coin:
               count += amount // coin
               amount = amount % coin
       if amount == 0:
           return count
       else:
           return -1
   
   coins = [1, 2, 5, 10, 20]
   amount = 36
   result = coin_change(coins, amount)
   print("最少要的数量:", result)

4. 回溯法：通过逐步构建解空间树，并进行剪枝，从而找到满足约束条件的问题解。回溯法常用于求解组合、排列、子集等问题。

   def can_place(board, row, col):
       for i in range(row):
           if board[i] == col or \
              board[i] - i == col - row or \
              board[i] + i == col + row:
               return False
       return True
   
   def backtrack(board, row, n, res):
       if row == n:
           res.append(board[:])
           return
       for col in range(n):
           if can_place(board, row, col):
               board[row] = col
               backtrack(board, row + 1, n, res)
   
   n = 8
   board = [-1] * n
   res = []
   backtrack(board, 0, n, res)
   print("解决数量:", len(res))
   for solution in res:
       print(solution)

5. 分支限界法：通过将问题划分为多个子问题，并采用剪枝策略，以减少搜索空间并找到问题的最优解。分支限界法通常用于求解最优化问题。

   class Item:
       def __init__(self, weight, value):
           self.weight = weight
           self.value = value
   
   def knapsack(items, capacity):
       items.sort(key=lambda x: x.value / x.weight, reverse=True)
       max_value = 0
       curr_weight = 0
       for item in items:
           if curr_weight + item.weight <= capacity:
               curr_weight += item.weight
               max_value += item.value
           else:
               remaining_capacity = capacity - curr_weight
               max_value += item.value * (remaining_capacity / item.weight)
               break
       return max_value
   
   items = [Item(10, 60), Item(20, 100), Item(30, 120)]
   capacity = 50
   result = knapsack(items, capacity)
   print("最大值:", result)