贪心算法入门(Greedy algorithm)

贪心算法入门(greedy algorithm)

贪心算法，又名贪婪法，是寻找最优解问题的常用方法，这种方法模式一般将求解过程分成若干个步骤，但每个步骤都应用贪心策略，选取当前状态下最好/最优的选择（局部最优解），并以此希望最后堆叠出的结果也是最好/最优的解。

解决贪心问题的基本步骤

• 1. 将原问题分解为子问题
• 2. 找出贪心策略
• 3. 得到每一个子问题的最优解
• 4. 将所有局部最优解的集合构成称为原问题的一个解

分析思路

1. 贪心策略选择
贪心算法的根本在于贪心策略的选择，如果你能找出正确的贪心策略那么，贪心问题也就迎刃而解。

贪心策略 :即我们需要找到一种方法使得当前可以获得的收益最大。举个栗子:我们每个人都对未来有很多的憧憬和计划。我们希望我们的人生都能够得到最优解。但是由于我们无法预知之后几年几十年的事情发展，我们无法精准的计算出我们再每一个时间结点的完美选择。于是我们只好选择每一天，或者当前时间段我都都做对自己最有帮助的事情。经过不断的累积最后得到最终结果，未必不是一种好的做法

2. 猜

例题分析

P1090 合并果子

既然是贪心的思想: 那么就首先要将问题分解为子问题，然后着眼于子问题的最优解，最后将所有子问题的最优解汇总即可

n 堆果子一定会经过 n - 1次合并，而每次消耗的体力之和为两堆果子的重量 ， 举个栗子

我们拿样例 n = 3 举例

1 2 9分别为三堆果子的数量。
我们分别采用两种极端的方法：

1. 先将最大的和最大的合并:
   第一次合并 : 1 11 耗费体力 : 11
   第二次合并 : 12 耗费体力 : 11 + 12 = 23
2. 先将最小的两堆合并
   第一次合并 : 3 9 耗费体力 : 3
   第二次合并 : 12 耗费体力 : 3 + 12 = 15
   

其实我们已经可以发现，我们每次挑选最大的只会使得我们再下一次合并时增加我们的体力消耗，于是我们应该尽可能的避免这种消耗

也就是说我们最终采用的贪心策略实际上就是每次取出最小的两个进行合并，合并完之后再将其合并值放入，在进行重复操作，相信大家都想到了 堆 和 赫夫曼树。赫夫曼树就不说了 ，已经忘记怎么写了 hhh 在这里采用堆的形式解决也就是STL 中的优先队列

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <queue>

using namespace std;

// 申请小顶堆 
priority_queue<int,vector<int>,greater<int> > q;
int n ; 
int main()
{
	cin >> n;
	int x;
	for(int i = 0;i < n ;i ++)
	{
		cin >> x;
		q.push(x);
	}
	long long ans = 0; 
	while(q.size() >= 2)
	{
		int a = q.top();q.pop();
		int b = q.top();q.pop();
		ans += a + b;
		q.push(a + b);
	}
	cout << ans << endl;
	return 0;
} 

P1253 线性存储问题

贪心策略:
贪速率，(f=v/t)

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

using namespace std;
const int N = 10005;
int n;
struct node{
	int f;
	int id;
};

vector<node> v;

bool cmp(node a,node b)
{
	return a.f > b.f;
}
int main()
{
	cin >> n;
	int a, b ;
	for(int i = 0;i < n ;i ++)
	{
		scanf("%d %d",&a ,&b);
		v.push_back({a * b, i + 1});
	}	
	sort(v.begin(),v.end(),cmp);
	for(int i = 0;i < v.size() ;i ++)
	{
		cout << v[i].id << " ";
	}
	return 0;
} 

存在的问题和难点

1. 证明困难，大部分贪心算法难以证明

2. 大部分情况下其并不是最优解

3. 贪心问题之间的跨越度比较大