五大经典算法

  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
    评论
贪心算法(Greedy Algorithm)是一种在每一步选择中都采取当前状态下最优的选择,从而希望最终导致全局最优的算法。贪心算法通常有以下特点: 1. 贪心选择性质:每一步都采取最优的选择,即局部最优解。 2. 最优子结构性质:原问题的最优解包含子问题的最优解。 3. 无后效性:每一步的决策只与当前状态有关,与之前的决策无关。 贪心算法可以用来求解一些最优化问题,如最小生成树、背包问题、活动选择问题等。 以活动选择问题为例,假设有n个活动,每个活动有一个开始时间s和结束时间f,多个活动可能在同一时间段内进行,但是同一时间只能进行一个活动。如何选择活动,使得能够安排的活动数量最多? 贪心算法的思路是:按照结束时间从早到晚排序,每次选择结束时间最早的活动,且不与已经选择的活动时间冲突。这是因为选择结束时间最早的活动,可以给后面留下更多的时间选择其他活动,从而使得总的安排活动数量最多。 参考代码如下: ``` #include <iostream> #include <algorithm> using namespace std; struct Activity { int start, finish; }; bool compare(Activity s1, Activity s2) { return (s1.finish < s2.finish); } void printMaxActivities(Activity arr[], int n) { sort(arr, arr+n, compare); cout << "Selected activities:\n"; int i = 0; cout << "(" << arr[i].start << ", " << arr[i].finish << "), "; for (int j = 1; j < n; j++) { if (arr[j].start >= arr[i].finish) { cout << "(" << arr[j].start << ", " << arr[j].finish << "), "; i = j; } } } int main() { Activity arr[] = {{1, 2}, {3, 4}, {0, 6}, {5, 7}, {8, 9}, {5, 9}}; int n = sizeof(arr)/sizeof(arr[0]); printMaxActivities(arr, n); return 0; } ``` 输出结果为: ``` Selected activities: (1, 2), (3, 4), (5, 7), (8, 9), ``` 可以看到,按照贪心算法的思路,选择了4个活动,使得能够安排的活动数量最多。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值