牛客网 左程云老师的算法入门课
贪心算法
贪心算法的解题步骤 ![](https://i-blog.csdnimg.cn/blog_migrate/dfc19760366c5a31dbb000056732db9c.png)
例子
题目要求
解题策略
-
按照结束时间早的会议先安排,比如先安排【2,4】,当4结束了,所有开始时间小于4的全部淘汰,【1,7】、【3,4】,【2,8】,将【5,6】加入安排,将【7,10】加入安排
代码
// package class07;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
public class Code04_BestArrange {
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[] 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 int bestArrangeForce(Program[] programs,int timePoint){
HashSet<Program> set = new HasgSet<>(Arrays.asList(programs));
}
//会议的集合是set,当前时间是timePoint
//返回集合中最多可以安排几个项目
public static int process(HashSet<Program>set ,int timepoint){
HashSet<Program> candidates = new HashSet<>();
for(Program program : set){
if(program.start >= timepoint){
candidates.add(program);
}
}
//tmp只是为了使用迭代器
HashSet<Program> tmp = new HashSet<>(candidates);
int result = 0;
//尝试将每一个项目,作为第一个安排的项目
for(Program program : tmp){
candidates.remove(program);
int next = process(candidates, program.end);
result = Math.max(result,next+1);
candidates.add(program);
}
return result;
}
public static void main(String[] args) {
}
}
- 注意事项:对于HashSet集合中的元素,不可以一边遍历一边删除。需要使用一个tmp集合,将满足条件条件的元素放到tmp中,然后遍历tmp集合,删除原有的集合中的元素
- 例子:将1到8元素放入到集合set中,需要删除集合中小于5的元素,所以遍历set集合,将小于5的元素收集到tmp集合中,然后遍历tmp集合,删除set集合中小于5的元素,最后遍历打印set集合。
代码
HashSet<Integer> set = new HashSet<>();
set.add(1);
set.add(2);
set.add(3);
set.add(4);
set.add(5);
set.add(6);
set.add(7);
set.add(8);
HashSet<Integer> tmp = new HashSet<>();
//删除集合中比5小的数
//不可以一边遍历一边删除元素
for(Integer i : set){
if(i < 5){
tmp.add(i);
}
}
for(Integer i : tmp){
set.remove(i);
}
for(Integer i : set){
System.out.println(i);
}
}
题目要求
给定一个字符串类型的数组str,找到一种拼接方式,使得所有字符串拼接起来形成的字符串具有最小的字典序
- 字典序:两个字符串在字典中谁先放在前面,谁的字典序就低
- 思路:两个字符串,str1和str2,如果str1+str2的字典顺序小于str2+str1,则将str1放到str2的前面,否则将str2放到str1的前面
- 排序具有传递性,不可以歧义,如果是闭环结构是不可以排序的
- “abc”*“xy” ==> "abc" * K^2 + "xy" ;* K^2好比与将abc字符串向左边移动2位,K暗指字符串是K进制的数字,数字2是指第二个需要拼接字符串的位数,然后加上字符串xy,整个的过程就像数字运算一样。
- 使用m(str)= return(K^string长度),所以“abc”*“xy” ==> "abc" * K^2 + "xy" ==> "abc" * m(xy) + "xy"
代码
package class07;
import java.util.Arrays;
import java.util.Comparator;
public class Code02_LowestLexicography {
public static class MyComparator implements Comparator<String> {
@Override
public int compare(String a, String b) {
return (a + b).compareTo(b + a);
}
}
public static String lowestString(String[] strs) {
if (strs == null || strs.length == 0) {
return "";
}
Arrays.sort(strs, new MyComparator());
String res = "";
for (int i = 0; i < strs.length; i++) {
res += strs[i];
}
return res;
}
public static void main(String[] args) {
String[] strs1 = { "jibw", "ji", "jp", "bw", "jibw" };
System.out.println(lowestString(strs1));
String[] strs2 = { "ba", "b" };
System.out.println(lowestString(strs2));
}
}
图片解析
- 根据给出的条件a . b 小于等于 b . a 和 b. c 小于等于 c . b得出a . c 小于等于 c . a,根据上面的式子,得出右边的不等式,将第一个不等式的两边减去b 再乘以 c;第二个不等式左右两边 减去c 乘以a ,这样两个式子会产生一个重合的项,链接其余不等式,化简之后就可以得到 m(c)* a + c 小于等于 m(a)*c + a
比较排序的过程:
分金条问题
思路
- 利用小根堆来做,每次选取其中最小的两个数,合并成为一个数,放入到堆中,依次类推。当小根堆里面只有一个数字的时候,就是最终的答案。(哈夫曼编码)
代码
package class07;
import java.util.Comparator;
import java.util.PriorityQueue;
public class Code03_LessMoneySplitGold {
public static int lessMoney(int[] arr) {
PriorityQueue<Integer> pQ = new PriorityQueue<>();
for (int i = 0; i < arr.length; i++) {
pQ.add(arr[i]);
}
int sum = 0;
int cur = 0;
while (pQ.size() > 1) {
cur = pQ.poll() + pQ.poll();
sum += cur;
pQ.add(cur);
}
return sum;
}
public static class MinheapComparator implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2; // < 0 o1 < o2 负数
}
}
public static class MaxheapComparator implements Comparator<Integer> {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1; // < o2 < o1
}
}
public static void main(String[] args) {
// solution
int[] arr = { 6, 7, 8, 9 };
System.out.println(lessMoney(arr));
int[] arrForHeap = { 3, 5, 2, 7, 0, 1, 6, 4 };
// min heap
PriorityQueue<Integer> minQ1 = new PriorityQueue<>();
for (int i = 0; i < arrForHeap.length; i++) {
minQ1.add(arrForHeap[i]);
}
while (!minQ1.isEmpty()) {
System.out.print(minQ1.poll() + " ");
}
System.out.println();
// min heap use Comparator
PriorityQueue<Integer> minQ2 = new PriorityQueue<>(new MinheapComparator());
for (int i = 0; i < arrForHeap.length; i++) {
minQ2.add(arrForHeap[i]);
}
while (!minQ2.isEmpty()) {
System.out.print(minQ2.poll() + " ");
}
System.out.println();
// max heap use Comparator
PriorityQueue<Integer> maxQ = new PriorityQueue<>(new MaxheapComparator());
for (int i = 0; i < arrForHeap.length; i++) {
maxQ.add(arrForHeap[i]);
}
while (!maxQ.isEmpty()) {
System.out.print(maxQ.poll() + " ");
}
}
}
求获取的最大钱数
例子
- 按照花费的钱建立小根堆,这个是被锁定的状态,根据初始的钱,比如w=2,解锁(1,3)和(2,6) ,按照利润的高低,压入利润大根堆中,(2,6)(1,3)加入栈中,然后将其从小根堆中删除。然后做第一个项目(2,6),此时自己的钱数为8,那么将小于8的花费的项目解锁,以此类推。
代码
package class07;
import java.util.Comparator;
import java.util.PriorityQueue;
public class Code05_IPO {
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 - o2.c;
}
}
public static class MaxProfitComparator implements Comparator<Node> {
@Override
public int compare(Node o1, Node o2) {
return o2.p - o1.p;
}
}
public static int findMaximizedCapital(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 < Profits.length; i++) {
minCostQ.add(new Node(Profits[i], Capital[i]));
}
for (int i = 0; i < k; i++) { // 进行K轮
// 能力所及的项目,全解锁
while (!minCostQ.isEmpty() && minCostQ.peek().c <= W) {
maxProfitQ.add(minCostQ.poll());
}
if (maxProfitQ.isEmpty()) {
return W;
}
W += maxProfitQ.poll().p;
}
return W;
}
}