算法学习26-贪心算法常见问题

算法学习26-贪心算法常见问题

贪心算法的实现框架

从问题的某一初始解出发；

while （能朝给定总目标前进一步）

{
    

利用可行的决策，求出可行解的一个解元素；

}

由所有解元素组合成问题的一个可行解；

常见问题一:最少的硬币数

问题描述

假设现有1分、2分、5分、1角的硬币若干枚，给定任意一个金额m，求最少需要多少枚硬币？

算法分析

难点在于：怎么证明这个算法得到的最少硬币数。

分析：假设金额为m分，分两种情况进行讨论：

• 若m<10, 可以列出所有的最小硬币数，显然与上面的程序一致；
• 若m>=10, 假设1分、2分、5分和1角的最少硬币数分别为k1、k2、k5、k10, 则需要证明k10=m/10是最优解。由于1角是1分、2分、5分的整数倍，假设存在另一个最少的组合中1角的数量k10‘ < k10且k10-k10’ = d，则必有k1’ + k2’ + k5’ >= k1 + k2 + k5 + 2d，显然，k1’、k2’、k5’、k10’不是最优解。（*思考：前文中的最小硬币数为什么不能用贪心算法？*）

利用贪心算法时，需要关注问题是否具有两个性质：

• 贪心选择性质。即通过局部最优选择可以构造全局最优解。如例1中的最小硬币数，每次都选取最大面值的硬币
• 最优子结构。即如果一个问题的最优解包含其子问题的最优解，则称此问题具有最优子结构性质。（动态规划和贪心选择都具有的性质）

例1中的分析验证了这一点，但是分析过程没有严格去证明贪心选择性质和最优子结构。

代码实现

int LeastCoinNum(int money){
   
    int tenNum = money / 10;
    money= money - tenNum*10;
    int fiveNum = money / 5;
    money = money - fiveNum*5;
    int twoNum = money / 2;
    int oneNum = money - twoNum * 2;
    return tenNum + fiveNum + twoNum + oneNum;
}

常见问题二:切金条问题

问题描述

一块金条切成两半，是需要花费和长度数值一样的铜板的。比如 长度为20的 金条，不管切成长度多大的两半，都要花费20个铜 板。一群人想整分整块金 条，怎么分最省铜板？

例如,

给定数组{10,20,30}，代表一共三个人，整块金条长度为 10+20+30=60. 金条要分成10,20,30三个部分。 如果， 先把长 度60的金条分成10和50，花费60 再把长度50的金条分成20和30， 花费50 一共花费110铜板。

但是如果， 先把长度60的金条分成30和30，花费60 再把长度30 金条分成10和20，花费30 一共花费90铜板。

输入一个数组，返回分割的最小代价。

算法分析

算法分析与问题一相似,可以用stl中的priority_queue ,页可以用递归方法去找到其中的最小值

代码实现

#include <iostream>
#include <vector>
#include <queue>

int lessMoney(const std::vector<int>& arr) {
   
    std::priority_queue<int, std::vector<int>, std::greater<> > minHeap;   // min heap
    
    //priority_queue：为功能队列：优先输出大数据
    // int：为整型数据组
    // std::vector<int>：为存储容器
    //less：从小到大进行排序
    //greater：从大到小进行排序
    
    for (auto it: arr) {
   
        minHeap.push(it);   // 在队列中输入数据
    }
    
    int res = 0;
    
    //得到最小的元素
    while (minHeap.size() > 1) {
   
        int top1 = minHeap.top();
        minHeap.pop();
        int top2 = minHeap.top();
        minHeap.pop();
        res += top1 + top2;
        minHeap.push(top1 + top2);
    }

    return res;
}

int main()
{
   
    std::vector<int> test1 = {
   10, 20, 30};
//    std::vector<int> test2 = { 1, 2, 6, 4, 3, 7, 1, 8 };
    int res1 = lessMoney(test1);
//    int res2 = lessMoney(test2);
    std::cout << "test1: " << res1 << std::endl;
//    std::cout << "test2: " << res2 << std::endl;

    return 0;
}

常见问题三:最大收益问题

问题描述

• 输入： 参数1，正数数组costs； 参数2，正数数组profits；参数3，正数k； 参数4，正数m；
  costs[i]表示i号项目的花费， profits[i]表示i号项目在扣除花费之后还能挣到的钱(利润) ，k表示你不能并行、只能串行的最多做k个项目 m表示你初始的资金。说明：你每做完一个项目，马上获得的收益，可以支持你去做下一个项目。
• 输出： 你最后获得的最大钱数。

算法分析

给定一个初始投资资金，给定N个项目，想要获得其中最大的收益，并且一次只能做一个项目。这是一个贪心策咯的问题，按照花费的多少放到一个小根堆里面，然后要是小根堆里面的头节点的花费少于给定资金，就将头节点一个个取出来，放到按照收益的大根堆里面，这样就然后将大根堆的堆顶弹出，将其加到初始资金上，这样我们就可以从小跟堆中解锁新的项目了，然后重复这个过程。如果遇到大跟堆中为空，我们就直接弹出来就可以啦。或者这么说,及不断去找投入中的最小项,然后我们在这些最小投入中找到最大收益的那一项

代码实现

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

struct Finance {
   
    int cost;
    int profit;
};

// 小根堆
struct cmp1 {
   
    bool operator () (Finance& f1, Finance& f2) {
   
        return f1.cost > f2.cost;
    }
};
// 大根堆
struct cmp2 {
   
    bool operator () (Finance& f1, Finance& f2) {
   
        return f1.profit < f2.profit;
    }
};

int IPO(std::vector<int>& costs, std::vector<int>& profits, int k, int m) {
   
    std::priority_queue<Finance, std::vector<Finance>, cmp1> costsMinHeap;
    std::priority_queue<Finance, std::vector<Finance>, cmp2> profitsMaxHeap;
    auto* FinanceNode = new Finance[profits.size()];
    for (int i = 0; i < profits.size(); ++i) {
   
        FinanceNode[i].cost = costs[i];
        FinanceNode[i].profit = profits[i];
    }
    for (int i = 0; i < profits.size(); ++i) {
   
        costsMinHeap.push(FinanceNode[i]);
    }
    for (int i = 0; i < k; ++i) {
   
        while (!costsMinHeap.empty() && costsMinHeap.top().cost <= m) {
   
            profitsMaxHeap.push(costsMinHeap.top());
            costsMinHeap.pop();
        }
        if (profitsMaxHeap.empty()) {
   
            return m;
        }

        m += profitsMaxHeap.top().profit;
        profitsMaxHeap.pop();
    }

    delete [] FinanceNode;
    return m;
}


int main()
{
   
    std::vector<int> costs