Algorithm 为什么需要在“中首先对数组进行排序”；会议室2“；Leetcode的名字？

以下是Leetcode中的“会议室2”问题：

给定由开始和结束组成的会议时间间隔数组 乘以[[s1，e1]，[s2，e2]，…]（si 例如，给定[[0,30]，[5,10]，[15,20]]，返回2

众所周知，一种可能的解决方案是在比较相邻会议的开始和结束时间之前对间隔数组进行排序

公共内部会议室（间隔[]间隔）{
排序（间隔，新的比较器（）{
公共整数比较（区间a、区间b）{
返回a.start-b.start；
}
});
List List=newarraylist（Arrays.asList（interval））；
整数计数=0；
而（！list.isEmpty（））{
int end=list.remove（0）.end；count++；//创建新的时间线
迭代器ite=list.Iterator（）；
while（ite.hasNext（））{
间隔next=ite.next（）；
如果（next.start>=end）{//添加到当前时间线
end=next.end；
删除（）；
}
}
}
返回计数；
}

但假设我们有以下代码来检测两次会议之间的时间冲突

private boolean isConflict（区间a、区间b）{
布尔abfb=（a.start
例如，生成多组间隔为1个单位的会议：例如，3、4、5和6个单位的会议

[[1, 3], [4, 6], [7, 9], ...]
[[1, 4], [5, 8], [9, 12], ...]
[[1, 5], [6, 10], [11, 15], ...]
[[1, 6], [7, 12], [13, 18], ...]

按顺序将它们输入到您的算法中，您将得到最佳的4个房间。随机洗牌它们，您将需要5或6个房间。
您的“贪婪”算法不会对某些输入集的会议室进行最佳利用。它接受在会议间隔列表中找到的第一个匹配。相反，它需要对每个可用的会议间隔进行最接近的匹配。实现这一点的一种方法是按开始时间对会议间隔进行排序；这样，它将始终在最近的会议间隔中找到最早的可用会议一个已经完成

例如，生成多组间隔为1个单位的会议：例如，3、4、5和6个单位的会议

[[1, 3], [4, 6], [7, 9], ...]
[[1, 4], [5, 8], [9, 12], ...]
[[1, 5], [6, 10], [11, 15], ...]
[[1, 6], [7, 12], [13, 18], ...]

按顺序将它们输入到算法中，您将得到最佳的4个房间。随机洗牌它们，您将需要5或6个房间。
您不需要对数组进行排序。它可以在O（n）时间复杂度内解决。其想法是创建一个
计数
数组，并在索引
开始[i]处用
+1
更新它
和
-1
在索引
end[i]
start
和
end
中是会议的相应开始和结束时间的数组

之后，只需将所有
+1
和
-1
相加，形成精确的计数数组，然后返回该数组中存在的最大值。下面是伪代码：

int[] count = new int[100];
for(int i=0;i<start.length;i++){
    count[start[i]] += 1;
    count[end[i]] -= 1;
}
//form the count array with exact values in this loop
count[0] = 0;
for(int i =0;i<count.length;i++){
    count[i] = count[i] + count[i-1];
}
return max(count);

int[]计数=新的int[100]；
对于（int i=0；i您不需要对数组进行排序。它可以在O（n）时间复杂度内求解。其思想是创建一个
计数
数组，并在索引
开始[i]
处用
+1
更新它，在索引
结束[i]处用
-1
更新它
start
和
end
是会议的相应开始和结束时间的数组

之后，只需将所有
+1
和
-1
相加，形成精确的计数数组，然后返回该数组中存在的最大值。下面是伪代码：

int[] count = new int[100];
for(int i=0;i<start.length;i++){
    count[start[i]] += 1;
    count[end[i]] -= 1;
}
//form the count array with exact values in this loop
count[0] = 0;
for(int i =0;i<count.length;i++){
    count[i] = count[i] + count[i-1];
}
return max(count);

int[]计数=新的int[100]；
对于（int i=0；ithx很多！这里有一个控制示例：
[[5,10]，[1,3]，[2,5]，[9,12]，[10,14]，[3,9]
只需要2个房间：
[[1,3]，[3,9]，[9,12]
和
[2,5]，[5,10]，[10,14]
。但是我们会找到3个没有排序的房间：
[1,3]，[5,10,14]，[code>和
[2,5]，[9]
太多了！这里有一个对比示例：
[[5,10]、[1,3]、[2,5]、[9,12]、[10,14]、[3,9]
只需要2个房间：
[[1,3]、[3,9]、[9,12]
和
[2,5]、[5,10]、[10,14]
。但是我们会找到3个没有排序的房间：
和
[2,5]、[9]、[9]
实际上，您可以在
O（n）
中执行此操作，而不需要任何复杂的代码。是的，我们也不需要以那种方式进行排序。但是您需要
O（max（start，end））
空间。实际上，您可以在
O（n）
中执行此操作，而不需要任何复杂的代码。是的，我们也不需要以那种方式进行排序。但是您需要
O（max）（开始，结束））
space。我喜欢这个解决方案。唯一的问题可能是它需要一个非常大的数组：）但总的来说，这个想法很好！@weiShen:事实上不是。如果你仔细观察你的问题，问题中给出的时间段与一天中的时间有关。因此，任何值都可以假设为小于24！因为这是一天中的时间小时！我相信这可以充分利用我们的空间！：）我喜欢这个解决方案。唯一的问题可能是它需要一个非常大的阵列：）但总的来说，这个想法很好！@weiShen:事实上不是。如果你仔细观察你的问题，问题中给出的时间段与一天中的时间有关。因此，任何值都可以假设为小于24！因为这是一天中的时间小时！我相信这可以充分利用我们的空间！：）