1、题目

一些项目要占用一个会议室宣讲，会议室不能同时容纳两个项目的宣讲。

给你每一个项目开始的时间和结束的时间

给定每个项目宣讲的开始时间 start 和 结束时间 end，你来安排宣讲的日程，要求会议室进行的宣讲的场次最多。

返回最多的宣讲场次。

2、思路

• 贪心策略1：将所有的 [start, end] 数组放到一个集合 set 中，开始时间早的先宣讲，然后删掉集合中剩下的数组里 start 比当前的宣讲会议的 end 时间早的会议，得到一个 set'，在set'中也是开始时间早的先宣讲，重复这个过程。这个策略是无效的，反例：[1，1000000]，[2，3]，[3，5]，[6，7]，如果按照开始时间最早的进行宣讲，那么只有第一个会议能得到宣讲，但是事实上按照[2,3]，[3,5]，[6,7] 这样的排列是最佳的。
• 贪心策略2：会议持续时间短的会议先宣讲。依然无效，反例：[1，27]，[26，31]，[29，300]。
• 贪心策略3：每次选择会议结束时间最早的。有效策略。例子：[1，5]，[1，2]，[2，8]，[3，6]，[3，11]。
  • 先根据所有会议的结束时间进行排序：[1，2]，[1，5]，[3，6]，[2，8]，[3，11]。
  • 选择[1，2]，则[1，5]被删掉；
  • 接着选结束时间最早的[3，6]，那么[2，8] 和 [3，11] 被删掉；
  • 最终结果就是[1，2] 和 [3，6]。

3、代码

C++版

/************************************************************************* > File Name: 044.安排项目宣讲日程.cpp > Author: Maureen > Mail: [email protected] > Created Time: 四 7/14 22:13:42 2022 ************************************************************************/

#include <iostream>
#include <vector>
#include <ctime>
#include <algorithm>
using namespace std;

class Program {
    
public:
    int start;
    int end;
    
    Program() {
    }
    Program(int s, int e) : start(s), end(e) {
    }
};


vector<Program> copyButExcept(vector<Program> &programs, int i) {
    
    vector<Program> ans(programs.size() - 1);
    int index = 0;
    for (int k = 0; k < programs.size(); k++) {
    
        if (k != i) ans[index++] = programs[k];
    }
    return ans;
}

int process(vector<Program> &programs, int done, int timeLine) {
    
    if (programs.size() == 0) return done;

    int _max = done;
    for (int i = 0; i < programs.size(); i++) {
    
        if (programs[i].start >= timeLine) {
    
            vector<Program> next = copyButExcept(programs, i);
            _max = max(_max, process(next, done + 1, programs[i].end));
        }
    }

    return _max;
}

int bestArrange1(vector<Program> &programs) {
    
    if (programs.size() == 0) return 0;

    return process(programs, 0, 0);
}


//方法二：

bool cmp(Program &a, Program &b) {
    
    return a.end < b.end;
}

int bestArrange2(vector<Program> &programs) {
    
    sort(programs.begin(), programs.end(), cmp);
    
    int timeLine = 0;
    int result = 0;

    for (int i = 0; i < programs.size(); i++) {
    
        if (timeLine <= programs[i].start) {
    
            result++;
            timeLine = programs[i].end;
        }
    }
    return result;
}

//for test 
vector<Program> generatePrograms(int size, int timeMax) {
    
    vector<Program> ans(rand() % (size + 1));
    
    for (int i = 0; i < ans.size(); i++) {
    
        int r1 = rand() % (timeMax + 1);
        int r2 = rand() % (timeMax + 1);

        if (r1 == r2) ans[i] = Program(r1, r1 + 1);
        else ans[i] = Program(min(r1, r2), max(r1, r2));
    }

    return ans;
}

int main() {
    
    srand(time(0));

    int size = 12;
    int timeMax = 20;
    int timeTimes = 1000000;

    for (int i = 0; i < timeTimes + 1; i++) {
    
        vector<Program> programs = generatePrograms(size, timeMax);
        if (bestArrange1(programs) != bestArrange2(programs)) {
    
            cout << "Oops!" << endl;
            break;
        }

        if (i && i % 1000 == 0) cout << i << " cases passed!" << endl;
    }
    
    cout << "finish!" << endl;

    return 0;
}

Java版

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

public class 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 int bestArrange1(Program[] programs) {
    
		if (programs == null || programs.length == 0) {
    
			return 0;
		}
		return process(programs, 0, 0);
	}

	// 还剩下的会议都放在programs里
	// done之前已经安排了多少会议的数量
	// timeLine目前来到的时间点是什么
	
	// 目前来到timeLine的时间点，已经安排了done多的会议，剩下的会议programs可以自由安排
	// 返回能安排的最多会议数量
	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++) {
    
			if (programs[i].start >= timeLine) {
    
				Program[] next = copyButExcept(programs, i);
				max = Math.max(max, process(next, done + 1, programs[i].end));
			}
		}
		return max;
	}

	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;
	}

	// 会议的开始时间和结束时间，都是数值，不会 < 0
	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;
		}

	}

	// for test
	public static Program[] generatePrograms(int programSize, int timeMax) {
    
		Program[] ans = new Program[(int) (Math.random() * (programSize + 1))];
		for (int i = 0; i < ans.length; i++) {
    
			int r1 = (int) (Math.random() * (timeMax + 1));
			int r2 = (int) (Math.random() * (timeMax + 1));
			if (r1 == r2) {
    
				ans[i] = new Program(r1, r1 + 1);
			} else {
    
				ans[i] = new Program(Math.min(r1, r2), Math.max(r1, r2));
			}
		}
		return ans;
	}

	public static void main(String[] args) {
    
		int programSize = 12;
		int timeMax = 20;
		int timeTimes = 1000000;
		for (int i = 0; i < timeTimes; i++) {
    
			Program[] programs = generatePrograms(programSize, timeMax);
			if (bestArrange1(programs) != bestArrange2(programs)) {
    
				System.out.println("Oops!");
			}
		}
		System.out.println("finish!");
	}

}