贪心算法
算法简介：
- 贪心算法是指：在每一步的求解的步骤中，他要求"贪婪"的选择最佳操作，并希望通过一系列的最优选择，找到一个全局的最优解。（但有时候是找不到全局最优）；
- 贪心算法需满足：
- 可行性：即每一步都必须满足问题的约束
- 局部最优 ：他是当前步骤中所有可行选择中最佳的局部选择。
- 不可取消： 即选择一旦做出，在算法的后面步骤就不可改变。
- 贪心算法需满足：
算法案例：
- 活动选择问题：
问题描述：有n个需要在同一天使用同一个教室的活动a1,a2,…,an，教室同一时刻只能由一个活动使用。每个活动ai都有一个开始时间si和结束时间fi 。一旦被选择后，活动ai就占据半开时间区间[si,fi)。如果[si,fi]和[sj,fj]互不重叠，ai和aj两个活动就可以被安排在这一天。该问题就是要安排这些活动使得尽量多的活动能不冲突的举行。例如下图所示的活动集合S，其中各项活动按照结束时间单调递增排序
贪心思想：活动越早结束，剩余的时间越多，那我就选最早结束的那个活动，找到后继续在剩余的活动中找最早结束的活动 … …
事实证明贪心算法在这个问题中可以得到最优解：
实现如下（c++）：
#include <iostream>
#include <algorithm>
using namespace std;
struct active
{
int L;
int R;
};
bool cmp(active a, active b)
{
return a.R < b.R;
}
int main()
{
int N;
cin >> N;
int M; // M代表结束时间，可能为0 时，当结束时间为 0 时其实是M时
cin >> M;
struct active acts[N];
int ret = 0;
for(int i = 0; i < N; i++)
{
cin >> acts[i].L;
cin >> acts[i].R;
if(acts[i].R == 0)
{
acts[i].R = M;
}
}
sort(acts, acts + N -1, cmp);
int time_now = 0;
for(int i = 0; i < N; i++)
{
if(time_now <= acts[i].L)
{
++ret;
time_now = acts[i].R;
}
}
cout<< ret;
return 0;
}
结果：
实现（java （来自互联网，我没有试，不过逻辑正确））：
public class ActiveTime {
public static void main(String[] args) {
//创建活动并添加到集合中
Active act1 = new Active(1, 4);
Active act2 = new Active(3, 5);
Active act3 = new Active(0, 6);
Active act4 = new Active(5, 7);
Active act5 = new Active(3, 8);
Active act6 = new Active(5, 9);
Active act7 = new Active(6, 10);
Active act8 = new Active(8, 11);
Active act9 = new Active(8, 12);
Active act10 = new Active(2, 13);
Active act11 = new Active(12, 14);
List<Active> actives = new ArrayList<Active>();
actives.add(act1);
actives.add(act2);
actives.add(act3);
actives.add(act4);
actives.add(act5);
actives.add(act6);
actives.add(act7);
actives.add(act8);
actives.add(act9);
actives.add(act10);
actives.add(act11);
List<Active> bestActives = getBestActives(actives, 0, 16);
for (int i = 0; i < bestActives.size(); i++) {
System.out.println(bestActives.get(i));
}
}
/**
*
* @param actives
* 活动集合
* @param startTime
* 教室的开始使用时间
* @param endTime
* 教室的结束使用时间
* @return
*/
public static List<Active> getBestActives(List<Active> actives, int startTime, int endTime) {
//最佳活动选择集合
List<Active> bestActives = new ArrayList<Active>();
//将活动按照最早结束时间排序
actives.sort(null);
//nowTime 用来记录上次活动结束时间
int nowTime = startTime;
/**
* 因为我们已经按照最早结束时间排序，那么只要活动在时间范围内
* actives.get(1)就应当是第一个活动的结束时间.
* 则我们记录第一次活动结束的时间，在结合剩下的活动中，
* 选取开始时间大于nowTime且结束时间又在范围内的活动，则为第二次活动时间，
* 知道选出所有活动
*/
for (int i = 0; i < actives.size(); i++) {
Active act = actives.get(i);
if(act.getStartTime()>=nowTime&&act.getEndTime()<=endTime){
bestActives.add(act);
nowTime = act.getEndTime();
}
}
return bestActives;
}
}
/**
* 活动类
* @CreatTime 下午9:45:37
*
*/
class Active implements Comparable<Active>{
private int startTime;//活动开始时间
private int endTime;//活动结束时间
public Active(int startTime, int endTime) {
super();
this.startTime = startTime;
this.endTime = endTime;
}
public int getStartTime() {
return startTime;
}
public void setStartTime(int startTime) {
this.startTime = startTime;
}
public int getEndTime() {
return endTime;
}
public void setEndTime(int endTime) {
this.endTime = endTime;
}
@Override
public String toString() {
return "Active [startTime=" + startTime + ", endTime=" + endTime + "]";
}
//活动排序时按照结束时间升序
@Override
public int compareTo(Active o) {
if(this.endTime>o.getEndTime()){
return 1;
}else if(this.endTime == o.endTime){
return 0;
}else{
return -1;
}
}
}
- 找零钱问题
问题描述：这个问题在我们的日常生活中就更加普遍了。假设1元、2元、5元、10元、20元、50元、100元的纸币分别有c0, c1, c2, c3, c4, c5, c6张。现在要用这些钱来支付K元，至少要用多少张纸币？用贪心算法的思想，很显然，每一步尽可能用面值大的纸币即可。在日常生活中我们自然而然也是这么做的。
代码实现（C++）：
#include <iostream>
#include <algorithm>
using namespace std;
int change(int money, int *values, int *counts , int length)
{
int ret[length];
int num = 0;
for (int i = length - 1; i >=0; i--)
{
int cou = min(money/values[i], counts[i]);
cout << cou <<endl;
money = money - cou * values[i];
num += cou;
ret[i] = cou;
}
cout << num << endl;
for (int i=0; i < length; i++)
{
cout << ret[i] << " ";
}
return num;
}
int main()
{
//人民币面值集合
int values[] = {1,2,5,10,20,50,100};
int counts[] = {3,1,2,1,1,3,5};
int length = sizeof(values) / sizeof(values[0]);
cout << length;
int num = change(442, values, counts, length);
return 0;
}
java代码实现:(来自互联网)：
package GreedyAlgorithm;
public class CoinChange {
public static void main(String[] args) {
//人民币面值集合
int[] values = { 1, 2, 5, 10, 20, 50, 100 };
//各种面值对应数量集合
int[] counts = { 3, 1, 2, 1, 1, 3, 5 };
//求442元人民币需各种面值多少张
int[] num = change(442, values, counts);
print(num, values);
}
public static int[] change(int money, int[] values, int[] counts) {
//用来记录需要的各种面值张数
int[] result = new int[values.length];
for (int i = values.length - 1; i >= 0; i--) {
int num = 0;
//需要最大面值人民币张数
int c = min(money / values[i], counts[i]);
//剩下钱数
money = money - c * values[i];
//将需要最大面值人民币张数存入数组
num += c;
result[i] = num;
}
return result;
}
/**
* 返回最小值
*/
private static int min(int i, int j) {
return i > j ? j : i;
}
private static void print(int[] num, int[] values) {
for (int i = 0; i < values.length; i++) {
if (num[i] != 0) {
System.out.println("需要面额为" + values[i] + "的人民币" + num[i] + "张");
}
}
}
}
总结：于是我们可以看出，有些情况，贪心算法确实可以给出最优解，然而，还有一些问题并不是这种情况。对于这种情况，我们关心的是近似解，或者只能满足于近似解，贪心算法也是有价值的。
ps： 在这里我想学习这种贪心的策略，就是找到该贪什么心，这是重点，例如第一题就是贪最早结束的心，第二题就是贪从最大钱开始拼凑的心，我觉得这是重点！