C++贪心算法-优快云博客

本文链接：https://blog.youkuaiyun.com/abcdeWA/article/details/145266847

以下是一篇关于C++贪心算法的详细介绍：

C++贪心算法的介绍

贪心算法是一种在每一步选择中都采取当前状态下最优决策的算法策略，其核心思想是局部最优会导致全局最优。虽然贪心算法并不适用于所有问题，但对于许多问题，它可以提供高效的解决方案，而且实现相对简单。

一、贪心算法的基本概念

贪心算法的工作原理是通过做出一系列局部最优的选择，期望最终这些选择能组合成全局最优解。在某些问题中，这种策略是可行的，因为这些问题具有贪心选择性质和最优子结构性质。

1. 贪心选择性质

一个问题具有贪心选择性质是指，通过做出局部最优的选择，可以得到全局最优解。这意味着在求解过程中，每一步的最优选择都不会影响后续步骤的最优解选择，并且最终可以达到全局最优。

2. 最优子结构性质

最优子结构性质表明原问题的最优解可以由子问题的最优解组合而成，这与动态规划中的最优子结构有些类似，但贪心算法只考虑当前最优，不考虑子问题之间的依赖关系。

二、贪心算法的经典应用

1. 活动安排问题

假设有一系列活动，每个活动有开始时间和结束时间，要求选择最多的不冲突的活动。

以下是活动安排问题的C++实现：

#include <iostream>
#include <vector>
#include <algorithm>

struct Activity {
    int start, end;
};

bool compare(Activity a, Activity b) {
    return a.end < b.end;
}

int maxActivities(std::vector<Activity>& activities) {
    std::sort(activities.begin(), activities.end(), compare);
    int n = activities.size();
    int i = 0;
    int count = 1;
    for (int j = 1; j < n; j++) {
        if (activities[j].start >= activities[i].end) {
            count++;
            i = j;
        }
    }
    return count;
}


int main() {
    std::vector<Activity> activities = {{1, 2}, {3, 4}, {0, 6}, {5, 7}, {8, 9}, {5, 9}};
    std::cout << "Maximum number of activities: " << maxActivities(activities) << std::endl;
    return 0;
}

在这个代码中：

Activity 结构体表示一个活动的开始和结束时间。
compare 函数用于根据活动的结束时间对活动进行排序。
maxActivities 函数首先对活动排序，然后从第一个活动开始，每次选择不冲突且结束时间最早的活动，这样可以保证选择最多的不冲突活动。

2. 找零问题

假设我们有不同面额的硬币，需要找零 $n$ 元，使用最少的硬币数量。

以下是找零问题的C++实现：

#include <iostream>
#include <vector>

std::vector<int> coinChange(std::vector<int>& coins, int amount) {
    std::vector<int> result;
    std::sort(coins.rbegin(), coins.rend()); // 从大面额开始
    for (int coin : coins) {
        while (amount >= coin) {
            result.push_back(coin);
            amount -= coin;
        }
    }
    return result;
}


int main() {
    std::vector<int> coins = {1, 5, 10, 25}; // 面额
    int amount = 42;
    std::vector<int> change = coinChange(coins, amount);
    std::cout << "Change for " << amount << " cents: ";
    for (int coin : change) {
        std::cout << coin << " ";
    }
    std::cout << std::endl;
    return 0;
}

在这个代码中：

coinChange 函数将硬币面额从大到小排序，每次尽可能多地使用大面额硬币，以减少硬币数量。

3. 分数背包问题

与0-1背包问题不同，分数背包问题允许物品可以被分割，目标是在背包容量限制下，使物品总价值最大。

以下是分数背包问题的C++实现：

#include <iostream>
#include <vector>
#include <algorithm>

struct Item {
    int value, weight;
    double ratio;
};

bool compare(Item a, Item b) {
    return a.ratio > b.ratio;
}

double fractionalKnapsack(int W, std::vector<Item>& items) {
    for (Item& item : items) {
        item.ratio = (double)item.value / item.weight;
    }
    std::sort(items.begin(), items.end(), compare);
    double totalValue = 0.0;
    for (Item& item : items) {
        if (W >= item.weight) {
            W -= item.weight;
            totalValue += item.value;
        } else {
            totalValue += W * item.ratio;
            break;
        }
    }
    return totalValue;
}


int main() {
    std::vector<Item> items = {{60, 10}, {100, 20}, {120, 30}};
    int W = 50;
    std::cout << "Maximum value: " << fractionalKnapsack(W, items) << std::endl;
    return 0;
}

在这个代码中：

Item 结构体存储物品的价值、重量和价值重量比。
compare 函数根据价值重量比排序物品。
fractionalKnapsack 函数按价值重量比从大到小选择物品，对于最后一个物品，如果背包容量不足，可以选择部分物品。

三、贪心算法的性能分析

1. 时间复杂度

对于上述例子，活动安排问题的时间复杂度主要取决于排序，为 $O (n l o g n)$ 。
找零问题的时间复杂度为 $O (n l o g n)$ ，主要是排序的时间复杂度，其中 $n$ 是硬币的种类数。
分数背包问题的时间复杂度为 $O (n l o g n)$ ，也是排序的时间复杂度，其中 $n$ 是物品的数量。

2. 空间复杂度

这些贪心算法的空间复杂度通常为 $O (n)$ ，主要用于存储输入数据和结果。

四、贪心算法的局限性

虽然贪心算法简单高效，但并非所有问题都适合贪心算法。例如，对于0-1背包问题，如果物品不能分割，贪心算法可能无法找到最优解，因为它只考虑当前最优而不考虑全局最优。

五、总结

贪心算法是一种简单而强大的算法策略，在满足贪心选择性质和最优子结构性质的问题上可以高效地找到最优解。在C++中，可以方便地实现各种贪心算法，解决诸如活动安排、找零和分数背包等问题。然而，使用贪心算法时需要谨慎，因为它并不适用于所有问题。如果你对贪心算法的某个部分有更多的问题，例如如何确定一个问题是否适合贪心算法，或者如何将贪心算法应用于其他问题，都可以继续向我询问，我会为你提供更详细的帮助。

这篇文章涵盖了C++贪心算法的基本概念、经典应用、性能分析和局限性。如果你对其中的任何部分有疑问，例如希望看到更多的代码解释、需要对代码进行优化，或者想知道如何判断一个问题是否适合贪心算法，都可以告诉我，我会尽力为你提供帮助。