贪心算法及其相关题目

贪心算法：在某一个标准下，优先考虑最满足标准的样本，最后考虑最不满足标准的样本，最终得到一个答案的算法，叫做贪心算法。

也就是说，不从整体最优上加以考虑，所做出的是在某种意义上的局部最优解

局部最优 -?-> 整体最优

题目一：一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目的宣讲。给你每一个项目开始的时间和结束的时间（给你一个数组，是一个个具体的项目），你来安排会议，要求会议室进行的宣讲的场次最多。返回这个最多的宣讲场次。

以每个会议的结束时间来排序，结束点的时间作为其他会议的开始时间进行再次选择。

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;


    }}