五大经典算法

  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)

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值