贪心算法&策略实现

贪心算法

贪心算法&策略实现_第1张图片

贪心算法:基于某种情况进行一个排序。 贪心算法得到的是优良解,而非全局最优解。需要证明局部最优解 == 全局最优解

经典贪心算法 —— 会议问题

贪心算法&策略实现_第2张图片

对于这个问题 ,我们提出贪心策略:

策略1:按照会议的持续时间长短来排序。持续时间短的会议优先安排

我们可以举出反例:蓝色方案安排的场次比绿色方案安排的场次少

贪心算法&策略实现_第3张图片

策略2:按照会议的开始时间早晚来排序。开始时间早的会议优先安排

我们可以举出反例:蓝色方案安排的场次比绿色方案安排的场次少

贪心算法&策略实现_第4张图片

.......

策略n:按照会议的结束时间早晚来排序。结束时间早的会议优先安排

这个策略是正确的,先上代码

package greedyalgorithms;

import java.util.Arrays;
import java.util.Comparator;

public class ScheduleProgram {
    class Progame {//会议
        int start;
        int end;

        public Progame(int start, int end) {
            this.start = start;
            this.end = end;
        }
    }

    public static class ProgameComparator implements Comparator {
        //按结束时间从早到晚排序
        @Override
        public int compare(Progame o1, Progame o2) {
            return o1.end - o2.end;//o1的结束时间比o2的结束时间晚,o2排前面
            //返回-1(或负数),表示不需要交换o1和o2的位置,o1排在o2前面
            //返回1(或正数),表示需要交换o1和o2的位置,o2排在o1前面
        }
    }

    //progames:需要安排的会议,timePoint:目前的时间点
    public int bestArrange(Progame[] progames, int timePoint) {
        Arrays.sort(progames, new ProgameComparator());//按照ProgameComparator比较器定义的compare()方法来排序
        int result = 0;
        
        for (int i = 0; i < progames.length; i++) {
            if(timePoint <= progames[i].start){//此时时间 <= 会议的开始时间
                result++;//安排好的会议的个数++
                timePoint = progames[i].end;//时间来到会议的结束时间
            }
        }
        
        return result;
    }
}

对于这个策略,我们不能够轻松举出反例,但证明需要使用严格复杂的数学证明

贪心算法在笔试时的解题套路

贪心算法&策略实现_第5张图片

1、准备暴力枚举、全排列的模板,贪心算法的最优解一定在全排列之中

2、贪心策略类题目,是一句某个标准排序或是放在堆里各自排序,举出n多个比较策略。此时容易举出反例的比较策略可以直接pass

3、用策略X结合随机大样本跑对数器。如果某个策略几千万次的随机样本都相同,那么这个比较策略就是正确的

什么是对数器?对数器的作用是什么?-CSDN博客

贪心策略实现

贪心算法&策略实现_第6张图片

切分金条的最小分割代价

哈夫曼编码问题

贪心算法&策略实现_第7张图片

从反方向考虑,已经切好的数组如何合并使得花费最小,花费的金额为合并的数值

贪心策略:每次挑代价最小的2个数来结合

如果有一组数组:arr = {2, 3, 4, 7, 9, 2}

将数组放入小根堆中 arr = {2, 2, 3, 4, 7, 9}
前两个数相加 arr = {4, 3, 4, 7, 9}
排序 arr = {3, 4, 4, 7, 9}
前两个数相加 arr = {7, 4, 7, 9}
排序 arr = {4, 7, 7, 9}
前两个数相加 arr = {11, 7, 9}
排序 arr = {7, 9, 11}
前两个数相加 arr = {16, 11}
排序 arr = {16, 11}
两个数相加 arr = {27}
package greedyalgorithms;

import java.util.PriorityQueue;

public class LessMoneySplitGold {
    public static int lessMoney(int[] arr) {
        PriorityQueue priorityQueue = new PriorityQueue<>();//默认小根堆
        for (int i = 0; i < arr.length; i++) {
            priorityQueue.add(arr[i]);//将数组全部放入小根堆
        }

        int temp = 0;
        while (priorityQueue.size() > 1) {
            temp = priorityQueue.poll() + priorityQueue.poll();//弹出两个相加
            priorityQueue.add(temp);//加回去,排序
        }

        return priorityQueue.poll();//最后小根堆中只有一个数即为结果
    }
}

做项目获得的最大收益

贪心算法&策略实现_第8张图片

costs[]:花费数组,profits[]: 利润数组

这里的花费仅仅表示做项目的门槛,因为在实际题目的计算中并没有减去项目花费的数

实现解析

一组项目:<花费,利润>

<2,3>,  <1,4>,  <1,1>,  <2,7>.,  <3,2>,  <4,10>

将项目放入一个以花费为依据的小根堆中,其中,利润的大小不考虑

小根堆中的项目表示都是锁住(不可做)的状态

小根堆中:<1,4>,  <1,1>,   <2,3>,  <2,7>.,  <3,2>,  <4,10>

依据初始资金m,解锁所有花费小于等于m的项目放到一个以利润为依据的大根堆中,其中,花费的大小不考虑

大根堆中的项目表示解锁(可做)的状态

m = 1; 大根堆中:<1,4>,  <1,1>

大根堆抛出第一个项目,初始资金更新为m+该项目的利润

依据新的初始资金m,在小根堆中解锁项目,在大根堆中抛出,更新利润 .......

直到到达指定的项目数k停止

此外,还有另一种情况。当没有达到指定的项目数k,但某一时刻的初始资金比较少,不能够解锁小根堆中剩下的所有项目,此时只能提前返回当前的资金m

package greedyalgorithms;

import java.util.*;

public class FindMaxmizedCapital {
    int M = 0;//初始资金
    int K = 0;//表示最多做k个项目

    class Program {
        public int cost;//花费
        public int profit;//利润

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

    public int findMaxmizedCapital(List programs, int M, int K) {
        PriorityQueue minCostPQ = new PriorityQueue(new MinCostComparator());
        PriorityQueue maxProfitPQ = new PriorityQueue(new MaxProfitComparator());
        //全部放入小根堆中锁定
        for (Program pr : programs) {
            minCostPQ.add(pr);
        }

        for (int i = 0; i < K; i++) {
            //peek(): 获取元素但不删除队列首元素
            while (!minCostPQ.isEmpty() && minCostPQ.peek().cost <= M) {
                maxProfitPQ.add(minCostPQ.poll());//放入大根堆中,解锁
            }
            //更新初始资金
            M += maxProfitPQ.poll().profit;
            //当没有达到指定的项目数k,但某一时刻的初始资金比较少,不能够解锁小根堆中剩下的所有项目,此时只能提前返回当前的资金m
            if (maxProfitPQ.isEmpty()) {
                break;
            }
        }
        return M;
    }


    class MinCostComparator implements Comparator {
        @Override
        public int compare(Program o1, Program o2) {
            return o1.cost - o2.cost;
            //compare()方法比较o1,o2的大小
            //正序:当o1o2时return 1

        }
    }

    class MaxProfitComparator implements Comparator {
        @Override
        public int compare(Program o1, Program o2) {
            return o2.profit - o1.profit;
        }
    }


}

你可能感兴趣的:(左神算法与数据结构,贪心算法,算法)