贪心算法的相关题目（Java实现）

活动安排问题 ：定义比较器 按照活动的结束时间来进行排序

public 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;
	}
}
//timePoint 表示开始时间点
public static int bestArrange(Program[] programs, int timePoint) {
	Arrays.sort(programs, new ProgramComparator());
	int result = 0;
	for(int i = 0; i < programs.length; i++) {
		if(timePoint <= programs[i].start) {
			result++;   //可以安排的活动数目
			timePoint = programs[i].end;
		}
	}
	return result;
}

字典序问题：给一个字符串，按照返回最大的字符串

//字符串排序问题
public static class MyComparator implements Comparator<String>{
    //用compareTo来比较字符串
	public int compare(String o1, String o2) {
		return (o1 + o2).compareTo(o2 + o1); 
	}
}
public static String lowestString(String[] strs) {
	if(strs == null | strs.length == 0) return null;
	Arrays.sort(strs, new MyComparator());
	StringBuilder res = new StringBuilder();
	for(int i = 0; i < strs.length; i++) {
		res.append(strs[i]);
	}
	return res.toString();
}

题目描述：

//哈夫曼树  最小花费的类似问题
public static int lessMoney(int[] nums) {
	PriorityQueue<Integer> pQ = new PriorityQueue<Integer>();
	for(Integer num : nums) {
		pQ.add(num);   //放进小根堆中  从小到大进行排列
	}
	int sum = 0;
	int cur = 0;
	while(pQ.size() > 1) {
		//每次拿出最小的两个数  进行相加  然后又放到小根堆中去
		cur  = pQ.poll() + pQ.poll();  
		sum += cur;
		pQ.add(cur);
	}
	return sum;
}

题目描述：关于做项目的利润，给两个数组，其中一个为profits，一个为costs，给定k和w，其中k为可做的项目个数，w为启动资金，求最大的利润数

//花费一样时，按照利润来排序
public static class Node{
	public int p;  //利润
	public int c;  //花费
	public Node(int p, int c) {
		this.c = c;
		this.p = p;
	}
}
//定义两个比较器
public static class MinCostComparator implements Comparator<Node>{
	@Override
	public int compare(Node o1, Node o2) {
		return o1.c - o2.c;
	}
}
public static class MaxProfitComparator implements Comparator<Node>{
	@Override
	public int compare(Node o1, Node o2) {
		return o2.p - o1.p;
	}
}

//k 最多选多少个项目   w为初始资金
public static int findMaximizedCapital(int k, int W, int[] profits, int[] costs) {
//其中minCostQ按照花费来存放项目节点
	PriorityQueue<Node> minCostQ = new PriorityQueue<Node>(new MinCostComparator());
//maxProfitQ存放解锁的项目，按照利润来进行排列
	PriorityQueue<Node> maxProfitQ = new PriorityQueue<Node>(new MaxProfitComparator());
	for(int i = 0; i < profits.length; i++) {
		minCostQ.add(new Node(profits[i], costs[i]));
	}
	for(int i = 0; i < k; i++) {
		while(!minCostQ.isEmpty() && minCostQ.peek().c <= W) {
			maxProfitQ.add(minCostQ.poll());
		}
		//即有的钱不足于解锁新的项目 所以提前结束
		if(maxProfitQ.isEmpty()) return W;
		W += minCostQ.poll().p;
	}
	return W;
}

参考牛客网左神的算法讲解视频牛客网