贪心算法

贪心算法

1. 拼接字符串使字典序最小

比如：“ab”、“cd”、"ef"三个字符串，拼接的结果可以有多种，但是”abcdef“这个结果才是最小的。

1.1 分析：

1. 按单个字符串的字典序进行比较：比如a小于b，则a放b前面

   这种思路是错误的：比如b和ba，字典序肯定是b小，但拼接的时候应该ba放前面，因为结果bab最小

2. 两个字符串拼接之后再比较，看谁放前面比较合适：比如a和b，看ab和ba哪个更小

对于第二种思路，就是一种贪心策略，该策略具有传递性，而且可以证明是正确的

贪心策略证明

1.2 实现

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

public class Solution_dictionarySort {

    public static class MyComparator implements Comparator<String> {

        @Override
        public int compare(String a, String b) {
            //a+b小，返回负数，否则返回正数。
            return (a+b).compareTo(b+a);
        }
    }

    public static String lowestString(String[] strs){
        if(strs == null){
            return null;
        }
        Arrays.sort(strs, new MyComparator());
        String res = "";
        for(String str : strs){
            res += str;
        }
        return res;
    }

    public static void main(String[] args) {
        String[] strs = {"a", "ac", "b", "ba", "efa", "cab"};
        String str = lowestString(strs);
        System.out.println(str);
    }
}

2. 分金条

题目： 一块金条切成两半，是需要花费和长度数值一样的铜板的。比如长度为20的金条，不管切成长度多大的两半，都要花费20个铜板。一群人想整分整块金条，怎么分最省铜板？

例如,给定数组{10,20,30}，代表一共三个人，整块金条长度为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铜板。

要求：时间复杂度为O(NlogN)，空间复杂度为O(N)

输入描述:

第一行一个整数N。表示数组长度。
接下来一行N个整数，表示arr数组。

输出描述

返回分金条的最小花费

思路：哈夫曼编码问题
使用一个小根堆，先将所有数组元素压入其中。每次弹出两个最小元素，相加得到的结果再次压入小根堆中，知道小根堆中只剩一个元素。数组全部压入之后，以后再压入小根堆的数值相加即为结果

import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

//金条划分
public class Solution_GoldenPartition {

    //升序
    public static class MinHeapComparator implements Comparator<Integer>{

        @Override
        public int compare(Integer t1, Integer t2) {
            return t1 - t2;
        }
    }
    //降序
    public static class MaxHeapComparator implements Comparator<Integer>{

        @Override
        public int compare(Integer t1, Integer t2) {
            return t2 - t1;
        }
    }

    public static int goldenPartition(int[] arr){
        if(arr == null){
            return 0;
        }

        int cost = 0;
        //小根堆
        Queue<Integer> queue = new PriorityQueue<Integer>(new MinHeapComparator());
        for(int value : arr){
            queue.offer(value);
        }
        while(queue.size() > 1){
            int temp = queue.poll() + queue.poll();
            cost += temp;
            queue.offer(temp);
        }
        return cost;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n];
        for(int i = 0; i < n; i++){
            arr[i] = sc.nextInt();
        }
        System.out.println(goldenPartition(arr));
    }
}

3. 项目最大收益

题目：某公司需要接一些项目来赚钱，
现有n个项目，每个项目的费用由costs数组表示，其中costs[i]表示第i个项目需要的资金；
每个项目的利润由profits数组表示，其中profits[i]表示第i个项目的纯利润。
这个公司的总资金为w，且这个公司一次只能做一个项目，每个项目只能做一次，该公司最多能做k个项目。
求该公司能获得的最大收益为多少。

思路：

1. 构造一个大根堆maxProfit，一个小根堆minCost，自定义一个类Project，包含两个属性cost和profit
2. 将所有project对象存入小根堆
3. 如果小根堆的堆订，即cost最小的project对象，其cost小于总资金w的话，将该对象弹出，并存入大根堆
4. 如果大根堆不为空，则堆订元素即为要完成的项目，将其利润加到总资金里，从大根堆弹出该project对象
5. 重复第三步和第四部，知道大根堆为空（当前资金不足以进行新的项目），或项目次数已用完。

import java.util.*;

public class Solution_MaxProfit {

    public static class Project{
        int profit;
        int cost;
        public Project(int cost, int profit){
            this.profit = profit;
            this.cost = cost;
        }
    }

    //升序
    public static class CostComparator implements Comparator<Project>{

        @Override
        public int compare(Project t1, Project t2) {
            return t1.cost - t2.cost;
        }
    }

    //降序
    public static class ProfitComparator implements Comparator<Project>{

        @Override
        public int compare(Project t1, Project t2) {
            return t2.profit - t1.profit;
        }
    }

    public static int maxProfit(int k, int w, int[] costs, int[] profits){

        int profit = 0;
        int len = costs.length;
        Queue<Project> minCost = new PriorityQueue<>(new CostComparator());
        Queue<Project> maxProfit = new PriorityQueue<>(new ProfitComparator());
        Project project = null;
        for(int i = 0; i < len; i++){//将所有项目存入minCost队列
            minCost.add(new Project(costs[i], profits[i]));
        }
        while(k > 0){
            while(minCost.size() > 0 && minCost.peek().cost <= w){
                //如果minCost队头的项目花费小于资金，将该项目弹出minCost并加入maxProfit
                maxProfit.add(minCost.poll());
            }
            if(maxProfit.isEmpty()){//手头的资金不足以进行下一个花费最小的项目
                return profit;
            }
            project = maxProfit.poll();
            profit += project.profit;//利润增加
            w += project.profit;//总金额增加
            k--;
        }
        return profit;
    }

    public static void main(String[] args) {
        System.out.println("请输入项目的个数");
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.println("请输入每个项目的花费");
        int[] costs = new int[n];
        for(int i = 0; i < n; i++){
            costs[i] = sc.nextInt();
        }
        System.out.println("请输入每个项目的利润");
        int[] profits = new int[n];
        for(int i = 0; i < n; i++){
            profits[i] = sc.nextInt();
        }
        System.out.println("请分别输入该公司的总资金和接项目的次数");
        int w = sc.nextInt();
        int k = sc.nextInt();

        System.out.println("最大利润为：" + maxProfit(k, w, costs, profits));
    }
}

4. 合理安排会议

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

贪心策略：

1. 最早开始的会议优先：反例：最先开始的占全天时间。
2. 持续时间最短的会议优先：反例：这一天只有三个会议，[][][][][6:00,12:00]、[11:00,13:00]、[12:00,20:00]
3. 最先结束的会议优先：该策略为正确的贪心策略。

import java.util.*;

public class Solution_ArrangeMeeting {

    public static class Meeting{
        int start;
        int end;
        int last;//持续时间
        public Meeting(int start, int end){
            this.start = start;
            this.end = end;
            this.last = end - start;
        }
    }

    public static class MyComparator implements Comparator<Meeting>{

        @Override
        public int compare(Meeting t1, Meeting t2) {
            return t1.end - t2.end;
        }
    }

    public static int arrangeMeeting(int[] start, int[] end, int current){//current为当前时刻
        if(start == null){
            return 0;
        }
        int count = 0;//安排的会议数
        int len = start.length;
        Meeting[] meetings = new Meeting[len];
        for(int i = 0; i < len; i++){//将会议存入数组中
            meetings[i] = new Meeting(start[i], end[i]);
        }
        Arrays.sort(meetings, new MyComparator());//根据会议的结束时间先后排序
        for(int i = 0; ; i++){
            if(current > meetings[len - 1].start){//当前时间晚于最后一场会议的开始时间
                break;
            }
            if(current <= meetings[i].start){//遍历数组，发现一个会议的开始时间不早于当前时间，安排
                count++;
                current = meetings[i].end;//开完会后，当前时间推移
            }
        }
        return count;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入会议个数：");
        int n = sc.nextInt();
        System.out.println("请分别输入会议开始时间：");
        int[] start = new int[n];
        for(int i = 0; i < n; i++){
            start[i] = sc.nextInt();
        }
        System.out.println("请分别输入会议结束时间：");
        int[] end = new int[n];
        for(int i = 0; i < n; i++){
            end[i] = sc.nextInt();
        }
        int count = arrangeMeeting(start, end, 0);
        System.out.println("共能安排的会议数为：" + count);
    }
}

5. leetcode

安排工作以达到最大收益