04、贪心算法-会议室宣讲场次最多问题

题目：

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

 1、暴力解决方案

1.1、图解：

 1.2、代码：

public static class Program {
    //会议开始时间
    public int start;
    //会议结束时间
    public int end;

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

//方案1：暴力解法
public static int bestArrange1(Program[] programs) {
    if (programs == null || programs.length == 0) {
        return 0;
    }
    return process(programs, 0, 0);
}

/**
 * 目前来到timeLine的时间点，已经安排了done场的会议，剩下的会议programs可以自由安排
 * 返回能安排的最多会议数量
 *
 * @param programs 还有多少会议可以安排
 * @param done     之前已经安排了多少场会议
 * @param timeLine 目前来到的时间节点是什么
 */

public static int process(Program[] programs, int done, int timeLine) {
    if (programs.length == 0) {
        return done;
    }
    int max = done;
    //当前安排的会议是什么会，每一个都进行穷举
    for (int i = 0; i < programs.length; i++) {
        //如果当前会议的开始时间大于timeLine时间点，才可以进行安排
        if (programs[i].start >= timeLine) {
            //把i号位置的会议从programs中剔除，然后返回剩下的会议
            Program[] next = copyButExcept(programs, i);
            //既然安排了i号位置的会议，那么接下来就就从i号会议的结束时间开始接着进行安排
            //每一个会议都进行穷举，其中一定有一个安排最大的可能性
            max = Math.max(max, process(next, done + 1, programs[i].end));
        }
    }
    return max;
}

//把i号位置的会议从programs中剔除，然后返回剩下的会议
public static Program[] copyButExcept(Program[] programs, int i) {
    Program[] ans = new Program[programs.length - 1];
    int index = 0;
    for (int k = 0; k < programs.length; k++) {
        if (k != i) {
            ans[index++] = programs[k];
        }
    }
    return ans;
}

 2、贪心解决方案

1.1、图解：

 

 

 1.2、思路：

解题思路是按照项目完成时间，从前到后排序，先做最早结束的项目，然后淘汰掉不能再做的项目

 1.3、代码：

//方案2：贪心解法
public static int bestArrange2(Program[] programs) {
    //根据结束时间排序，谁结束早，谁排在前面
    Arrays.sort(programs, new ProgramComparator());
    int timeLine = 0;
    int result = 0;
    for (int i = 0; i < programs.length; i++) {
        if (timeLine <= programs[i].start) {
            result++;
            timeLine = programs[i].end;
        }
    }
    return result;
}

//定义一个比较器，根据结束时间排序，谁结束早，谁排在前面
public static class ProgramComparator implements Comparator<Program> {
    @Override
    public int compare(Program o1, Program o2) {
        return o1.end - o2.end;
    }
}