贪心算法:在某一个标准下,优先考虑最满足标准的样本,最后考虑最不满足标准的样本,最终得到一个答案的算法,叫做贪心算法。
也就是说,不从整体最优上加以考虑,所做出的是在某种意义上的局部最优解
局部最优 -?-> 整体最优
题目一:一些项目要占用一个会议室宣讲,会议室不能同时容纳两个项目的宣讲。给你每一个项目开始的时间和结束的时间(给你一个数组,是一个个具体的项目),你来安排会议,要求会议室进行的宣讲的场次最多。返回这个最多的宣讲场次。
以每个会议的结束时间来排序,结束点的时间作为其他会议的开始时间进行再次选择。
Java代码如下:
public static class Program{
public int start;
public int end;
public Program(int start,int end){
this.start = start;
this.end = end;
}
public static class ProgramComparator implements Comparator<Program>{
@Override
public int compare(Program o1, Program o2) {
return o1.end- o2.end;
}
}
public static int bestArrange(Program[] arr,int begin){
Arrays.sort(arr,new ProgramComparator());
int result = 0;
for (int i = 0;i < arr.length; i++){
if (arr[i].start >= begin){
result++;
begin = arr[i].end;
}
}
return result;
}
题目二:一块金条切成两半,是需要花费和长度数值一样的铜板的。比如长度为20的金条,不管切成长度多大的两半,都要花费20个铜板。
一群人想整分整块金条,怎么分最省铜板?
例如:给定数组{10,20,30}代表一共三个人,整块金条长度为10+20+30=60。如果先把长度为60的金条分成10和50,花费60;再把50的金条分成20和30,花费50;一共花费110铜板。但是如果先把长度60的金条分成30和30,花费60,再把30的分成10和20,花费30,一共90.
输入一共数组,返回分割的最小代价。
思路:把10 20 30放到一个小根堆里面,每次弹出两个,两个相加的值再放入小根堆中,再次弹出两个值相加再放入小根堆中,直到小根堆中只有一个元素为止。而其中的花费就是弹出的所有的值累计和。例如 先弹出 10 20. 10+20 =30 , 30再放入小根堆中,随后弹出30 和30 ,30+30=60,此时把60放入小根堆中,并且此时堆中只有一个元素了,就停止。这个过程的花费是10+20+30+30=90。代码中可以使用默认为升序的优先队列PriorityQueue来充当小根堆结构。add与poll。
Java代码如下
public static int lessMoney(int[] arr){
PriorityQueue<Integer> queue = new PriorityQueue();
for (int i = 0;i<arr.length;i++){
queue.add(arr[i]);
}
int sum = 0;
int cur = 0;
while (queue.size() > 1){
cur = queue.poll() + queue.poll();
sum += cur;
queue.add(cur);
}
return sum;
}
题目三:输入:
正数数组costs
正数数组profits
正数k
正数m
含义:costs[i]表示i号项目的花费,profits[i]表示i号项目在扣除花费之后还能挣到的钱(利润),k表示能串行最多做k个项目,m表示初始资金。输出最后获得的最大钱数。
Java代码如下:
public class MoreMoney {
public static class Node{
public int p;//利润
public int c;//需要的花费
public Node(int p,int c){
this.p = p;
this.c = c;
}
}
//需要的花费的小根堆比较器
public static class MinCostComparator implements Comparator<Node>{
@Override
public int compare(Node o1, Node o2) {
return o1.c - o1.c;
}
}
//利润的大根堆比较器
public static class MaxProfitComparator implements Comparator<Node>{
@Override
public int compare(Node o1, Node o2) {
return o2.p - o2.p;
}
}
public static int findMaximizedCaptial(int k,int w,int[] Profits,int[] Capital){
//首先生成小根堆和大根堆。小根堆里面排序规则是花费。大根堆里面是利润。
PriorityQueue<Node> minCostQ = new PriorityQueue(new MinCostComparator());
PriorityQueue<Node> maxProfitQ = new PriorityQueue<>(new MaxProfitComparator());
//把所有的项目放入小根堆
for (int i = 0;i<Capital.length;i++){
minCostQ.add(new Node(Profits[i],Capital[i]));
}
//进行k轮,每次要做的项目就是大根堆里面的第一个。
for (int j = 0;j<k;j++){
while (!minCostQ.isEmpty() && minCostQ.peek().c <= w){
maxProfitQ.add(minCostQ.poll());
}
//如果没有解锁的项目,那么直接return
if (maxProfitQ.isEmpty()){
return w;
}
//做大根堆的第一个项目然后初始的钱又加了一点,随后进入下一轮找新项目做
w += maxProfitQ.poll().p;
}
return w;
}}