贪心算法相关题目

题目一：安排会议问题

title:一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目的宣讲，给你每一个项目开始的时间和结束的时间，你来安排宣讲的日程，要求会议室进行的宣讲的场次最多，返回最多的宣讲场次

target:在一个时间段中 安排最多的会议

代码实现：

public class BestArrangeInMeeting {
    //会议对象
    public static class Program{
        //会议起始时间
        private int beginTime;
        //会议结束时间
        private int endTime;

        public Program(int beginTime,int endTime){
            this.beginTime = beginTime;
            this.endTime = endTime;
        }
    }
    //设计一个方法  在同一时间内使得安排的会议数达到最大值  返回安排的会议数目
    //参数：会议数组
    public int arrange(Program[] programs){
        //先将会议全部按照从小到大排序  比较器
        Arrays.sort(programs,new programComparator());
        //时间线 来控制哪个能安排哪个不能安排
        int timeLine = 0;
        //结果数组
        int result = 0;
        //遍历会议 每次拿出结束最早的会议进行安排
        for(Program program : programs){
            //当前时间线等于当前会议的结束时间  如果下一个会议的开始时间  大于等于时间线  就安排他
            if(timeLine <= program.beginTime){
                result ++;
                timeLine = program.endTime;
            }
        }
        return result;
    }
    //比较器  将数组中的结束按照从小到大排序
    public class programComparator implements Comparator<Program> {
        @Override
        public int compare(Program o1, Program o2) {
            return o1.endTime - o2.endTime ;
        }
    }
    public int maxEvents(int[][] events) {
        if(events == null){
            return 0;
        }
        Arrays.sort(events,new eventsComparator());
        int result = 0;
        int timeLine = 0;
        for(int[] event : events){
            if(event[0] >= timeLine){
                result ++;
                timeLine = event[1];
            }
        }
        return result;
    }
    public class eventsComparator implements Comparator<int[]>{
        //将二维数组升序排列
        @Override
        public int compare(int[] o1, int[] o2) {
            return o1[0] - o2[0];
        }

    }
}

题目二：分金条问题(哈夫曼编码问题)

title:一块金条切成两半，是需要花费和长度数值一样的铜板，比如长度为20的金条，不管怎么切都要花费20个铜板，一群人想整分整块金条，怎么分最省铜板? 例如，给定数组{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铜板

target:给一个数组 返回分金条花费的最小代价

代码实现：

public class LessMoneySplitMoney {
    //哈夫曼编码问题
    public int splitMoney(int[] arr){
        //先将数组中所有的值存到小根堆中
        PriorityQueue<Integer> queue = new PriorityQueue<>();
        for(int i = 0;i < arr.length;i++){
            queue.offer(arr[i]);
        }
        //取出前两个值相加 然后将相加的和再放入到队列中  循环 直至队列中剩下最后一个结合后的值
        //返回sum和
        int sum = 0;
        //临时接收值
        int cur = 0;
        while(queue.size() > 1){
            cur += queue.poll() + queue.poll();
            sum += cur;
            queue.offer(cur);
        }
        return sum;
    }
}

题目三：做项目问题

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

target:返回做项目获得的最大受益

代码实现：

    public class DoProjectGetMoney {
    //结构
    public class Program{
        //项目受益
        private int profit;
        //项目支出
        private int capital;

        public Program(int profit,int capital){
            this.profit = profit;
            this.capital = capital;
        }
    }

    //返回获取做项目的最大受益  参数： 最多做K个项目  当前现有资金  项目受益的数组  项目支出的数组
    //思路：将所有的项目生成到一个小根堆中“锁”起来 然后在小根堆中找出当前资金可以做的项目
    //放到一个大根堆里面  挑受益多的先做。
    public int doMoreWork(int K,int M,int[] profits,int[] capitals){
        //按照花费从小到大排序的小根堆  比较器
        PriorityQueue<Program> costQueue = new PriorityQueue<>(new costComparator());
        //按照受益从大到小排序的大根堆 比较器
        PriorityQueue<Program> profitQueue = new PriorityQueue<>(new profitComparator());
        //将所有的项目“锁”到小根堆中  profits 和capitals肯定是等长的
        for(int i = 0 ;i < profits.length;i++){
            costQueue.offer(new Program(profits[i],capitals[i]));
        }
        //找出花费队列中每一个花费小于等于现有资金M的项目 解锁到大根堆中
        //但是最多只能做K个项目
        for(int i = 0;i < K;i++){
            while (!costQueue.isEmpty() && costQueue.peek().capital <= M) {
                profitQueue.offer(costQueue.poll());
            }
            //如果小根堆为空了  证明不能做项目了 直接返回M
            if(costQueue.isEmpty()){
                return M;
            }
            //结算M
            M += profitQueue.poll().profit;
        }

        return M;
    }

    //花费比较器  小根堆
    public class costComparator implements Comparator<Program>{
        @Override
        public int compare(Program o1, Program o2) {
            return o1.capital - o2.capital;
        }
    }

    //收益比较器  大根堆
    public class profitComparator implements Comparator<Program>{
        @Override
        public int compare(Program o1, Program o2) {
            return o2.profit - o1.profit;
        }
    }
    public int maxValue(int[][] events, int k) {
        int result = 0;
        //将会议按照结束时间从小到大存入到小根堆中
        PriorityQueue<int[]> eventQueue = new PriorityQueue<>(new eventComparator());
        //将events的值生成到小根堆中
        for(int[] event : events){
            eventQueue.offer(event);
        }
        int timeLine = 0;
        //弹出一个会议 记录他的结束时间
        if(!eventQueue.isEmpty()){
            int[] tmp = eventQueue.poll();
            timeLine = tmp[1];
            //这个会议已经参加 获得value
            result += tmp[2];
        }
        //弹出后续会议  如果后续会议的开始时间大于我当前结束时间  就参加这个会议 并获得会议值
        for(int i = 0;i < k;i++){
            while(!eventQueue.isEmpty() && timeLine <= eventQueue.peek()[0]){
                int[] tmp = eventQueue.poll();
                //参加这个会议
                timeLine = tmp[1];
                result += tmp[2];
            }
        }
        return result;
    }
    public class eventComparator implements Comparator<int[]>{
        @Override
        public int compare(int[] o1, int[] o2) {
            return o1[1] - o2[1];
        }
    }
}